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                 int errno;
 590                 const char *errstr;
 591
 592                 ldap_get_option( si->si_ld, LDAP_OPT_ERROR_NUMBER, &errno );
 593                 errstr = ldap_err2string( errno );
 594
 595 #ifdef NEW_LOGGING
 596                 LDAP_LOG( OPERATION, ERR,
 597                         "do_syncrepl : %s\n", errstr, 0, 0 );
 598 #else
 599                 Debug( LDAP_DEBUG_ANY,
 600                         "do_syncrepl : %s\n", errstr, 0, 0 );
 601 #endif
 602         }
 603
 604 done:
 605         if ( res ) ldap_msgfree( res );
 606
 607         if ( rc && si->si_ld ) {
 608                 ldap_unbind( si->si_ld );
 609                 si->si_ld = NULL;
 610                 /* just close and report success */
 611                 if ( rc == -2 )
 612                         rc = 0;
 613         }
 614
 615         return rc;
 616 }
 617
 618 void *
 619 do_syncrepl(
 620         void    *ctx,
 621         void    *arg )
 622 {
 623         struct re_s* rtask = arg;
 624         syncinfo_t *si = ( syncinfo_t * ) rtask->arg;
 625         Connection conn = {0};
 626         Operation op = {0};
 627         int rc = LDAP_SUCCESS;
 628         int first = 0;
 629
 630 #ifdef NEW_LOGGING
 631         LDAP_LOG ( OPERATION, DETAIL1, "do_syncrepl\n", 0, 0, 0 );
 632 #else
 633         Debug( LDAP_DEBUG_TRACE, "=>do_syncrepl\n", 0, 0, 0 );
 634 #endif
 635
 636         if ( si == NULL )
 637                 return NULL;
 638
 639         switch( abs( si->si_type )) {
 640         case LDAP_SYNC_REFRESH_ONLY:
 641         case LDAP_SYNC_REFRESH_AND_PERSIST:
 642                 break;
 643         default:
 644                 return NULL;
 645         }
 646
 647         conn.c_connid = -1;
 648         conn.c_send_ldap_result = slap_send_ldap_result;
 649         conn.c_send_search_entry = slap_send_search_entry;
 650         conn.c_send_search_reference = slap_send_search_reference;
 651         conn.c_listener = (Listener *)&dummy_list;
 652         conn.c_peer_name = slap_empty_bv;
 653
 654         /* set memory context */
 655 #define SLAB_SIZE 1048576
 656         op.o_tmpmemctx = sl_mem_create( SLAB_SIZE, ctx );
 657         op.o_tmpmfuncs = &sl_mfuncs;
 658
 659         op.o_dn = si->si_updatedn;
 660         op.o_ndn = si->si_updatedn;
 661         op.o_time = slap_get_time();
 662         op.o_threadctx = ctx;
 663         op.o_managedsait = 1;
 664         op.o_bd = si->si_be;
 665         op.o_conn = &conn;
 666         op.o_connid = op.o_conn->c_connid;
 667
 668         /* Establish session, do search */
 669         if ( !si->si_ld ) {
 670                 first = 1;
 671                 rc = do_syncrep1( &op, si );
 672         }
 673
 674         /* Process results */
 675         if ( rc == LDAP_SUCCESS ) {
 676                 ber_socket_t s;
 677                 ldap_get_option( si->si_ld, LDAP_OPT_DESC, &s );
 678
 679                 rc = do_syncrep2( &op, si );
 680
 681                 if ( abs(si->si_type) == LDAP_SYNC_REFRESH_AND_PERSIST ) {
 682                         /* If we succeeded, enable the connection for further listening.
 683                          * If we failed, tear down the connection and reschedule.
 684                          */
 685                         if ( rc == LDAP_SUCCESS ) {
 686                                 if ( first ) {
 687                                         rc = connection_client_setup( s, (Listener *)&dummy_list, do_syncrepl,
 688                                                 arg );
 689                                 } else {
 690                                         connection_client_enable( s );
 691                                 }
 692                                 /* Don't need to resched this task for a while */
 693                                 if ( rc == 0 ) rc = 1;
 694                         } else {
 695                                 connection_client_stop( s );
 696                         }
 697                 } else {
 698                         ch_free( si->si_syncCookie.bv_val );
 699                         si->si_syncCookie.bv_val = NULL;
 700                         si->si_syncCookie.bv_len = 0;
 701                 }
 702         }
 703
 704         if ( rc == LDAP_SUCCESS || rc == LDAP_SERVER_DOWN ) {
 705                 ldap_pvt_thread_mutex_lock( &syncrepl_rq.rq_mutex );
 706                 ldap_pvt_runqueue_stoptask( &syncrepl_rq, rtask );
 707                 ldap_pvt_runqueue_resched( &syncrepl_rq, rtask );
 708                 ldap_pvt_thread_mutex_unlock( &syncrepl_rq.rq_mutex );
 709         }
 710
 711         return NULL;
 712 }
 713
 714 Entry*
 715 syncrepl_message_to_entry(
 716         syncinfo_t      *si,
 717         Operation       *op,
 718         LDAPMessage     *msg,
 719         Modifications   **modlist,
 720         int             syncstate
 721 )
 722 {
 723         Entry           *e = NULL;
 724         BerElement      *ber = NULL;
 725         Modifications   tmp;
 726         Modifications   *mod;
 727         Modifications   **modtail = modlist;
 728
 729         const char      *text;
 730         char txtbuf[SLAP_TEXT_BUFLEN];
 731         size_t textlen = sizeof txtbuf;
 732
 733         struct berval   bdn = {0, NULL}, dn, ndn;
 734         int             rc;
 735
 736         *modlist = NULL;
 737
 738         if ( ldap_msgtype( msg ) != LDAP_RES_SEARCH_ENTRY ) {
 739 #ifdef NEW_LOGGING
 740                 LDAP_LOG( OPERATION, ERR,
 741                         "Message type should be entry (%d)", ldap_msgtype( msg ), 0, 0 );
 742 #else
 743                 Debug( LDAP_DEBUG_ANY,
 744                         "Message type should be entry (%d)", ldap_msgtype( msg ), 0, 0 );
 745 #endif
 746                 return NULL;
 747         }
 748
 749         op->o_tag = LDAP_REQ_ADD;
 750
 751         rc = ldap_get_dn_ber( si->si_ld, msg, &ber, &bdn );
 752
 753         if ( rc != LDAP_SUCCESS ) {
 754 #ifdef NEW_LOGGING
 755                 LDAP_LOG( OPERATION, ERR,
 756                         "syncrepl_message_to_entry : dn get failed (%d)", rc, 0, 0 );
 757 #else
 758                 Debug( LDAP_DEBUG_ANY,
 759                         "syncrepl_message_to_entry : dn get failed (%d)", rc, 0, 0 );
 760 #endif
 761                 return NULL;
 762         }
 763
 764         dnPrettyNormal( NULL, &bdn, &dn, &ndn, op->o_tmpmemctx );
 765         ber_dupbv( &op->o_req_dn, &dn );
 766         ber_dupbv( &op->o_req_ndn, &ndn );
 767         sl_free( ndn.bv_val, op->o_tmpmemctx );
 768         sl_free( dn.bv_val, op->o_tmpmemctx );
 769
 770         if ( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_DELETE ) {
 771                 return NULL;
 772         }
 773
 774         e = ( Entry * ) ch_calloc( 1, sizeof( Entry ) );
 775         e->e_name = op->o_req_dn;
 776         e->e_nname = op->o_req_ndn;
 777
 778         while ( ber_remaining( ber ) ) {
 779                 if ( (ber_scanf( ber, "{mW}", &tmp.sml_type, &tmp.sml_values ) ==
 780                         LBER_ERROR ) || ( tmp.sml_type.bv_val == NULL ))
 781                 {
 782                         break;
 783                 }
 784
 785                 mod  = (Modifications *) ch_malloc( sizeof( Modifications ));
 786
 787                 mod->sml_op = LDAP_MOD_REPLACE;
 788                 mod->sml_next = NULL;
 789                 mod->sml_desc = NULL;
 790                 mod->sml_type = tmp.sml_type;
 791                 mod->sml_bvalues = tmp.sml_bvalues;
 792                 mod->sml_nvalues = NULL;
 793
 794                 *modtail = mod;
 795                 modtail = &mod->sml_next;
 796         }
 797
 798         if ( *modlist == NULL ) {
 799 #ifdef NEW_LOGGING
 800                 LDAP_LOG( OPERATION, ERR,
 801                                 "syncrepl_message_to_entry: no attributes\n", 0, 0, 0 );
 802 #else
 803                 Debug( LDAP_DEBUG_ANY, "syncrepl_message_to_entry: no attributes\n",
 804                                 0, 0, 0 );
 805 #endif
 806         }
 807
 808         rc = slap_mods_check( *modlist, 1, &text, txtbuf, textlen, NULL );
 809
 810         if ( rc != LDAP_SUCCESS ) {
 811 #ifdef NEW_LOGGING
 812                 LDAP_LOG( OPERATION, ERR,
 813                                 "syncrepl_message_to_entry: mods check (%s)\n", text, 0, 0 );
 814 #else
 815                 Debug( LDAP_DEBUG_ANY, "syncrepl_message_to_entry: mods check (%s)\n",
 816                                 text, 0, 0 );
 817 #endif
 818                 goto done;
 819         }
 820
 821         rc = slap_mods2entry( *modlist, &e, 1, 1, &text, txtbuf, textlen);
 822         if( rc != LDAP_SUCCESS ) {
 823 #ifdef NEW_LOGGING
 824                 LDAP_LOG( OPERATION, ERR,
 825                                 "syncrepl_message_to_entry: mods2entry (%s)\n", text, 0, 0 );
 826 #else
 827                 Debug( LDAP_DEBUG_ANY, "syncrepl_message_to_entry: mods2entry (%s)\n",
 828                                 text, 0, 0 );
 829 #endif
 830         }
 831
 832 done:
 833         ber_free ( ber, 0 );
 834         if ( rc != LDAP_SUCCESS ) {
 835                 entry_free( e );
 836                 e = NULL;
 837         }
 838
 839         return e;
 840 }
 841
 842 int
 843 syncuuid_cmp( const void* v_uuid1, const void* v_uuid2 )
 844 {
 845         const struct berval *uuid1 = v_uuid1;
 846         const struct berval *uuid2 = v_uuid2;
 847         int rc = uuid1->bv_len - uuid2->bv_len;
 848         if ( rc ) return rc;
 849         return ( strcmp( uuid1->bv_val, uuid2->bv_val ) );
 850 }
 851
 852 int
 853 syncrepl_entry(
 854         syncinfo_t* si,
 855         Operation *op,
 856         Entry* e,
 857         Modifications* modlist,
 858         int syncstate,
 859         struct berval* syncUUID,
 860         int refresh
 861 )
 862 {
 863         Backend *be = op->o_bd;
 864         slap_callback   cb;
 865         struct berval   *syncuuid_bv = NULL;
 866
 867         SlapReply       rs = {REP_RESULT};
 868         Filter f = {0};
 869         AttributeAssertion ava = {0};
 870         int rc = LDAP_SUCCESS;
 871         int ret = LDAP_SUCCESS;
 872
 873         if ( refresh &&
 874                 ( syncstate == LDAP_SYNC_PRESENT || syncstate == LDAP_SYNC_ADD ))
 875         {
 876                 syncuuid_bv = ber_dupbv( NULL, syncUUID );
 877                 avl_insert( &si->si_presentlist, (caddr_t) syncuuid_bv,
 878                         syncuuid_cmp, avl_dup_error );
 879         }
 880
 881         if ( syncstate == LDAP_SYNC_PRESENT ) {
 882                 return e ? 1 : 0;
 883         }
 884
 885         op->ors_filterstr.bv_len = (sizeof("entryUUID=")-1) + syncUUID->bv_len;
 886         op->ors_filterstr.bv_val = (char *) sl_malloc(
 887                 op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
 888         AC_MEMCPY( op->ors_filterstr.bv_val, "entryUUID=", sizeof("entryUUID=")-1 );
 889         AC_MEMCPY( &op->ors_filterstr.bv_val[sizeof("entryUUID=")-1],
 890                 syncUUID->bv_val, syncUUID->bv_len );
 891         op->ors_filterstr.bv_val[op->ors_filterstr.bv_len] = '\0';
 892
 893         f.f_choice = LDAP_FILTER_EQUALITY;
 894         f.f_ava = &ava;
 895         ava.aa_desc = slap_schema.si_ad_entryUUID;
 896         ava.aa_value = *syncUUID;
 897         op->ors_filter = &f;
 898         op->ors_scope = LDAP_SCOPE_SUBTREE;
 899
 900         /* get syncrepl cookie of shadow replica from subentry */
 901         op->o_req_dn = si->si_base;
 902         op->o_req_ndn = si->si_base;
 903
 904         /* set callback function */
 905         op->o_callback = &cb;
 906         cb.sc_response = dn_callback;
 907         cb.sc_private = si;
 908
 909         si->si_syncUUID_ndn.bv_val = NULL;
 910
 911         rc = be->be_search( op, &rs );
 912
 913         if ( op->ors_filterstr.bv_val ) {
 914                 sl_free( op->ors_filterstr.bv_val, op->o_tmpmemctx );
 915         }
 916
 917         cb.sc_response = null_callback;
 918         cb.sc_private = si;
 919
 920         if ( rc == LDAP_SUCCESS && si->si_syncUUID_ndn.bv_val &&
 921                 si->si_sync_mode != LDAP_SYNC_LOG_MODE )
 922         {
 923                 op->o_req_dn = si->si_syncUUID_ndn;
 924                 op->o_req_ndn = si->si_syncUUID_ndn;
 925                 op->o_tag = LDAP_REQ_DELETE;
 926                 rc = be->be_delete( op, &rs );
 927         }
 928
 929         switch ( syncstate ) {
 930         case LDAP_SYNC_ADD:
 931         case LDAP_SYNC_MODIFY:
 932                 if ( rc == LDAP_SUCCESS ||
 933                          rc == LDAP_REFERRAL ||
 934                          rc == LDAP_NO_SUCH_OBJECT )
 935                 {
 936                         attr_delete( &e->e_attrs, slap_schema.si_ad_entryUUID );
 937                         attr_merge_normalize_one( e, slap_schema.si_ad_entryUUID,
 938                                 syncUUID, op->o_tmpmemctx );
 939
 940                         op->o_tag = LDAP_REQ_ADD;
 941                         op->ora_e = e;
 942                         op->o_req_dn = e->e_name;
 943                         op->o_req_ndn = e->e_nname;
 944                         rc = be->be_add( op, &rs );
 945
 946                         if ( rc != LDAP_SUCCESS ) {
 947                                 if ( rc == LDAP_ALREADY_EXISTS ) {
 948                                         op->o_tag = LDAP_REQ_MODIFY;
 949                                         op->orm_modlist = modlist;
 950                                         op->o_req_dn = e->e_name;
 951                                         op->o_req_ndn = e->e_nname;
 952                                         rc = be->be_modify( op, &rs );
 953                                         if ( rc != LDAP_SUCCESS ) {
 954 #ifdef NEW_LOGGING
 955                                                 LDAP_LOG( OPERATION, ERR,
 956                                                         "syncrepl_entry : be_modify failed (%d)\n",
 957                                                         rc, 0, 0 );
 958 #else
 959                                                 Debug( LDAP_DEBUG_ANY,
 960                                                         "syncrepl_entry : be_modify failed (%d)\n",
 961                                                         rc, 0, 0 );
 962 #endif
 963                                         }
 964                                         ret = 1;
 965                                         goto done;
 966                                 } else if ( rc == LDAP_REFERRAL || rc == LDAP_NO_SUCH_OBJECT ) {
 967                                         syncrepl_add_glue( op, e );
 968                                         ret = 0;
 969                                         goto done;
 970                                 } else {
 971 #ifdef NEW_LOGGING
 972                                         LDAP_LOG( OPERATION, ERR,
 973                                                 "syncrepl_entry : be_add failed (%d)\n",
 974                                                 rc, 0, 0 );
 975 #else
 976                                         Debug( LDAP_DEBUG_ANY,
 977                                                 "syncrepl_entry : be_add failed (%d)\n",
 978                                                 rc, 0, 0 );
 979 #endif
 980                                         ret = 1;
 981                                         goto done;
 982                                 }
 983                         } else {
 984                                 be_entry_release_w( op, e );
 985                                 ret = 0;
 986                                 goto done;
 987                         }
 988                 } else {
 989 #ifdef NEW_LOGGING
 990                         LDAP_LOG( OPERATION, ERR,
 991                                 "syncrepl_entry : be_search failed (%d)\n", rc, 0, 0 );
 992 #else
 993                         Debug( LDAP_DEBUG_ANY,
 994                                 "syncrepl_entry : be_search failed (%d)\n", rc, 0, 0 );
 995 #endif
 996                         ret = 1;
 997                         goto done;
 998                 }
 999
1000         case LDAP_SYNC_DELETE :
1001                 if ( si->si_sync_mode == LDAP_SYNC_LOG_MODE ) {
1002                         if ( si->si_syncUUID_ndn.bv_val ) {
1003                                 op->o_req_dn = si->si_syncUUID_ndn;
1004                                 op->o_req_ndn = si->si_syncUUID_ndn;
1005                                 op->o_tag = LDAP_REQ_DELETE;
1006                                 rc = be->be_delete( op, &rs );
1007                         }
1008                 }
1009                 /* Already deleted otherwise */
1010                 ret = 1;
1011                 goto done;
1012
1013         default :
1014 #ifdef NEW_LOGGING
1015                 LDAP_LOG( OPERATION, ERR,
1016                         "syncrepl_entry : unknown syncstate\n", 0, 0, 0 );
1017 #else
1018                 Debug( LDAP_DEBUG_ANY,
1019                         "syncrepl_entry : unknown syncstate\n", 0, 0, 0 );
1020 #endif
1021                 ret = 1;
1022                 goto done;
1023         }
1024
1025 done :
1026
1027         if ( si->si_syncUUID_ndn.bv_val ) {
1028                 ber_memfree_x( si->si_syncUUID_ndn.bv_val, op->o_tmpmemctx );
1029         }
1030         return ret;
1031 }
1032
1033 static void
1034 syncrepl_del_nonpresent(
1035         Operation *op,
1036         syncinfo_t *si
1037 )
1038 {
1039         Backend* be = op->o_bd;
1040         slap_callback   cb;
1041         SlapReply       rs = {REP_RESULT};
1042         struct nonpresent_entry *np_list, *np_prev;
1043
1044         op->o_req_dn = si->si_base;
1045         op->o_req_ndn = si->si_base;
1046
1047         cb.sc_response = nonpresent_callback;
1048         cb.sc_private = si;
1049
1050         op->o_callback = &cb;
1051         op->o_tag = LDAP_REQ_SEARCH;
1052         op->ors_scope = si->si_scope;
1053         op->ors_deref = LDAP_DEREF_NEVER;
1054         op->ors_slimit = 0;
1055         op->ors_tlimit = 0;
1056         op->ors_attrsonly = 0;
1057         op->ors_attrs = NULL;
1058         op->ors_filter = str2filter_x( op, si->si_filterstr.bv_val );
1059         op->ors_filterstr = si->si_filterstr;
1060
1061         op->o_nocaching = 1;
1062         be->be_search( op, &rs );
1063         op->o_nocaching = 0;
1064
1065         if ( op->ors_filter ) filter_free_x( op, op->ors_filter );
1066
1067         if ( !LDAP_LIST_EMPTY( &si->si_nonpresentlist ) ) {
1068                 np_list = LDAP_LIST_FIRST( &si->si_nonpresentlist );
1069                 while ( np_list != NULL ) {
1070                         LDAP_LIST_REMOVE( np_list, npe_link );
1071                         np_prev = np_list;
1072                         np_list = LDAP_LIST_NEXT( np_list, npe_link );
1073                         op->o_tag = LDAP_REQ_DELETE;
1074                         op->o_callback = &cb;
1075                         cb.sc_response = null_callback;
1076                         cb.sc_private = si;
1077                         op->o_req_dn = *np_prev->npe_name;
1078                         op->o_req_ndn = *np_prev->npe_nname;
1079                         op->o_bd->be_delete( op, &rs );
1080                         ber_bvfree( np_prev->npe_name );
1081                         ber_bvfree( np_prev->npe_nname );
1082                         op->o_req_dn.bv_val = NULL;
1083                         op->o_req_ndn.bv_val = NULL;
1084                         ch_free( np_prev );
1085                 }
1086         }
1087
1088         return;
1089 }
1090
1091
1092 static struct berval gcbva[] = {
1093         BER_BVC("top"),
1094         BER_BVC("glue")
1095 };
1096
1097 void
1098 syncrepl_add_glue(
1099         Operation* op,
1100         Entry *e
1101 )
1102 {
1103         Backend *be = op->o_bd;
1104         slap_callback cb;
1105         Attribute       *a;
1106         int     rc;
1107         int suffrdns;
1108         int i;
1109         struct berval dn = {0, NULL};
1110         struct berval ndn = {0, NULL};
1111         Entry   *glue;
1112         SlapReply       rs = {REP_RESULT};
1113         char    *ptr, *comma;
1114
1115         op->o_tag = LDAP_REQ_ADD;
1116         op->o_callback = &cb;
1117         cb.sc_response = null_callback;
1118         cb.sc_private = NULL;
1119
1120         dn = e->e_name;
1121         ndn = e->e_nname;
1122
1123         /* count RDNs in suffix */
1124         if ( be->be_nsuffix[0].bv_len ) {
1125                 for (i=0, ptr=be->be_nsuffix[0].bv_val; ptr; ptr=strchr( ptr, ',' )) {
1126                         ptr++;
1127                         i++;
1128                 }
1129                 suffrdns = i;
1130         } else {
1131                 /* suffix is "" */
1132                 suffrdns = 0;
1133         }
1134
1135         /* Start with BE suffix */
1136         for ( i = 0, ptr = NULL; i < suffrdns; i++ ) {
1137                 comma = strrchr(dn.bv_val, ',');
1138                 if ( ptr ) *ptr = ',';
1139                 if ( comma ) *comma = '\0';
1140                 ptr = comma;
1141         }
1142         if ( ptr ) {
1143                 *ptr++ = ',';
1144                 dn.bv_len -= ptr - dn.bv_val;
1145                 dn.bv_val = ptr;
1146         }
1147         /* the normalizedDNs are always the same length, no counting
1148          * required.
1149          */
1150         if ( ndn.bv_len > be->be_nsuffix[0].bv_len ) {
1151                 ndn.bv_val += ndn.bv_len - be->be_nsuffix[0].bv_len;
1152                 ndn.bv_len = be->be_nsuffix[0].bv_len;
1153         }
1154
1155         while ( ndn.bv_val > e->e_nname.bv_val ) {
1156                 glue = (Entry *) ch_calloc( 1, sizeof(Entry) );
1157                 ber_dupbv( &glue->e_name, &dn );
1158                 ber_dupbv( &glue->e_nname, &ndn );
1159
1160                 a = ch_calloc( 1, sizeof( Attribute ));
1161                 a->a_desc = slap_schema.si_ad_objectClass;
1162
1163                 a->a_vals = ch_calloc( 3, sizeof( struct berval ));
1164                 ber_dupbv( &a->a_vals[0], &gcbva[0] );
1165                 ber_dupbv( &a->a_vals[1], &gcbva[1] );
1166                 a->a_vals[2].bv_len = 0;
1167                 a->a_vals[2].bv_val = NULL;
1168
1169                 a->a_nvals = a->a_vals;
1170
1171                 a->a_next = glue->e_attrs;
1172                 glue->e_attrs = a;
1173
1174                 a = ch_calloc( 1, sizeof( Attribute ));
1175                 a->a_desc = slap_schema.si_ad_structuralObjectClass;
1176
1177                 a->a_vals = ch_calloc( 2, sizeof( struct berval ));
1178                 ber_dupbv( &a->a_vals[0], &gcbva[1] );
1179                 a->a_vals[1].bv_len = 0;
1180                 a->a_vals[1].bv_val = NULL;
1181
1182                 a->a_nvals = a->a_vals;
1183
1184                 a->a_next = glue->e_attrs;
1185                 glue->e_attrs = a;
1186
1187                 op->o_req_dn = glue->e_name;
1188                 op->o_req_ndn = glue->e_nname;
1189                 op->ora_e = glue;
1190                 rc = be->be_add ( op, &rs );
1191                 if ( rc == LDAP_SUCCESS ) {
1192                         be_entry_release_w( op, glue );
1193                 } else {
1194                 /* incl. ALREADY EXIST */
1195                         entry_free( glue );
1196                 }
1197
1198                 /* Move to next child */
1199                 for (ptr = dn.bv_val-2; ptr > e->e_name.bv_val && *ptr != ','; ptr--) {
1200                         /* empty */
1201                 }
1202                 if ( ptr == e->e_name.bv_val ) break;
1203                 dn.bv_val = ++ptr;
1204                 dn.bv_len = e->e_name.bv_len - (ptr-e->e_name.bv_val);
1205                 for( ptr = ndn.bv_val-2;
1206                         ptr > e->e_nname.bv_val && *ptr != ',';
1207                         ptr--)
1208                 {
1209                         /* empty */
1210                 }
1211                 ndn.bv_val = ++ptr;
1212                 ndn.bv_len = e->e_nname.bv_len - (ptr-e->e_nname.bv_val);
1213         }
1214
1215         op->o_req_dn = e->e_name;
1216         op->o_req_ndn = e->e_nname;
1217         op->ora_e = e;
1218         rc = be->be_add ( op, &rs );
1219         if ( rc == LDAP_SUCCESS ) {
1220                 be_entry_release_w( op, e );
1221         } else {
1222                 entry_free( e );
1223         }
1224
1225         return;
1226 }
1227
1228 static struct berval ocbva[] = {
1229         BER_BVC("top"),
1230         BER_BVC("subentry"),
1231         BER_BVC("syncConsumerSubentry"),
1232         BER_BVNULL
1233 };
1234
1235 static struct berval cnbva[] = {
1236         BER_BVNULL,
1237         BER_BVNULL
1238 };
1239
1240 static struct berval ssbva[] = {
1241         BER_BVC("{}"),
1242         BER_BVNULL
1243 };
1244
1245 static struct berval scbva[] = {
1246         BER_BVNULL,
1247         BER_BVNULL
1248 };
1249
1250 void
1251 syncrepl_updateCookie(
1252         syncinfo_t *si,
1253         Operation *op,
1254         struct berval *pdn,
1255         struct berval *syncCookie
1256 )
1257 {
1258         Backend *be = op->o_bd;
1259         Modifications *ml;
1260         Modifications *mlnext;
1261         Modifications *mod;
1262         Modifications *modlist = NULL;
1263         Modifications **modtail = &modlist;
1264
1265         const char      *text;
1266         char txtbuf[SLAP_TEXT_BUFLEN];
1267         size_t textlen = sizeof txtbuf;
1268
1269         Entry* e = NULL;
1270         int rc;
1271
1272         char syncrepl_cbuf[sizeof(CN_STR SYNCREPL_STR)];
1273         struct berval slap_syncrepl_dn_bv = BER_BVNULL;
1274         struct berval slap_syncrepl_cn_bv = BER_BVNULL;
1275
1276         slap_callback cb;
1277         SlapReply       rs = {REP_RESULT};
1278
1279         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1280         mod->sml_op = LDAP_MOD_REPLACE;
1281         mod->sml_desc = slap_schema.si_ad_objectClass;
1282         mod->sml_type = mod->sml_desc->ad_cname;
1283         mod->sml_bvalues = ocbva;
1284         *modtail = mod;
1285         modtail = &mod->sml_next;
1286
1287         ber_dupbv( &cnbva[0], (struct berval *) &slap_syncrepl_bvc );
1288         assert( si->si_id < 1000 );
1289         cnbva[0].bv_len = snprintf( cnbva[0].bv_val,
1290                 slap_syncrepl_bvc.bv_len,
1291                 "syncrepl%d", si->si_id );
1292         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1293         mod->sml_op = LDAP_MOD_REPLACE;
1294         mod->sml_desc = slap_schema.si_ad_cn;
1295         mod->sml_type = mod->sml_desc->ad_cname;
1296         mod->sml_bvalues = cnbva;
1297         *modtail = mod;
1298         modtail = &mod->sml_next;
1299
1300         if ( scbva[0].bv_val ) ch_free( scbva[0].bv_val );
1301         ber_dupbv( &scbva[0], syncCookie );
1302         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1303         mod->sml_op = LDAP_MOD_REPLACE;
1304         mod->sml_desc = slap_schema.si_ad_syncreplCookie;
1305         mod->sml_type = mod->sml_desc->ad_cname;
1306         mod->sml_bvalues = scbva;
1307         *modtail = mod;
1308         modtail = &mod->sml_next;
1309
1310         mod = (Modifications *) ch_calloc( 1, sizeof( Modifications ));
1311         mod->sml_op = LDAP_MOD_REPLACE;
1312         mod->sml_desc = slap_schema.si_ad_subtreeSpecification;
1313         mod->sml_type = mod->sml_desc->ad_cname;
1314         mod->sml_bvalues = ssbva;
1315         *modtail = mod;
1316         modtail = &mod->sml_next;
1317
1318         mlnext = mod;
1319
1320         op->o_tag = LDAP_REQ_ADD;
1321         rc = slap_mods_opattrs( op, modlist, modtail,
1322                                                          &text,txtbuf, textlen );
1323
1324         for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
1325                 ml->sml_op = LDAP_MOD_REPLACE;
1326         }
1327
1328         if( rc != LDAP_SUCCESS ) {
1329 #ifdef NEW_LOGGING
1330                 LDAP_LOG( OPERATION, ERR,
1331                         "syncrepl_updateCookie: mods opattrs (%s)\n", text, 0, 0 );
1332 #else
1333                 Debug( LDAP_DEBUG_ANY, "syncrepl_updateCookie: mods opattrs (%s)\n",
1334                          text, 0, 0 );
1335 #endif
1336         }
1337
1338         e = ( Entry * ) ch_calloc( 1, sizeof( Entry ));
1339
1340         slap_syncrepl_cn_bv.bv_val = syncrepl_cbuf;
1341         assert( si->si_id < 1000 );
1342         slap_syncrepl_cn_bv.bv_len = snprintf( slap_syncrepl_cn_bv.bv_val,
1343                 slap_syncrepl_cn_bvc.bv_len,
1344                 "cn=syncrepl%d", si->si_id );
1345
1346         build_new_dn( &slap_syncrepl_dn_bv, pdn, &slap_syncrepl_cn_bv,
1347                 op->o_tmpmemctx );
1348         ber_dupbv( &e->e_name, &slap_syncrepl_dn_bv );
1349         ber_dupbv( &e->e_nname, &slap_syncrepl_dn_bv );
1350
1351         if ( slap_syncrepl_dn_bv.bv_val ) {
1352                 sl_free( slap_syncrepl_dn_bv.bv_val, op->o_tmpmemctx );
1353         }
1354
1355         e->e_attrs = NULL;
1356
1357         rc = slap_mods2entry( modlist, &e, 1, 1, &text, txtbuf, textlen );
1358
1359         if( rc != LDAP_SUCCESS ) {
1360 #ifdef NEW_LOGGING
1361                 LDAP_LOG( OPERATION, ERR,
1362                         "syncrepl_updateCookie: mods2entry (%s)\n", text, 0, 0 );
1363 #else
1364                 Debug( LDAP_DEBUG_ANY, "syncrepl_updateCookie: mods2entry (%s)\n",
1365                          text, 0, 0 );
1366 #endif
1367         }
1368
1369         cb.sc_response = null_callback;
1370         cb.sc_private = si;
1371
1372         op->o_callback = &cb;
1373         op->o_req_dn = e->e_name;
1374         op->o_req_ndn = e->e_nname;
1375
1376         /* update persistent cookie */
1377 update_cookie_retry:
1378         op->o_tag = LDAP_REQ_MODIFY;
1379         op->orm_modlist = modlist;
1380         rc = be->be_modify( op, &rs );
1381
1382         if ( rc != LDAP_SUCCESS ) {
1383                 if ( rc == LDAP_REFERRAL ||
1384                          rc == LDAP_NO_SUCH_OBJECT ) {
1385                         op->o_tag = LDAP_REQ_ADD;
1386                         op->ora_e = e;
1387                         rc = be->be_add( op, &rs );
1388                         if ( rc != LDAP_SUCCESS ) {
1389                                 if ( rc == LDAP_ALREADY_EXISTS ) {
1390                                         goto update_cookie_retry;
1391                                 } else if ( rc == LDAP_REFERRAL ||
1392                                                         rc == LDAP_NO_SUCH_OBJECT ) {
1393 #ifdef NEW_LOGGING
1394                                         LDAP_LOG( OPERATION, ERR,
1395                                                 "cookie will be non-persistent\n",
1396                                                 0, 0, 0 );
1397 #else
1398                                         Debug( LDAP_DEBUG_ANY,
1399                                                 "cookie will be non-persistent\n",
1400                                                 0, 0, 0 );
1401 #endif
1402                                 } else {
1403 #ifdef NEW_LOGGING
1404                                         LDAP_LOG( OPERATION, ERR,
1405                                                 "be_add failed (%d)\n",
1406                                                 rc, 0, 0 );
1407 #else
1408                                         Debug( LDAP_DEBUG_ANY,
1409                                                 "be_add failed (%d)\n",
1410                                                 rc, 0, 0 );
1411 #endif
1412                                 }
1413                         } else {
1414                                 be_entry_release_w( op, e );
1415                                 goto done;
1416                         }
1417                 } else {
1418 #ifdef NEW_LOGGING
1419                         LDAP_LOG( OPERATION, ERR,
1420                                 "be_modify failed (%d)\n", rc, 0, 0 );
1421 #else
1422                         Debug( LDAP_DEBUG_ANY,
1423                                 "be_modify failed (%d)\n", rc, 0, 0 );
1424 #endif
1425                 }
1426         }
1427
1428         if ( e != NULL ) {
1429                 entry_free( e );
1430         }
1431
1432 done :
1433
1434         if ( cnbva[0].bv_val ) {
1435                 ch_free( cnbva[0].bv_val );
1436                 cnbva[0].bv_val = NULL;
1437         }
1438         if ( scbva[0].bv_val ) {
1439                 ch_free( scbva[0].bv_val );
1440                 scbva[0].bv_val = NULL;
1441         }
1442
1443         if ( mlnext->sml_next ) {
1444                 slap_mods_free( mlnext->sml_next );
1445                 mlnext->sml_next = NULL;
1446         }
1447
1448         for (ml = modlist ; ml != NULL; ml = mlnext ) {
1449                 mlnext = ml->sml_next;
1450                 free( ml );
1451         }
1452
1453         return;
1454 }
1455
1456 void
1457 avl_ber_bvfree( void *bv )
1458 {
1459         if( bv == NULL ) {
1460                 return;
1461         }
1462         if ( ((struct berval *)bv)->bv_val != NULL ) {
1463                 ch_free ( ((struct berval *)bv)->bv_val );
1464         }
1465         ch_free ( (char *) bv );
1466 }
1467
1468 static int
1469 dn_callback(
1470         Operation*      op,
1471         SlapReply*      rs
1472 )
1473 {
1474         syncinfo_t *si = op->o_callback->sc_private;
1475
1476         if ( rs->sr_type == REP_SEARCH ) {
1477                 if ( si->si_syncUUID_ndn.bv_val != NULL ) {
1478 #ifdef NEW_LOGGING
1479                         LDAP_LOG( OPERATION, ERR,
1480                                 "dn_callback : multiple entries match dn\n", 0, 0, 0 );
1481 #else
1482                         Debug( LDAP_DEBUG_ANY,
1483                                 "dn_callback : multiple entries match dn\n", 0, 0, 0 );
1484 #endif
1485                 } else {
1486                         ber_dupbv_x( &si->si_syncUUID_ndn, &rs->sr_entry->e_nname, op->o_tmpmemctx );
1487                 }
1488         }
1489
1490         return LDAP_SUCCESS;
1491 }
1492
1493 static int
1494 nonpresent_callback(
1495         Operation*      op,
1496         SlapReply*      rs
1497 )
1498 {
1499         syncinfo_t *si = op->o_callback->sc_private;
1500         Attribute *a;
1501         int count = 0;
1502         struct berval* present_uuid = NULL;
1503         struct nonpresent_entry *np_entry;
1504
1505         if ( rs->sr_type == REP_RESULT ) {
1506                 count = avl_free( si->si_presentlist, avl_ber_bvfree );
1507                 si->si_presentlist = NULL;
1508
1509         } else if ( rs->sr_type == REP_SEARCH ) {
1510                 a = attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_entryUUID );
1511
1512                 if ( a == NULL ) return 0;
1513
1514                 present_uuid = avl_find( si->si_presentlist, &a->a_vals[0],
1515                         syncuuid_cmp );
1516
1517                 if ( present_uuid == NULL ) {
1518                         np_entry = (struct nonpresent_entry *)
1519                                 ch_calloc( 1, sizeof( struct nonpresent_entry ));
1520                         np_entry->npe_name = ber_dupbv( NULL, &rs->sr_entry->e_name );
1521                         np_entry->npe_nname = ber_dupbv( NULL, &rs->sr_entry->e_nname );
1522                         LDAP_LIST_INSERT_HEAD( &si->si_nonpresentlist, np_entry, npe_link );
1523
1524                 } else {
1525                         avl_delete( &si->si_presentlist,
1526                                         &a->a_vals[0], syncuuid_cmp );
1527                         ch_free( present_uuid->bv_val );
1528                         ch_free( present_uuid );
1529                 }
1530         }
1531         return LDAP_SUCCESS;
1532 }
1533
1534 static int
1535 null_callback(
1536         Operation*      op,
1537         SlapReply*      rs
1538 )
1539 {
1540         if ( rs->sr_err != LDAP_SUCCESS &&
1541                 rs->sr_err != LDAP_REFERRAL &&
1542                 rs->sr_err != LDAP_ALREADY_EXISTS &&
1543                 rs->sr_err != LDAP_NO_SUCH_OBJECT )
1544         {
1545 #ifdef NEW_LOGGING
1546                 LDAP_LOG( OPERATION, ERR,
1547                         "null_callback : error code 0x%x\n",
1548                         rs->sr_err, 0, 0 );
1549 #else
1550                 Debug( LDAP_DEBUG_ANY,
1551                         "null_callback : error code 0x%x\n",
1552                         rs->sr_err, 0, 0 );
1553 #endif
1554         }
1555         return LDAP_SUCCESS;
1556 }
1557
1558 Entry *
1559 slap_create_syncrepl_entry(
1560         Backend *be,
1561         struct berval *context_csn,
1562         struct berval *rdn,
1563         struct berval *cn
1564 )
1565 {
1566         Entry* e;
1567
1568         struct berval bv;
1569
1570         e = ( Entry * ) ch_calloc( 1, sizeof( Entry ));
1571
1572         attr_merge( e, slap_schema.si_ad_objectClass, ocbva, NULL );
1573
1574         attr_merge_one( e, slap_schema.si_ad_structuralObjectClass,
1575                 &ocbva[1], NULL );
1576
1577         attr_merge_one( e, slap_schema.si_ad_cn, cn, NULL );
1578
1579         if ( context_csn ) {
1580                 attr_merge_one( e, slap_schema.si_ad_syncreplCookie,
1581                         context_csn, NULL );
1582         }
1583
1584         bv.bv_val = "{}";
1585         bv.bv_len = sizeof("{}")-1;
1586         attr_merge_one( e, slap_schema.si_ad_subtreeSpecification, &bv, NULL );
1587
1588         build_new_dn( &e->e_name, &be->be_nsuffix[0], rdn, NULL );
1589         ber_dupbv( &e->e_nname, &e->e_name );
1590
1591         return e;
1592 }