git.sur5r.net Git - openldap/blob - servers/slapd/syncrepl.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Replication Engine which uses the LDAP Sync protocol
   4  */
   5 /*
   6  * Copyright 2003 The OpenLDAP Foundation, All Rights Reserved.
   7  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   8  */
   9 /* Copyright (c) 2003 by International Business Machines, Inc.
  10  *
  11  * International Business Machines, Inc. (hereinafter called IBM) grants
  12  * permission under its copyrights to use, copy, modify, and distribute this
  13  * Software with or without fee, provided that the above copyright notice and
  14  * all paragraphs of this notice appear in all copies, and that the name of IBM
  15  * not be used in connection with the marketing of any product incorporating
  16  * the Software or modifications thereof, without specific, written prior
  17  * permission.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
  20  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  21  * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
  22  * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
  23  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
  24  * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
  25  */
  26 /* Modified by Howard Chu
  27  *
  28  * Copyright (c) 2003 by Howard Chu, Symas Corporation
  29  *
  30  * Modifications provided under the terms of the OpenLDAP public license.
  31  */
  32
  33 #include "portable.h"
  34
  35 #include <stdio.h>
  36
  37 #include <ac/string.h>
  38 #include <ac/socket.h>
  39
  40 #include "ldap_pvt.h"
  41 #include "lutil.h"
  42 #include "slap.h"
  43 #include "lutil_ldap.h"
  44
  45 #include "ldap_rq.h"
  46
  47 #define SYNCREPL_STR    "syncreplxxx"
  48 #define CN_STR  "cn="
  49
  50 static const struct berval slap_syncrepl_bvc = BER_BVC(SYNCREPL_STR);
  51 static const struct berval slap_syncrepl_cn_bvc = BER_BVC(CN_STR SYNCREPL_STR);
  52
  53 static void
  54 syncrepl_del_nonpresent( Operation *, syncinfo_t * );
  55
  56 /* callback functions */
  57 static int dn_callback( struct slap_op *, struct slap_rep * );
  58 static int nonpresent_callback( struct slap_op *, struct slap_rep * );
  59 static int null_callback( struct slap_op *, struct slap_rep * );
  60
  61 static AttributeDescription *sync_descs[4];
  62
  63 struct runqueue_s syncrepl_rq;
  64
  65 void
  66 init_syncrepl(syncinfo_t *si)
  67 {
  68         int i, j, k, n;
  69         char **tmp;
  70
  71         if ( !sync_descs[0] ) {
  72                 sync_descs[0] = slap_schema.si_ad_objectClass;
  73                 sync_descs[1] = slap_schema.si_ad_structuralObjectClass;
  74                 sync_descs[2] = slap_schema.si_ad_entryCSN;
  75                 sync_descs[3] = NULL;
  76         }
  77
  78         for ( n = 0; si->si_attrs[ n ] != NULL; n++ ) /* empty */;
  79
  80         if ( n ) {
  81                 /* Delete Attributes */
  82                 for ( i = 0; sync_descs[i] != NULL; i++ ) {
  83                         for ( j = 0; si->si_attrs[j] != NULL; j++ ) {
  84                                 if ( strcmp( si->si_attrs[j], sync_descs[i]->ad_cname.bv_val )
  85                                         == 0 )
  86                                 {
  87                                         ch_free( si->si_attrs[j] );
  88                                         for ( k = j; si->si_attrs[k] != NULL; k++ ) {
  89                                                 si->si_attrs[k] = si->si_attrs[k+1];
  90                                         }
  91                                 }
  92                         }
  93                 }
  94                 for ( n = 0; si->si_attrs[ n ] != NULL; n++ ) /* empty */;
  95                 tmp = ( char ** ) ch_realloc( si->si_attrs, (n + 4)*sizeof( char * ));
  96                 if ( tmp == NULL ) {
  97 #ifdef NEW_LOGGING
  98                         LDAP_LOG( OPERATION, ERR, "out of memory\n", 0,0,0 );
  99 #else
 100                         Debug( LDAP_DEBUG_ANY, "out of memory\n", 0,0,0 );
 101 #endif
 102                 }
 103         } else {
 104                 tmp = ( char ** ) ch_realloc( si->si_attrs, 5 * sizeof( char * ));
 105                 if ( tmp == NULL ) {
 106 #ifdef NEW_LOGGING
 107                         LDAP_LOG( OPERATION, ERR, "out of memory\n", 0,0,0 );
 108 #else
 109                         Debug( LDAP_DEBUG_ANY, "out of memory\n", 0,0,0 );
 110 #endif
 111                 }
 112                 tmp[ n++ ] = ch_strdup( "*" );
 113         }
 114
 115         si->si_attrs = tmp;
 116
 117         /* Add Attributes */
 118
 119         for ( i = 0; sync_descs[ i ] != NULL; i++ ) {
 120                 si->si_attrs[ n++ ] = ch_strdup ( sync_descs[i]->ad_cname.bv_val );
 121                 si->si_attrs[ n ] = NULL;
 122         }
 123 }
 124
 125 static int
 126 ldap_sync_search(
 127         syncinfo_t *si,
 128         void *ctx,
 129         struct berval *syncCookie )
 130 {
 131         BerElementBuffer berbuf;
 132         BerElement *ber = (BerElement *)&berbuf;
 133         LDAPControl c[2], *ctrls[3];
 134         struct timeval timeout;
 135         ber_int_t       msgid;
 136         int rc;
 137
 138         /* setup LDAP SYNC control */
 139         ber_init2( ber, NULL, LBER_USE_DER );
 140         ber_set_option( ber, LBER_OPT_BER_MEMCTX, &ctx );
 141
 142         if ( syncCookie ) {
 143                 ber_printf( ber, "{eO}", abs(si->si_type), syncCookie );
 144         } else {
 145                 ber_printf( ber, "{e}", abs(si->si_type) );
 146         }
 147
 148         if ( (rc = ber_flatten2( ber, &c[0].ldctl_value, 0 )) == LBER_ERROR ) {
 149                 ber_free_buf( ber );
 150                 return rc;
 151         }
 152
 153         c[0].ldctl_oid = LDAP_CONTROL_SYNC;
 154         c[0].ldctl_iscritical = si->si_type < 0;
 155         ctrls[0] = &c[0];
 156
 157         if ( si->si_authzId ) {
 158                 c[1].ldctl_oid = LDAP_CONTROL_PROXY_AUTHZ;
 159                 ber_str2bv( si->si_authzId, 0, 0, &c[1].ldctl_value );
 160                 c[1].ldctl_iscritical = 1;
 161                 ctrls[1] = &c[1];
 162                 ctrls[2] = NULL;
 163         } else {
 164                 ctrls[1] = NULL;
 165         }
 166
 167         timeout.tv_sec = si->si_tlimit > 0 ? si->si_tlimit : 1;
 168         timeout.tv_usec = 0;
 169
 170         rc = ldap_search_ext( si->si_ld, si->si_base.bv_val, si->si_scope,
 171                 si->si_filterstr.bv_val, si->si_attrs, si->si_attrsonly,
 172                 ctrls, NULL, si->si_tlimit < 0 ? NULL : &timeout,
 173                 si->si_slimit, &msgid );
 174         ber_free_buf( ber );
 175
 176         return rc;
 177 }
 178
 179 static const Listener dummy_list = { {0, ""}, {0, ""} };
 180
 181 static int
 182 do_syncrep1(
 183         Operation *op,
 184         syncinfo_t *si )
 185 {
 186         int     rc;
 187
 188         char syncrepl_cbuf[sizeof(CN_STR SYNCREPL_STR)];
 189         struct berval syncrepl_cn_bv;
 190         BerVarray syncCookie;
 191
 192         si->si_sync_mode = LDAP_SYNC_STATE_MODE;
 193
 194         /* Init connection to master */
 195
 196         rc = ldap_initialize( &si->si_ld, si->si_provideruri );
 197         if ( rc != LDAP_SUCCESS ) {
 198 #ifdef NEW_LOGGING
 199                 LDAP_LOG( OPERATION, ERR,
 200                         "do_syncrepl: ldap_initialize failed (%s)\n",
 201                         si->si_provideruri, 0, 0 );
 202 #else
 203                 Debug( LDAP_DEBUG_ANY,
 204                         "do_syncrepl: ldap_initialize failed (%s)\n",
 205                         si->si_provideruri, 0, 0 );
 206 #endif
 207                 return rc;
 208         }
 209
 210         op->o_protocol = LDAP_VERSION3;
 211         ldap_set_option( si->si_ld, LDAP_OPT_PROTOCOL_VERSION, &op->o_protocol );
 212
 213         /* Bind to master */
 214
 215         if ( si->si_tls ) {
 216                 rc = ldap_start_tls_s( si->si_ld, NULL, NULL );
 217                 if( rc != LDAP_SUCCESS ) {
 218 #ifdef NEW_LOGGING
 219                         LDAP_LOG ( OPERATION, ERR, "do_syncrepl: "
 220                                 "%s: ldap_start_tls failed (%d)\n",
 221                                 si->si_tls == SYNCINFO_TLS_CRITICAL ? "Error" : "Warning",
 222                                 rc, 0 );
 223 #else
 224                         Debug( LDAP_DEBUG_ANY,
 225                                 "%s: ldap_start_tls failed (%d)\n",
 226                                 si->si_tls == SYNCINFO_TLS_CRITICAL ? "Error" : "Warning",
 227                                 rc, 0 );
 228 #endif
 229                         if( si->si_tls == SYNCINFO_TLS_CRITICAL ) goto done;
 230                 }
 231         }
 232
 233         if ( si->si_bindmethod == LDAP_AUTH_SASL ) {
 234 #ifdef HAVE_CYRUS_SASL
 235                 void *defaults;
 236
 237                 if ( si->si_secprops != NULL ) {
 238                         rc = ldap_set_option( si->si_ld,
 239                                 LDAP_OPT_X_SASL_SECPROPS, si->si_secprops);
 240
 241                         if( rc != LDAP_OPT_SUCCESS ) {
 242 #ifdef NEW_LOGGING
 243                                 LDAP_LOG ( OPERATION, ERR, "do_bind: Error: "
 244                                         "ldap_set_option(%s,SECPROPS,\"%s\") failed!\n",
 245                                         si->si_provideruri, si->si_secprops, 0 );
 246 #else
 247                                 Debug( LDAP_DEBUG_ANY, "Error: ldap_set_option "
 248                                         "(%s,SECPROPS,\"%s\") failed!\n",
 249                                         si->si_provideruri, si->si_secprops, 0 );
 250 #endif
 251                                 goto done;
 252                         }
 253                 }
 254
 255                 defaults = lutil_sasl_defaults( si->si_ld,
 256                         si->si_saslmech, si->si_realm,
 257                         si->si_authcId, si->si_passwd, si->si_authzId );
 258
 259                 rc = ldap_sasl_interactive_bind_s( si->si_ld,
 260                                 si->si_binddn,
 261                                 si->si_saslmech,
 262                                 NULL, NULL,
 263                                 LDAP_SASL_QUIET,
 264                                 lutil_sasl_interact,
 265                                 defaults );
 266
 267                 lutil_sasl_freedefs( defaults );
 268
 269                 /* FIXME : different error behaviors according to
 270                  *      1) return code
 271                  *      2) on err policy : exit, retry, backoff ...
 272                  */
 273                 if ( rc != LDAP_SUCCESS ) {
 274 #ifdef NEW_LOGGING
 275                         LDAP_LOG ( OPERATION, ERR, "do_syncrepl: "
 276                                 "ldap_sasl_interactive_bind_s failed (%d)\n",
 277                                 rc, 0, 0 );
 278 #else
 279                         Debug( LDAP_DEBUG_ANY, "do_syncrepl: "
 280                                 "ldap_sasl_interactive_bind_s failed (%d)\n",
 281                                 rc, 0, 0 );
 282 #endif
 283                         goto done;
 284                 }
 285 #else /* HAVE_CYRUS_SASL */
 286                 /* Should never get here, we trapped this at config time */
 287                 fprintf( stderr, "not compiled with SASL support\n" );
 288                 rc = LDAP_OTHER;
 289                 goto done;
 290 #endif
 291         } else {
 292                 rc = ldap_bind_s( si->si_ld, si->si_binddn, si->si_passwd, si->si_bindmethod );
 293                 if ( rc != LDAP_SUCCESS ) {
 294 #ifdef NEW_LOGGING
 295                         LDAP_LOG ( OPERATION, ERR, "do_syncrepl: "
 296                                 "ldap_bind_s failed (%d)\n", rc, 0, 0 );
 297 #else
 298                         Debug( LDAP_DEBUG_ANY, "do_syncrepl: "
 299                                 "ldap_bind_s failed (%d)\n", rc, 0, 0 );
 300 #endif
 301                         goto done;
 302                 }
 303         }
 304
 305         /* get syncrepl cookie of shadow replica from subentry */
 306
 307         assert( si->si_id < 1000 );
 308         syncrepl_cn_bv.bv_val = syncrepl_cbuf;
 309         syncrepl_cn_bv.bv_len = snprintf(syncrepl_cbuf, sizeof(syncrepl_cbuf),
 310                 CN_STR "syncrepl%d", si->si_id );
 311         build_new_dn( &op->o_req_ndn, &si->si_base, &syncrepl_cn_bv,
 312                 op->o_tmpmemctx );
 313         op->o_req_dn = op->o_req_ndn;
 314
 315         syncCookie = NULL;
 316         backend_attribute( op, NULL, &op->o_req_ndn,
 317                 slap_schema.si_ad_syncreplCookie, &syncCookie );
 318
 319         rc = ldap_sync_search( si, op->o_tmpmemctx, syncCookie );
 320         if( rc != LDAP_SUCCESS ) {
 321 #ifdef NEW_LOGGING
 322                 LDAP_LOG ( OPERATION, ERR, "do_syncrepl: "
 323                         "ldap_search_ext: %s (%d)\n", ldap_err2string( rc ), rc, 0 );
 324 #else
 325                 Debug( LDAP_DEBUG_ANY, "do_syncrepl: "
 326                         "ldap_search_ext: %s (%d)\n", ldap_err2string( rc ), rc, 0 );
 327 #endif
 328         }
 329         if ( syncCookie ) {
 330                 ber_dupbv( &si->si_syncCookie, syncCookie );
 331                 ber_bvarray_free_x( syncCookie, op->o_tmpmemctx );
 332         }
 333
 334 done:
 335         if ( rc ) {
 336                 if ( si->si_ld ) {
 337                         ldap_unbind( si->si_ld );
 338                         si->si_ld = NULL;
 339                 }
 340         }
 341
 342         return rc;
 343 }
 344
 345 static int
 346 do_syncrep2(
 347         Operation *op,
 348         syncinfo_t *si )
 349 {
 350         LDAPControl     **rctrls = NULL;
 351         LDAPControl     *rctrlp;
 352
 353         BerElementBuffer berbuf;
 354         BerElement      *ber = (BerElement *)&berbuf;
 355
 356         LDAPMessage     *res = NULL;
 357         LDAPMessage     *msg = NULL;
 358
 359         char            *retoid = NULL;
 360         struct berval   *retdata = NULL;
 361
 362         int             sync_info_arrived = 0;
 363         Entry           *entry = NULL;
 364
 365         int             syncstate;
 366         struct berval   syncUUID = { 0, NULL };
 367         struct berval   syncCookie = { 0, NULL };
 368         struct berval   syncCookie_req;
 369
 370         int     rc;
 371         int     err;
 372         ber_len_t       len;
 373         int     syncinfo_arrived = 0;
 374
 375         slap_callback   cb;
 376
 377         int rc_efree;
 378
 379         struct berval   *psub;
 380         Modifications   *modlist = NULL;
 381
 382         const char              *text;
 383         int                             match;
 384
 385         struct timeval *tout_p = NULL;
 386         struct timeval tout = { 0, 0 };
 387
 388         if ( slapd_abrupt_shutdown ) {
 389                 rc = -2;
 390                 goto done;
 391         }
 392
 393 #ifdef NEW_LOGGING
 394         LDAP_LOG ( OPERATION, DETAIL1, "do_syncrep2\n", 0, 0, 0 );
 395 #else
 396         Debug( LDAP_DEBUG_TRACE, "=>do_syncrep2\n", 0, 0, 0 );
 397 #endif
 398
 399         op->o_callback = &cb;
 400
 401         psub = &si->si_be->be_nsuffix[0];
 402
 403         syncCookie_req = si->si_syncCookie;
 404
 405         if ( abs(si->si_type) == LDAP_SYNC_REFRESH_AND_PERSIST ){
 406                 tout_p = &tout;
 407         } else {
 408                 tout_p = NULL;
 409         }
 410
 411         while (( rc = ldap_result( si->si_ld, LDAP_RES_ANY, LDAP_MSG_ONE, tout_p, &res ))
 412                 > 0 )
 413         {
 414                 if ( slapd_abrupt_shutdown ) {
 415                         rc = -2;
 416                         goto done;
 417                 }
 418                 for( msg = ldap_first_message( si->si_ld, res );
 419                   msg != NULL;
 420                   msg = ldap_next_message( si->si_ld, msg ) )
 421                 {
 422                         syncCookie.bv_len = 0; syncCookie.bv_val = NULL;
 423                         switch( ldap_msgtype( msg ) ) {
 424                         case LDAP_RES_SEARCH_ENTRY:
 425                                 ldap_get_entry_controls( si->si_ld, msg, &rctrls );
 426                                 if ( rctrls ) {
 427                                         rctrlp = *rctrls;
 428                                         ber_init2( ber, &rctrlp->ldctl_value, LBER_USE_DER );
 429                                         ber_scanf( ber, "{em", &syncstate, &syncUUID );
 430                                         if ( ber_peek_tag( ber, &len ) == LDAP_SYNC_TAG_COOKIE ) {
 431                                                 ber_scanf( ber, "m}", &syncCookie );
 432                                         }
 433                                 }
 434                                 entry = syncrepl_message_to_entry( si, op, msg,
 435                                         &modlist, syncstate );
 436                                 rc_efree = syncrepl_entry( si, op, entry, modlist,
 437                                                 syncstate, &syncUUID, !syncinfo_arrived );
 438                                 if ( syncCookie.bv_len ) {
 439                                         syncrepl_updateCookie( si, op, psub, &syncCookie );
 440                                 }
 441                                 if ( rctrls ) {
 442                                         ldap_controls_free( rctrls );
 443                                 }
 444                                 if ( modlist ) {
 445                                         slap_mods_free( modlist );
 446                                 }
 447                                 if ( rc_efree && entry ) {
 448                                         entry_free( entry );
 449                                 }
 450                                 break;
 451
 452                         case LDAP_RES_SEARCH_REFERENCE:
 453 #ifdef NEW_LOGGING
 454                                 LDAP_LOG( OPERATION, ERR,
 455                                         "do_syncrepl : reference received\n", 0, 0, 0 );
 456 #else
 457                                 Debug( LDAP_DEBUG_ANY,
 458                                         "do_syncrepl : reference received\n", 0, 0, 0 );
 459 #endif
 460                                 break;
 461
 462                         case LDAP_RES_SEARCH_RESULT:
 463                                 ldap_parse_result( si->si_ld, msg, &err, NULL, NULL, NULL,
 464                                         &rctrls, 0 );
 465                                 if ( rctrls ) {
 466                                         rctrlp = *rctrls;
 467                                         ber_init2( ber, &rctrlp->ldctl_value, LBER_USE_DER );
 468
 469                                         ber_scanf( ber, "{" /*"}"*/);
 470                                         if ( ber_peek_tag( ber, &len ) == LDAP_SYNC_TAG_COOKIE )
 471                                         {
 472                                                 ber_scanf( ber, "m", &syncCookie );
 473                                         }
 474                                 }
 475                                 value_match( &match, slap_schema.si_ad_entryCSN,
 476                                         slap_schema.si_ad_entryCSN->ad_type->sat_ordering,
 477                                         SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
 478                                         &syncCookie_req, &syncCookie, &text );
 479                                 if ( syncCookie.bv_len && match < 0) {
 480                                         syncrepl_updateCookie( si, op,
 481                                                 psub, &syncCookie );
 482                                 }
 483                                 if ( rctrls ) {
 484                                         ldap_controls_free( rctrls );
 485                                 }
 486                                 if (si->si_type != LDAP_SYNC_REFRESH_AND_PERSIST) {
 487                                         /* FIXME : different error behaviors according to
 488                                          *      1) err code : LDAP_BUSY ...
 489                                          *      2) on err policy : stop service, stop sync, retry
 490                                          */
 491                                         if ( si->si_sync_mode == LDAP_SYNC_STATE_MODE && match
 492                                                 < 0 )
 493                                         {
 494                                                 syncrepl_del_nonpresent( op, si );
 495                                         }
 496                                 }
 497                                 rc = -2;
 498                                 goto done;
 499                                 break;
 500
 501                         case LDAP_RES_INTERMEDIATE:
 502                                 rc = ldap_parse_intermediate( si->si_ld, msg,
 503                                         &retoid, &retdata, NULL, 0 );
 504                                 if ( !rc && !strcmp( retoid, LDAP_SYNC_INFO ) ) {
 505                                         sync_info_arrived = 1;
 506                                         ber_init2( ber, retdata, LBER_USE_DER );
 507                                         ber_scanf( ber, "{e" /*"}"*/, &syncstate );
 508
 509                                         if ( ber_peek_tag( ber, &len )
 510                                                                 == LDAP_SYNC_TAG_COOKIE ) {
 511                                                 ber_scanf( ber, /*"{"*/ "m}", &syncCookie );
 512                                         } else {
 513                                                 if ( syncstate == LDAP_SYNC_NEW_COOKIE ) {
 514 #ifdef NEW_LOGGING
 515                                                         LDAP_LOG( OPERATION, ERR,
 516                                                                 "do_syncrepl : cookie required\n", 0, 0, 0 );
 517 #else
 518                                                         Debug( LDAP_DEBUG_ANY,
 519                                                                 "do_syncrepl : cookie required\n", 0, 0, 0 );
 520 #endif
 521                                                 }
 522                                         }
 523
 524                                         value_match( &match, slap_schema.si_ad_entryCSN,
 525                                                 slap_schema.si_ad_entryCSN->ad_type->sat_ordering,
 526                                                 SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
 527                                                 &syncCookie_req, &syncCookie, &text );
 528
 529                                         if ( syncCookie.bv_len && match < 0 ) {
 530                                                 syncrepl_updateCookie( si, op, psub, &syncCookie);
 531                                         }
 532
 533                                         if ( syncstate == LDAP_SYNC_STATE_MODE_DONE ) {
 534                                                 if ( match < 0 ) {
 535                                                         syncrepl_del_nonpresent( op, si );
 536                                                 }
 537                                                 si->si_sync_mode = LDAP_SYNC_LOG_MODE;
 538                                         } else if ( syncstate == LDAP_SYNC_LOG_MODE_DONE ) {
 539                                                 si->si_sync_mode = LDAP_SYNC_PERSIST_MODE;
 540                                         } else if ( syncstate == LDAP_SYNC_REFRESH_DONE ) {
 541                                                 si->si_sync_mode = LDAP_SYNC_PERSIST_MODE;
 542                                         } else if ( syncstate != LDAP_SYNC_NEW_COOKIE ||
 543                                                 syncstate != LDAP_SYNC_LOG_MODE_DONE )
 544                                         {
 545 #ifdef NEW_LOGGING
 546                                                 LDAP_LOG( OPERATION, ERR,
 547                                                         "do_syncrepl : unknown sync info\n", 0, 0, 0 );
 548 #else
 549                                                 Debug( LDAP_DEBUG_ANY,
 550                                                         "do_syncrepl : unknown sync info\n", 0, 0, 0 );
 551 #endif
 552                                         }
 553
 554                                         ldap_memfree( retoid );
 555                                         ber_bvfree( retdata );
 556                                         break;
 557                                 } else {
 558 #ifdef NEW_LOGGING
 559                                         LDAP_LOG( OPERATION, ERR,"do_syncrepl :"
 560                                                 " unknown intermediate "
 561                                                 "response\n", 0, 0, 0 );
 562 #else
 563                                         Debug( LDAP_DEBUG_ANY, "do_syncrepl : "
 564                                                 "unknown intermediate response (%d)\n",
 565                                                 rc, 0, 0 );
 566 #endif
 567                                         ldap_memfree( retoid );
 568                                         ber_bvfree( retdata );
 569                                         break;
 570                                 }
 571                                 break;
 572                         default:
 573 #ifdef NEW_LOGGING
 574                                 LDAP_LOG( OPERATION, ERR, "do_syncrepl : "
 575                                         "unknown message\n", 0, 0, 0 );
 576 #else
 577                                 Debug( LDAP_DEBUG_ANY, "do_syncrepl : "
 578                                         "unknown message\n", 0, 0, 0 );
 579 #endif
 580                                 break;
 581
 582                         }
 583                 }
 584                 ldap_msgfree( res );
 585                 res = NULL;
 586         }
 587
 588         if ( rc == -1 ) {
 589                 const char *errstr;
 590
 591                 ldap_get_option( si->si_ld, LDAP_OPT_ERROR_NUMBER, &rc );
 592                 errstr = ldap_err2string( rc );
 593
 594 #ifdef NEW_LOGGING
 595                 LDAP_LOG( OPERATION, ERR,
 596                         "do_syncrepl : %s\n", errstr, 0, 0 );
 597 #else
 598                 Debug( LDAP_DEBUG_ANY,
 599                         "do_syncrepl : %s\n", errstr, 0, 0 );
 600 #endif
 601         }
 602
 603 done:
 604         if ( res ) ldap_msgfree( res );
 605
 606         if ( rc && si->si_ld ) {
 607                 ldap_unbind( si->si_ld );
 608                 si->si_ld = NULL;
 609         }
 610
 611         return rc;
 612 }
 613
 614 void *
 615 do_syncrepl(
 616         void    *ctx,
 617         void    *arg )
 618 {
 619         struct re_s* rtask = arg;
 620         syncinfo_t *si = ( syncinfo_t * ) rtask->arg;
 621         Connection conn = {0};
 622         Operation op = {0};
 623         int rc = LDAP_SUCCESS;
 624         int first = 0;
 625         int dostop = 0;
 626         ber_socket_t s;
 627
 628 #ifdef NEW_LOGGING
 629         LDAP_LOG ( OPERATION, DETAIL1, "do_syncrepl\n", 0, 0, 0 );
 630 #else
 631         Debug( LDAP_DEBUG_TRACE, "=>do_syncrepl\n", 0, 0, 0 );
 632 #endif
 633
 634         if ( si == NULL )
 635                 return NULL;
 636
 637         switch( abs( si->si_type )) {
 638         case LDAP_SYNC_REFRESH_ONLY:
 639         case LDAP_SYNC_REFRESH_AND_PERSIST:
 640                 break;
 641         default:
 642                 return NULL;
 643         }
 644
 645         if ( slapd_abrupt_shutdown && si->si_ld ) {
 646                 ldap_get_option( si->si_ld, LDAP_OPT_DESC, &s );
 647                 connection_client_stop( s );
 648                 ldap_unbind( si->si_ld );
 649                 si->si_ld = NULL;
 650                 return NULL;
 651         }
 652
 653         conn.c_connid = -1;
 654         conn.c_send_ldap_result = slap_send_ldap_result;
 655         conn.c_send_search_entry = slap_send_search_entry;
 656         conn.c_send_search_reference = slap_send_search_reference;
 657         conn.c_listener = (Listener *)&dummy_list;
 658         conn.c_peer_name = slap_empty_bv;
 659
 660         /* set memory context */
 661 #define SLAB_SIZE 1048576
 662         op.o_tmpmemctx = sl_mem_create( SLAB_SIZE, ctx );
 663         op.o_tmpmfuncs = &sl_mfuncs;
 664
 665         op.o_dn = si->si_updatedn;
 666         op.o_ndn = si->si_updatedn;
 667         op.o_time = slap_get_time();
 668         op.o_threadctx = ctx;
 669         op.o_managedsait = 1;
 670         op.o_bd = si->si_be;
 671         op.o_conn = &conn;
 672         op.o_connid = op.o_conn->c_connid;
 673
 674         /* Establish session, do search */
 675         if ( !si->si_ld ) {
 676                 first = 1;
 677                 rc = do_syncrep1( &op, si );
 678         }
 679
 680         /* Process results */
 681         if ( rc == LDAP_SUCCESS ) {
 682                 ldap_get_option( si->si_ld, LDAP_OPT_DESC, &s );
 683
 684                 rc = do_syncrep2( &op, si );
 685
 686                 if ( abs(si->si_type) == LDAP_SYNC_REFRESH_AND_PERSIST ) {
 687                         /* If we succeeded, enable the connection for further listening.
 688                          * If we failed, tear down the connection and reschedule.
 689                          */
 690                         if ( rc == LDAP_SUCCESS ) {
 691                                 if ( first ) {
 692                                         rc = connection_client_setup( s, (Listener *)&dummy_list, do_syncrepl,
 693                                                 arg );
 694                                 } else {
 695                                         connection_client_enable( s );
 696                                 }
 697                         } else {
 698                                 dostop = 1;
 699                         }
 700                 } else {
 701                         ch_free( si->si_syncCookie.bv_val );
 702                         si->si_syncCookie.bv_val = NULL;
 703                         si->si_syncCookie.bv_len = 0;
 704                 }
 705         }
 706
 707         /* At this point, we have 4 cases:
 708          * 1) for any hard failure, give up and remove this task
 709          * 2) for ServerDown, reschedule this task to run
 710          * 3) for Refresh and Success, reschedule to run
 711          * 4) for Persist and Success, reschedule to defer
 712          */
 713         ldap_pvt_thread_mutex_lock( &syncrepl_rq.rq_mutex );
 714         if ( ldap_pvt_runqueue_isrunning( &syncrepl_rq, rtask )) {
 715                 ldap_pvt_runqueue_stoptask( &syncrepl_rq, rtask );
 716         }
 717
 718         if ( dostop ) {
 719                 connection_client_stop( s );
 720         }
 721
 722         if ( rc && rc != LDAP_SERVER_DOWN ) {
 723                 ldap_pvt_runqueue_remove( &syncrepl_rq, rtask );
 724         } else {
 725                 if ( rc == LDAP_SERVER_DOWN ||
 726                         si->si_type == LDAP_SYNC_REFRESH_ONLY ) {
 727                         rc = 0;
 728                 } else {
 729                         rc = 1;
 730                 }
 731                 ldap_pvt_runqueue_resched( &syncrepl_rq, rtask, rc );
 732         }
 733         ldap_pvt_thread_mutex_unlock( &syncrepl_rq.rq_mutex );
 734
 735         return NULL;
 736 }
 737
 738 Entry*
 739 syncrepl_message_to_entry(
 740         syncinfo_t      *si,
 741         Operation       *op,
 742         LDAPMessage     *msg,
 743         Modifications   **modlist,
 744         int             syncstate
 745 )
 746 {
 747         Entry           *e = NULL;
 748         BerElement      *ber = NULL;
 749         Modifications   tmp;
 750         Modifications   *mod;
 751         Modifications   **modtail = modlist;
 752
 753         const char      *text;
 754         char txtbuf[SLAP_TEXT_BUFLEN];
 755         size_t textlen = sizeof txtbuf;
 756
 757         struct berval   bdn = {0, NULL}, dn, ndn;
 758         int             rc;
 759
 760         *modlist = NULL;
 761
 762         if ( ldap_msgtype( msg ) != LDAP_RES_SEARCH_ENTRY ) {
 763 #ifdef NEW_LOGGING
 764                 LDAP_LOG( OPERATION, ERR,
 765                         "Message type should be entry (%d)", ldap_msgtype( msg ), 0, 0 );
 766 #else
 767                 Debug( LDAP_DEBUG_ANY,
 768                         "Message type should be entry (%d)", ldap_msgtype( msg ), 0, 0 );
 769 #endif
 770                 return NULL;
 771         }
 772
 773         op->o_tag = LDAP_REQ_ADD;
 774
 775         rc = ldap_get_dn_ber( si->si_ld, msg, &ber, &bdn );
 776
 777         if ( rc != LDAP_SUCCESS ) {
 778 #ifdef NEW_LOGGING
 779                 LDAP_LOG( OPERATION, ERR,
 780                         "syncrepl_message_to_entry : dn get failed (%d)", rc, 0, 0 );
 781 #else
 782                 Debug( LDAP_DEBUG_ANY,
 783                         "syncrepl_message_to_entry : dn get failed (%d)", rc, 0, 0 );
 784 #endif
 785                 return NULL;
 786         }
 787
 788         dnPrettyNormal( NULL, &bdn, &dn, &ndn, op->o_tmpmemctx );
 789         ber_dupbv( &op->o_req_dn, &dn );
 790         ber_dupbv( &op->o_req_ndn, &ndn );
 791         sl_free( ndn.bv_val, op->o_tmpmemctx );
 792         sl_free( dn.bv_val, op->o_tmpmemctx );
 793
 794         if ( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_DELETE ) {
 795                 return NULL;
 796         }
 797
 798         e = ( Entry * ) ch_calloc( 1, sizeof( Entry ) );
 799         e->e_name = op->o_req_dn;
 800         e->e_nname = op->o_req_ndn;
 801
 802         while ( ber_remaining( ber ) ) {
 803                 if ( (ber_scanf( ber, "{mW}", &tmp.sml_type, &tmp.sml_values ) ==
 804                         LBER_ERROR ) || ( tmp.sml_type.bv_val == NULL ))
 805                 {
 806                         break;
 807                 }
 808
 809                 mod  = (Modifications *) ch_malloc( sizeof( Modifications ));
 810
 811                 mod->sml_op = LDAP_MOD_REPLACE;
 812                 mod->sml_next = NULL;
 813                 mod->sml_desc = NULL;
 814                 mod->sml_type = tmp.sml_type;
 815                 mod->sml_bvalues = tmp.sml_bvalues;
 816                 mod->sml_nvalues = NULL;
 817
 818                 *modtail = mod;
 819                 modtail = &mod->sml_next;
 820         }
 821
 822         if ( *modlist == NULL ) {
 823 #ifdef NEW_LOGGING
 824                 LDAP_LOG( OPERATION, ERR,
 825                                 "syncrepl_message_to_entry: no attributes\n", 0, 0, 0 );
 826 #else
 827                 Debug( LDAP_DEBUG_ANY, "syncrepl_message_to_entry: no attributes\n",
 828                                 0, 0, 0 );
 829 #endif
 830         }
 831
 832         rc = slap_mods_check( *modlist, 1, &text, txtbuf, textlen, NULL );
 833
 834         if ( rc != LDAP_SUCCESS ) {
 835 #ifdef NEW_LOGGING
 836                 LDAP_LOG( OPERATION, ERR,
 837                                 "syncrepl_message_to_entry: mods check (%s)\n", text, 0, 0 );
 838 #else
 839                 Debug( LDAP_DEBUG_ANY, "syncrepl_message_to_entry: mods check (%s)\n",
 840                                 text, 0, 0 );
 841 #endif
 842                 goto done;
 843         }
 844
 845         rc = slap_mods2entry( *modlist, &e, 1, 1, &text, txtbuf, textlen);
 846         if( rc != LDAP_SUCCESS ) {
 847 #ifdef NEW_LOGGING
 848                 LDAP_LOG( OPERATION, ERR,
 849                                 "syncrepl_message_to_entry: mods2entry (%s)\n", text, 0, 0 );
 850 #else
 851                 Debug( LDAP_DEBUG_ANY, "syncrepl_message_to_entry: mods2entry (%s)\n",
 852                                 text, 0, 0 );
 853 #endif
 854         }
 855
 856 done:
 857         ber_free ( ber, 0 );
 858         if ( rc != LDAP_SUCCESS ) {
 859                 entry_free( e );
 860                 e = NULL;
 861         }
 862
 863         return e;
 864 }
 865
 866 int
 867 syncuuid_cmp( const void* v_uuid1, const void* v_uuid2 )
 868 {
 869         const struct berval *uuid1 = v_uuid1;
 870         const struct berval *uuid2 = v_uuid2;
 871         int rc = uuid1->bv_len - uuid2->bv_len;
 872         if ( rc ) return rc;
 873         return ( strcmp( uuid1->bv_val, uuid2->bv_val ) );
 874 }
 875
 876 int
 877 syncrepl_entry(
 878         syncinfo_t* si,
 879         Operation *op,
 880         Entry* e,
 881         Modifications* modlist,
 882         int syncstate,
 883         struct berval* syncUUID,
 884         int refresh
 885 )
 886 {
 887         Backend *be = op->o_bd;
 888         slap_callback   cb;
 889         struct berval   *syncuuid_bv = NULL;
 890
 891         SlapReply       rs = {REP_RESULT};
 892         Filter f = {0};
 893         AttributeAssertion ava = {0};
 894         int rc = LDAP_SUCCESS;
 895         int ret = LDAP_SUCCESS;
 896
 897         if ( refresh &&
 898                 ( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_ADD ))
 899         {
 900                 syncuuid_bv = ber_dupbv( NULL, syncUUID );
 901                 avl_insert( &si->si_presentlist, (caddr_t) syncuuid_bv,
 902                         syncuuid_cmp, avl_dup_error );
 903         }
 904
 905         if ( syncstate == LDAP_SYNC_PRESENT ) {
 906                 return e ? 1 : 0;
 907         }
 908
 909         op->ors_filterstr.bv_len = (sizeof("entryUUID=")-1) + syncUUID->bv_len;
 910         op->ors_filterstr.bv_val = (char *) sl_malloc(
 911                 op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
 912         AC_MEMCPY( op->ors_filterstr.bv_val, "entryUUID=", sizeof("entryUUID=")-1 );
 913         AC_MEMCPY( &op->ors_filterstr.bv_val[sizeof("entryUUID=")-1],
 914                 syncUUID->bv_val, syncUUID->bv_len );
 915         op->ors_filterstr.bv_val[op->ors_filterstr.bv_len] = '\0';
 916
 917         f.f_choice = LDAP_FILTER_EQUALITY;
 918         f.f_ava = &ava;
 919         ava.aa_desc = slap_schema.si_ad_entryUUID;
 920         ava.aa_value = *syncUUID;
 921         op->ors_filter = &f;
 922         op->ors_scope = LDAP_SCOPE_SUBTREE;
 923
 924         /* get syncrepl cookie of shadow replica from subentry */
 925         op->o_req_dn = si->si_base;
 926         op->o_req_ndn = si->si_base;
 927
 928         /* set callback function */
 929         op->o_callback = &cb;
 930         cb.sc_response = dn_callback;
 931         cb.sc_private = si;
 932
 933         si->si_syncUUID_ndn.bv_val = NULL;
 934
 935         rc = be->be_search( op, &rs );
 936
 937         if ( op->ors_filterstr.bv_val ) {
 938                 sl_free( op->ors_filterstr.bv_val, op->o_tmpmemctx );
 939         }
 940
 941         cb.sc_response = null_callback;
 942         cb.sc_private = si;
 943
 944         if ( rc == LDAP_SUCCESS && si->si_syncUUID_ndn.bv_val &&
 945                 si->si_sync_mode != LDAP_SYNC_LOG_MODE )
 946         {
 947                 op->o_req_dn = si->si_syncUUID_ndn;
 948                 op->o_req_ndn = si->si_syncUUID_ndn;
 949                 op->o_tag = LDAP_REQ_DELETE;
 950                 rc = be->be_delete( op, &rs );
 951         }
 952
 953         switch ( syncstate ) {
 954         case LDAP_SYNC_ADD:
 955         case LDAP_SYNC_MODIFY:
 956                 if ( rc == LDAP_SUCCESS ||
 957                          rc == LDAP_REFERRAL ||
 958                          rc == LDAP_NO_SUCH_OBJECT )
 959                 {
 960                         attr_delete( &e->e_attrs, slap_schema.si_ad_entryUUID );
 961                         attr_merge_normalize_one( e, slap_schema.si_ad_entryUUID,
 962                                 syncUUID, op->o_tmpmemctx );
 963
 964                         op->o_tag = LDAP_REQ_ADD;
 965                         op->ora_e = e;
 966                         op->o_req_dn = e->e_name;
 967                         op->o_req_ndn = e->e_nname;
 968                         rc = be->be_add( op, &rs );
 969
 970                         if ( rc != LDAP_SUCCESS ) {
 971                                 if ( rc == LDAP_ALREADY_EXISTS ) {
 972                                         op->o_tag = LDAP_REQ_MODIFY;
 973                                         op->orm_modlist = modlist;
 974                                         op->o_req_dn = e->e_name;
 975                                         op->o_req_ndn = e->e_nname;
 976                                         rc = be->be_modify( op, &rs );
 977                                         if ( rc != LDAP_SUCCESS ) {
 978 #ifdef NEW_LOGGING
 979                                                 LDAP_LOG( OPERATION, ERR,
 980                                                         "syncrepl_entry : be_modify failed (%d)\n",
 981                                                         rc, 0, 0 );
 982 #else
 983                                                 Debug( LDAP_DEBUG_ANY,
 984                                                         "syncrepl_entry : be_modify failed (%d)\n",
 985                                                         rc, 0, 0 );
 986 #endif
 987                                         }
 988                                         ret = 1;
 989                                         goto done;
 990                                 } else if ( rc == LDAP_REFERRAL || rc == LDAP_NO_SUCH_OBJECT ) {
 991                                         syncrepl_add_glue( op, e );
 992                                         ret = 0;
 993                                         goto done;
 994                                 } else {
 995 #ifdef NEW_LOGGING
 996                                         LDAP_LOG( OPERATION, ERR,
 997                                                 "syncrepl_entry : be_add failed (%d)\n",
 998                                                 rc, 0, 0 );
 999 #else
1000                                         Debug( LDAP_DEBUG_ANY,
1001                                                 "syncrepl_entry : be_add failed (%d)\n",
1002                                                 rc, 0, 0 );
1003 #endif
1004                                         ret = 1;
1005                                         goto done;
1006                                 }
1007                         } else {
1008                                 be_entry_release_w( op, e );
1009                                 ret = 0;
1010                                 goto done;
1011                         }
1012                 } else {
1013 #ifdef NEW_LOGGING
1014                         LDAP_LOG( OPERATION, ERR,
1015                                 "syncrepl_entry : be_search failed (%d)\n", rc, 0, 0 );
1016 #else
1017                         Debug( LDAP_DEBUG_ANY,
1018                                 "syncrepl_entry : be_search failed (%d)\n", rc, 0, 0 );
1019 #endif
1020                         ret = 1;
1021                         goto done;
1022                 }
1023
1024         case LDAP_SYNC_DELETE :
1025                 if ( si->si_sync_mode == LDAP_SYNC_LOG_MODE ) {
1026                         if ( si->si_syncUUID_ndn.bv_val ) {
1027                                 op->o_req_dn = si->si_syncUUID_ndn;
1028                                 op->o_req_ndn = si->si_syncUUID_ndn;
1029                                 op->o_tag = LDAP_REQ_DELETE;
1030                                 rc = be->be_delete( op, &rs );
1031                         }
1032                 }
1033                 /* Already deleted otherwise */
1034                 ret = 1;
1035                 goto done;
1036
1037         default :
1038 #ifdef NEW_LOGGING
1039                 LDAP_LOG( OPERATION, ERR,
1040                         "syncrepl_entry : unknown syncstate\n", 0, 0, 0 );
1041 #else
1042                 Debug( LDAP_DEBUG_ANY,
1043                         "syncrepl_entry : unknown syncstate\n", 0, 0, 0 );
1044 #endif
1045                 ret = 1;
1046                 goto done;
1047         }
1048
1049 done :
1050
1051         if ( si->si_syncUUID_ndn.bv_val ) {
1052                 ber_memfree_x( si->si_syncUUID_ndn.bv_val, op->o_tmpmemctx );
1053         }
1054         return ret;
1055 }
1056
1057 static void
1058 syncrepl_del_nonpresent(
1059         Operation *op,
1060         syncinfo_t *si
1061 )
1062 {
1063         Backend* be = op->o_bd;
1064         slap_callback   cb;
1065         SlapReply       rs = {REP_RESULT};
1066         struct nonpresent_entry *np_list, *np_prev;
1067
1068         op->o_req_dn = si->si_base;
1069         op->o_req_ndn = si->si_base;
1070
1071         cb.sc_response = nonpresent_callback;
1072         cb.sc_private = si;
1073
1074         op->o_callback = &cb;
1075         op->o_tag = LDAP_REQ_SEARCH;
1076         op->ors_scope = si->si_scope;
1077         op->ors_deref = LDAP_DEREF_NEVER;
1078         op->ors_slimit = 0;
1079         op->ors_tlimit = 0;
1080         op->ors_attrsonly = 0;
1081         op->ors_attrs = NULL;
1082         op->ors_filter = str2filter_x( op, si->si_filterstr.bv_val );
1083         op->ors_filterstr = si->si_filterstr;
1084
1085         op->o_nocaching = 1;
1086         be->be_search( op, &rs );
1087         op->o_nocaching = 0;
1088
1089         if ( op->ors_filter ) filter_free_x( op, op->ors_filter );
1090
1091         if ( !LDAP_LIST_EMPTY( &si->si_nonpresentlist ) ) {
1092                 np_list = LDAP_LIST_FIRST( &si->si_nonpresentlist );
1093                 while ( np_list != NULL ) {
1094                         LDAP_LIST_REMOVE( np_list, npe_link );
1095                         np_prev = np_list;
1096                         np_list = LDAP_LIST_NEXT( np_list, npe_link );
1097                         op->o_tag = LDAP_REQ_DELETE;
1098                         op->o_callback = &cb;
1099                         cb.sc_response = null_callback;
1100                         cb.sc_private = si;
1101                         op->o_req_dn = *np_prev->npe_name;
1102                         op->o_req_ndn = *np_prev->npe_nname;
1103                         op->o_bd->be_delete( op, &rs );
1104                         ber_bvfree( np_prev->npe_name );
1105                         ber_bvfree( np_prev->npe_nname );
1106                         op->o_req_dn.bv_val = NULL;
1107                         op->o_req_ndn.bv_val = NULL;
1108                         ch_free( np_prev );
1109                 }
1110         }
1111
1112         return;
1113 }
1114
1115
1116 static struct berval gcbva[] = {
1117         BER_BVC("top"),
1118         BER_BVC("glue")
1119 };
1120
1121 void
1122 syncrepl_add_glue(
1123         Operation* op,
1124         Entry *e
1125 )
1126 {
1127         Backend *be = op->o_bd;
1128         slap_callback cb;
1129         Attribute       *a;
1130         int     rc;
1131         int suffrdns;
1132         int i;
1133         struct berval dn = {0, NULL};
1134         struct berval ndn = {0, NULL};
1135         Entry   *glue;
1136         SlapReply       rs = {REP_RESULT};
1137         char    *ptr, *comma;
1138
1139         op->o_tag = LDAP_REQ_ADD;
1140         op->o_callback = &cb;
1141         cb.sc_response = null_callback;
1142         cb.sc_private = NULL;
1143
1144         dn = e->e_name;
1145         ndn = e->e_nname;
1146
1147         /* count RDNs in suffix */
1148         if ( be->be_nsuffix[0].bv_len ) {
1149                 for (i=0, ptr=be->be_nsuffix[0].bv_val; ptr; ptr=strchr( ptr, ',' )) {
1150                         ptr++;
1151                         i++;
1152                 }
1153                 suffrdns = i;
1154         } else {
1155                 /* suffix is "" */
1156                 suffrdns = 0;
1157         }
1158
1159         /* Start with BE suffix */
1160         for ( i = 0, ptr = NULL; i < suffrdns; i++ ) {
1161                 comma = strrchr(dn.bv_val, ',');
1162                 if ( ptr ) *ptr = ',';
1163                 if ( comma ) *comma = '\0';
1164                 ptr = comma;
1165         }
1166         if ( ptr ) {
1167                 *ptr++ = ',';
1168                 dn.bv_len -= ptr - dn.bv_val;
1169                 dn.bv_val = ptr;
1170         }
1171         /* the normalizedDNs are always the same length, no counting
1172          * required.
1173          */
1174         if ( ndn.bv_len > be->be_nsuffix[0].bv_len ) {
1175                 ndn.bv_val += ndn.bv_len - be->be_nsuffix[0].bv_len;
1176                 ndn.bv_len = be->be_nsuffix[0].bv_len;
1177         }
1178
1179         while ( ndn.bv_val > e->e_nname.bv_val ) {
1180                 glue = (Entry *) ch_calloc( 1, sizeof(Entry) );
1181                 ber_dupbv( &glue->e_name, &dn );
1182                 ber_dupbv( &glue->e_nname, &ndn );
1183
1184                 a = ch_calloc( 1, sizeof( Attribute ));
1185                 a->a_desc = slap_schema.si_ad_objectClass;
1186
1187                 a->a_vals = ch_calloc( 3, sizeof( struct berval ));
1188                 ber_dupbv( &a->a_vals[0], &gcbva[0] );
1189                 ber_dupbv( &a->a_vals[1], &gcbva[1] );
1190                 a->a_vals[2].bv_len = 0;
1191                 a->a_vals[2].bv_val = NULL;
1192
1193                 a->a_nvals = a->a_vals;
1194
1195                 a->a_next = glue->e_attrs;
1196                 glue->e_attrs = a;
1197
1198                 a = ch_calloc( 1, sizeof( Attribute ));
1199                 a->a_desc = slap_schema.si_ad_structuralObjectClass;
1200
1201                 a->a_vals = ch_calloc( 2, sizeof( struct berval ));
1202                 ber_dupbv( &a->a_vals[0], &gcbva[1] );
1203                 a->a_vals[1].bv_len = 0;
1204                 a->a_vals[1].bv_val = NULL;
1205
1206                 a->a_nvals = a->a_vals;
1207
1208                 a->a_next = glue->e_attrs;
1209                 glue->e_attrs = a;
1210
1211                 op->o_req_dn = glue->e_name;
1212                 op->o_req_ndn = glue->e_nname;
1213                 op->ora_e = glue;
1214                 rc = be->be_add ( op, &rs );
1215                 if ( rc == LDAP_SUCCESS ) {
1216                         be_entry_release_w( op, glue );
1217                 } else {
1218                 /* incl. ALREADY EXIST */
1219                         entry_free( glue );
1220                 }
1221
1222                 /* Move to next child */
1223                 for (ptr = dn.bv_val-2; ptr > e->e_name.bv_val && *ptr != ','; ptr--) {
1224                         /* empty */
1225                 }
1226                 if ( ptr == e->e_name.bv_val ) break;
1227                 dn.bv_val = ++ptr;
1228                 dn.bv_len = e->e_name.bv_len - (ptr-e->e_name.bv_val);
1229                 for( ptr = ndn.bv_val-2;
1230                         ptr > e->e_nname.bv_val && *ptr != ',';
1231                         ptr--)
1232                 {
1233                         /* empty */
1234                 }
1235                 ndn.bv_val = ++ptr;
1236                 ndn.bv_len = e->e_nname.bv_len - (ptr-e->e_nname.bv_val);
1237         }
1238
1239         op->o_req_dn = e->e_name;
1240         op->o_req_ndn = e->e_nname;
1241         op->ora_e = e;
1242         rc = be->be_add ( op, &rs );
1243         if ( rc == LDAP_SUCCESS ) {
1244                 be_entry_release_w( op, e );
1245         } else {
1246                 entry_free( e );
1247         }
1248
1249         return;
1250 }
1251
1252 static struct berval ocbva[] = {
1253         BER_BVC("top"),
1254         BER_BVC("subentry"),
1255         BER_BVC("syncConsumerSubentry"),
1256         BER_BVNULL
1257 };
1258
1259 static struct berval cnbva[] = {
1260         BER_BVNULL,
1261         BER_BVNULL
1262 };
1263
1264 static struct berval ssbva[] = {
1265         BER_BVC("{}"),
1266         BER_BVNULL
1267 };
1268
1269 static struct berval scbva[] = {
1270         BER_BVNULL,
1271         BER_BVNULL
1272 };
1273
1274 void
1275 syncrepl_updateCookie(
1276         syncinfo_t *si,
1277         Operation *op,
1278         struct berval *pdn,
1279         struct berval *syncCookie
1280 )
1281 {
1282         Backend *be = op->o_bd;
1283         Modifications *ml;
1284         Modifications *mlnext;
1285         Modifications *mod;
1286         Modifications *modlist = NULL;
1287         Modifications **modtail = &modlist;
1288
1289         const char      *text;
1290         char txtbuf[SLAP_TEXT_BUFLEN];
1291         size_t textlen = sizeof txtbuf;
1292
1293         Entry* e = NULL;
1294         int rc;
1295
1296         char syncrepl_cbuf[sizeof(CN_STR SYNCREPL_STR)];
1297         struct berval slap_syncrepl_dn_bv = BER_BVNULL;
1298         struct berval slap_syncrepl_cn_bv = BER_BVNULL;
1299
1300         slap_callback cb;
1301         SlapReply       rs = {REP_RESULT};
1302
1303         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1304         mod->sml_op = LDAP_MOD_REPLACE;
1305         mod->sml_desc = slap_schema.si_ad_objectClass;
1306         mod->sml_type = mod->sml_desc->ad_cname;
1307         mod->sml_bvalues = ocbva;
1308         *modtail = mod;
1309         modtail = &mod->sml_next;
1310
1311         ber_dupbv( &cnbva[0], (struct berval *) &slap_syncrepl_bvc );
1312         assert( si->si_id < 1000 );
1313         cnbva[0].bv_len = snprintf( cnbva[0].bv_val,
1314                 slap_syncrepl_bvc.bv_len,
1315                 "syncrepl%d", si->si_id );
1316         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1317         mod->sml_op = LDAP_MOD_REPLACE;
1318         mod->sml_desc = slap_schema.si_ad_cn;
1319         mod->sml_type = mod->sml_desc->ad_cname;
1320         mod->sml_bvalues = cnbva;
1321         *modtail = mod;
1322         modtail = &mod->sml_next;
1323
1324         if ( scbva[0].bv_val ) ch_free( scbva[0].bv_val );
1325         ber_dupbv( &scbva[0], syncCookie );
1326         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1327         mod->sml_op = LDAP_MOD_REPLACE;
1328         mod->sml_desc = slap_schema.si_ad_syncreplCookie;
1329         mod->sml_type = mod->sml_desc->ad_cname;
1330         mod->sml_bvalues = scbva;
1331         *modtail = mod;
1332         modtail = &mod->sml_next;
1333
1334         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1335         mod->sml_op = LDAP_MOD_REPLACE;
1336         mod->sml_desc = slap_schema.si_ad_subtreeSpecification;
1337         mod->sml_type = mod->sml_desc->ad_cname;
1338         mod->sml_bvalues = ssbva;
1339         *modtail = mod;
1340         modtail = &mod->sml_next;
1341
1342         mlnext = mod;
1343
1344         op->o_tag = LDAP_REQ_ADD;
1345         rc = slap_mods_opattrs( op, modlist, modtail,
1346                                                          &text,txtbuf, textlen );
1347
1348         for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
1349                 ml->sml_op = LDAP_MOD_REPLACE;
1350         }
1351
1352         if( rc != LDAP_SUCCESS ) {
1353 #ifdef NEW_LOGGING
1354                 LDAP_LOG( OPERATION, ERR,
1355                         "syncrepl_updateCookie: mods opattrs (%s)\n", text, 0, 0 );
1356 #else
1357                 Debug( LDAP_DEBUG_ANY, "syncrepl_updateCookie: mods opattrs (%s)\n",
1358                          text, 0, 0 );
1359 #endif
1360         }
1361
1362         e = ( Entry * ) ch_calloc( 1, sizeof( Entry ));
1363
1364         slap_syncrepl_cn_bv.bv_val = syncrepl_cbuf;
1365         assert( si->si_id < 1000 );
1366         slap_syncrepl_cn_bv.bv_len = snprintf( slap_syncrepl_cn_bv.bv_val,
1367                 slap_syncrepl_cn_bvc.bv_len,
1368                 "cn=syncrepl%d", si->si_id );
1369
1370         build_new_dn( &slap_syncrepl_dn_bv, pdn, &slap_syncrepl_cn_bv,
1371                 op->o_tmpmemctx );
1372         ber_dupbv( &e->e_name, &slap_syncrepl_dn_bv );
1373         ber_dupbv( &e->e_nname, &slap_syncrepl_dn_bv );
1374
1375         if ( slap_syncrepl_dn_bv.bv_val ) {
1376                 sl_free( slap_syncrepl_dn_bv.bv_val, op->o_tmpmemctx );
1377         }
1378
1379         e->e_attrs = NULL;
1380
1381         rc = slap_mods2entry( modlist, &e, 1, 1, &text, txtbuf, textlen );
1382
1383         if( rc != LDAP_SUCCESS ) {
1384 #ifdef NEW_LOGGING
1385                 LDAP_LOG( OPERATION, ERR,
1386                         "syncrepl_updateCookie: mods2entry (%s)\n", text, 0, 0 );
1387 #else
1388                 Debug( LDAP_DEBUG_ANY, "syncrepl_updateCookie: mods2entry (%s)\n",
1389                          text, 0, 0 );
1390 #endif
1391         }
1392
1393         cb.sc_response = null_callback;
1394         cb.sc_private = si;
1395
1396         op->o_callback = &cb;
1397         op->o_req_dn = e->e_name;
1398         op->o_req_ndn = e->e_nname;
1399
1400         /* update persistent cookie */
1401 update_cookie_retry:
1402         op->o_tag = LDAP_REQ_MODIFY;
1403         op->orm_modlist = modlist;
1404         rc = be->be_modify( op, &rs );
1405
1406         if ( rc != LDAP_SUCCESS ) {
1407                 if ( rc == LDAP_REFERRAL ||
1408                          rc == LDAP_NO_SUCH_OBJECT ) {
1409                         op->o_tag = LDAP_REQ_ADD;
1410                         op->ora_e = e;
1411                         rc = be->be_add( op, &rs );
1412                         if ( rc != LDAP_SUCCESS ) {
1413                                 if ( rc == LDAP_ALREADY_EXISTS ) {
1414                                         goto update_cookie_retry;
1415                                 } else if ( rc == LDAP_REFERRAL ||
1416                                                         rc == LDAP_NO_SUCH_OBJECT ) {
1417 #ifdef NEW_LOGGING
1418                                         LDAP_LOG( OPERATION, ERR,
1419                                                 "cookie will be non-persistent\n",
1420                                                 0, 0, 0 );
1421 #else
1422                                         Debug( LDAP_DEBUG_ANY,
1423                                                 "cookie will be non-persistent\n",
1424                                                 0, 0, 0 );
1425 #endif
1426                                 } else {
1427 #ifdef NEW_LOGGING
1428                                         LDAP_LOG( OPERATION, ERR,
1429                                                 "be_add failed (%d)\n",
1430                                                 rc, 0, 0 );
1431 #else
1432                                         Debug( LDAP_DEBUG_ANY,
1433                                                 "be_add failed (%d)\n",
1434                                                 rc, 0, 0 );
1435 #endif
1436                                 }
1437                         } else {
1438                                 be_entry_release_w( op, e );
1439                                 goto done;
1440                         }
1441                 } else {
1442 #ifdef NEW_LOGGING
1443                         LDAP_LOG( OPERATION, ERR,
1444                                 "be_modify failed (%d)\n", rc, 0, 0 );
1445 #else
1446                         Debug( LDAP_DEBUG_ANY,
1447                                 "be_modify failed (%d)\n", rc, 0, 0 );
1448 #endif
1449                 }
1450         }
1451
1452         if ( e != NULL ) {
1453                 entry_free( e );
1454         }
1455
1456 done :
1457
1458         if ( cnbva[0].bv_val ) {
1459                 ch_free( cnbva[0].bv_val );
1460                 cnbva[0].bv_val = NULL;
1461         }
1462         if ( scbva[0].bv_val ) {
1463                 ch_free( scbva[0].bv_val );
1464                 scbva[0].bv_val = NULL;
1465         }
1466
1467         if ( mlnext->sml_next ) {
1468                 slap_mods_free( mlnext->sml_next );
1469                 mlnext->sml_next = NULL;
1470         }
1471
1472         for (ml = modlist ; ml != NULL; ml = mlnext ) {
1473                 mlnext = ml->sml_next;
1474                 free( ml );
1475         }
1476
1477         return;
1478 }
1479
1480 void
1481 avl_ber_bvfree( void *bv )
1482 {
1483         if( bv == NULL ) {
1484                 return;
1485         }
1486         if ( ((struct berval *)bv)->bv_val != NULL ) {
1487                 ch_free ( ((struct berval *)bv)->bv_val );
1488         }
1489         ch_free ( (char *) bv );
1490 }
1491
1492 static int
1493 dn_callback(
1494         Operation*      op,
1495         SlapReply*      rs
1496 )
1497 {
1498         syncinfo_t *si = op->o_callback->sc_private;
1499
1500         if ( rs->sr_type == REP_SEARCH ) {
1501                 if ( si->si_syncUUID_ndn.bv_val != NULL ) {
1502 #ifdef NEW_LOGGING
1503                         LDAP_LOG( OPERATION, ERR,
1504                                 "dn_callback : multiple entries match dn\n", 0, 0, 0 );
1505 #else
1506                         Debug( LDAP_DEBUG_ANY,
1507                                 "dn_callback : multiple entries match dn\n", 0, 0, 0 );
1508 #endif
1509                 } else {
1510                         ber_dupbv_x( &si->si_syncUUID_ndn, &rs->sr_entry->e_nname, op->o_tmpmemctx );
1511                 }
1512         }
1513
1514         return LDAP_SUCCESS;
1515 }
1516
1517 static int
1518 nonpresent_callback(
1519         Operation*      op,
1520         SlapReply*      rs
1521 )
1522 {
1523         syncinfo_t *si = op->o_callback->sc_private;
1524         Attribute *a;
1525         int count = 0;
1526         struct berval* present_uuid = NULL;
1527         struct nonpresent_entry *np_entry;
1528
1529         if ( rs->sr_type == REP_RESULT ) {
1530                 count = avl_free( si->si_presentlist, avl_ber_bvfree );
1531                 si->si_presentlist = NULL;
1532
1533         } else if ( rs->sr_type == REP_SEARCH ) {
1534                 a = attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_entryUUID );
1535
1536                 if ( a == NULL ) return 0;
1537
1538                 present_uuid = avl_find( si->si_presentlist, &a->a_vals[0],
1539                         syncuuid_cmp );
1540
1541                 if ( present_uuid == NULL ) {
1542                         np_entry = (struct nonpresent_entry *)
1543                                 ch_calloc( 1, sizeof( struct nonpresent_entry ));
1544                         np_entry->npe_name = ber_dupbv( NULL, &rs->sr_entry->e_name );
1545                         np_entry->npe_nname = ber_dupbv( NULL, &rs->sr_entry->e_nname );
1546                         LDAP_LIST_INSERT_HEAD( &si->si_nonpresentlist, np_entry, npe_link );
1547
1548                 } else {
1549                         avl_delete( &si->si_presentlist,
1550                                         &a->a_vals[0], syncuuid_cmp );
1551                         ch_free( present_uuid->bv_val );
1552                         ch_free( present_uuid );
1553                 }
1554         }
1555         return LDAP_SUCCESS;
1556 }
1557
1558 static int
1559 null_callback(
1560         Operation*      op,
1561         SlapReply*      rs
1562 )
1563 {
1564         if ( rs->sr_err != LDAP_SUCCESS &&
1565                 rs->sr_err != LDAP_REFERRAL &&
1566                 rs->sr_err != LDAP_ALREADY_EXISTS &&
1567                 rs->sr_err != LDAP_NO_SUCH_OBJECT )
1568         {
1569 #ifdef NEW_LOGGING
1570                 LDAP_LOG( OPERATION, ERR,
1571                         "null_callback : error code 0x%x\n",
1572                         rs->sr_err, 0, 0 );
1573 #else
1574                 Debug( LDAP_DEBUG_ANY,
1575                         "null_callback : error code 0x%x\n",
1576                         rs->sr_err, 0, 0 );
1577 #endif
1578         }
1579         return LDAP_SUCCESS;
1580 }
1581
1582 Entry *
1583 slap_create_syncrepl_entry(
1584         Backend *be,
1585         struct berval *context_csn,
1586         struct berval *rdn,
1587         struct berval *cn
1588 )
1589 {
1590         Entry* e;
1591
1592         struct berval bv;
1593
1594         e = ( Entry * ) ch_calloc( 1, sizeof( Entry ));
1595
1596         attr_merge( e, slap_schema.si_ad_objectClass, ocbva, NULL );
1597
1598         attr_merge_one( e, slap_schema.si_ad_structuralObjectClass,
1599                 &ocbva[1], NULL );
1600
1601         attr_merge_one( e, slap_schema.si_ad_cn, cn, NULL );
1602
1603         if ( context_csn ) {
1604                 attr_merge_one( e, slap_schema.si_ad_syncreplCookie,
1605                         context_csn, NULL );
1606         }
1607
1608         bv.bv_val = "{}";
1609         bv.bv_len = sizeof("{}")-1;
1610         attr_merge_one( e, slap_schema.si_ad_subtreeSpecification, &bv, NULL );
1611
1612         build_new_dn( &e->e_name, &be->be_nsuffix[0], rdn, NULL );
1613         ber_dupbv( &e->e_nname, &e->e_name );
1614
1615         return e;
1616 }