Diff for /servers/slapd/overlays/syncprov.c between versions 1.147.2.68 and 1.318

version 1.147.2.68, 2009/11/22 16:32:30 version 1.318, 2010/11/21 16:56:09
Line 1 Line 1
 /* $OpenLDAP$ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.317 2010/11/21 14:31:38 rein Exp $ */
 /* syncprov.c - syncrepl provider */  /* syncprov.c - syncrepl provider */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2004-2009 The OpenLDAP Foundation.   * Copyright 2004-2010 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 133  typedef struct syncprov_info_t { Line 133  typedef struct syncprov_info_t {
         int             si_numops;      /* number of ops since last checkpoint */          int             si_numops;      /* number of ops since last checkpoint */
         int             si_nopres;      /* Skip present phase */          int             si_nopres;      /* Skip present phase */
         int             si_usehint;     /* use reload hint */          int             si_usehint;     /* use reload hint */
           int             si_active;      /* True if there are active mods */
           int             si_dirty;       /* True if the context is dirty, i.e changes
                                                    * have been made without updating the csn. */
         time_t  si_chklast;     /* time of last checkpoint */          time_t  si_chklast;     /* time of last checkpoint */
         Avlnode *si_mods;       /* entries being modified */          Avlnode *si_mods;       /* entries being modified */
         sessionlog      *si_logs;          sessionlog      *si_logs;
Line 591  syncprov_findcsn( Operation *op, find_cs Line 594  syncprov_findcsn( Operation *op, find_cs
         slap_callback cb = {0};          slap_callback cb = {0};
         Operation fop;          Operation fop;
         SlapReply frs = { REP_RESULT };          SlapReply frs = { REP_RESULT };
         char buf[LDAP_LUTIL_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")];          char buf[LDAP_PVT_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")];
         char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char cbuf[LDAP_PVT_CSNSTR_BUFSIZE];
         struct berval maxcsn;          struct berval maxcsn;
         Filter cf;          Filter cf;
         AttributeAssertion eq = ATTRIBUTEASSERTION_INIT;          AttributeAssertion eq = ATTRIBUTEASSERTION_INIT;
Line 783  syncprov_free_syncop( syncops *so ) Line 786  syncprov_free_syncop( syncops *so )
         GroupAssertion *ga, *gnext;          GroupAssertion *ga, *gnext;
   
         ldap_pvt_thread_mutex_lock( &so->s_mutex );          ldap_pvt_thread_mutex_lock( &so->s_mutex );
         if ( --so->s_inuse > 0 ) {          /* already being freed, or still in use */
           if ( !so->s_inuse || --so->s_inuse > 0 ) {
                 ldap_pvt_thread_mutex_unlock( &so->s_mutex );                  ldap_pvt_thread_mutex_unlock( &so->s_mutex );
                 return;                  return;
         }          }
Line 853  syncprov_sendresp( Operation *op, opcook Line 857  syncprov_sendresp( Operation *op, opcook
         }          }
   
         rs.sr_ctrls = ctrls;          rs.sr_ctrls = ctrls;
           rs.sr_entry = &e_uuid;
           if ( mode == LDAP_SYNC_ADD || mode == LDAP_SYNC_MODIFY ) {
                   e_uuid = *opc->se;
                   e_uuid.e_private = NULL;
           }
   
         switch( mode ) {          switch( mode ) {
         case LDAP_SYNC_ADD:          case LDAP_SYNC_ADD:
                 rs.sr_entry = opc->se;  
                 if ( opc->sreference && so->s_op->o_managedsait <= SLAP_CONTROL_IGNORED ) {                  if ( opc->sreference && so->s_op->o_managedsait <= SLAP_CONTROL_IGNORED ) {
                         rs.sr_ref = get_entry_referrals( op, rs.sr_entry );                          rs.sr_ref = get_entry_referrals( op, rs.sr_entry );
                         rs.sr_err = send_search_reference( op, &rs );                          rs.sr_err = send_search_reference( op, &rs );
Line 864  syncprov_sendresp( Operation *op, opcook Line 873  syncprov_sendresp( Operation *op, opcook
                 }                  }
                 /* fallthru */                  /* fallthru */
         case LDAP_SYNC_MODIFY:          case LDAP_SYNC_MODIFY:
                 rs.sr_entry = opc->se;  
                 rs.sr_attrs = op->ors_attrs;                  rs.sr_attrs = op->ors_attrs;
                 rs.sr_err = send_search_entry( op, &rs );                  rs.sr_err = send_search_entry( op, &rs );
                 break;                  break;
Line 872  syncprov_sendresp( Operation *op, opcook Line 880  syncprov_sendresp( Operation *op, opcook
                 e_uuid.e_attrs = NULL;                  e_uuid.e_attrs = NULL;
                 e_uuid.e_name = opc->sdn;                  e_uuid.e_name = opc->sdn;
                 e_uuid.e_nname = opc->sndn;                  e_uuid.e_nname = opc->sndn;
                 rs.sr_entry = &e_uuid;  
                 if ( opc->sreference && so->s_op->o_managedsait <= SLAP_CONTROL_IGNORED ) {                  if ( opc->sreference && so->s_op->o_managedsait <= SLAP_CONTROL_IGNORED ) {
                         struct berval bv = BER_BVNULL;                          struct berval bv = BER_BVNULL;
                         rs.sr_ref = &bv;                          rs.sr_ref = &bv;
Line 928  syncprov_qplay( Operation *op, syncops * Line 935  syncprov_qplay( Operation *op, syncops *
                 ldap_pvt_thread_mutex_unlock( &so->s_mutex );                  ldap_pvt_thread_mutex_unlock( &so->s_mutex );
   
                 if ( sr->s_mode == LDAP_SYNC_NEW_COOKIE ) {                  if ( sr->s_mode == LDAP_SYNC_NEW_COOKIE ) {
                     SlapReply rs = { REP_INTERMEDIATE };                          SlapReply rs = { REP_INTERMEDIATE };
   
                     rc = syncprov_sendinfo( op, &rs, LDAP_TAG_SYNC_NEW_COOKIE,                          rc = syncprov_sendinfo( op, &rs, LDAP_TAG_SYNC_NEW_COOKIE,
                                 &sr->s_csn, 0, NULL, 0 );                                  &sr->s_csn, 0, NULL, 0 );
                 } else {                  } else {
                         opc.sdn = sr->s_dn;                          opc.sdn = sr->s_dn;
Line 942  syncprov_qplay( Operation *op, syncops * Line 949  syncprov_qplay( Operation *op, syncops *
   
                         rc = syncprov_sendresp( op, &opc, so, sr->s_mode );                          rc = syncprov_sendresp( op, &opc, so, sr->s_mode );
   
                         if ( opc.se ) {                  }
                                 if ( !dec_mutexint( opc.se->e_private )) {                  if ( sr->s_e ) {
                                         opc.se->e_private = NULL;                          if ( !dec_mutexint( sr->s_e->e_private )) {
                                         entry_free ( opc.se );                                  sr->s_e->e_private = NULL;
                                 }                                  entry_free ( sr->s_e );
                         }                          }
                 }                  }
   
Line 981  syncprov_qtask( void *ctx, void *arg ) Line 988  syncprov_qtask( void *ctx, void *arg )
         Operation *op;          Operation *op;
         BackendDB be;          BackendDB be;
         int rc;          int rc;
         OpExtra oex;  
   
         op = &opbuf.ob_op;          op = &opbuf.ob_op;
         *op = *so->s_op;          *op = *so->s_op;
Line 1000  syncprov_qtask( void *ctx, void *arg ) Line 1006  syncprov_qtask( void *ctx, void *arg )
         be.be_flags |= SLAP_DBFLAG_OVERLAY;          be.be_flags |= SLAP_DBFLAG_OVERLAY;
         op->o_bd = &be;          op->o_bd = &be;
         LDAP_SLIST_FIRST(&op->o_extra) = NULL;          LDAP_SLIST_FIRST(&op->o_extra) = NULL;
   
         /* Let syncprov_operational know it's us */  
         oex.oe_key = (void *)syncprov_qtask;  
         LDAP_SLIST_INSERT_HEAD(&op->o_extra, &oex, oe_next);  
   
         op->o_callback = NULL;          op->o_callback = NULL;
   
         rc = syncprov_qplay( op, so );          rc = syncprov_qplay( op, so );
Line 1296  syncprov_matchops( Operation *op, opcook Line 1297  syncprov_matchops( Operation *op, opcook
                 }                  }
   
                 if ( fc.fscope ) {                  if ( fc.fscope ) {
                           ldap_pvt_thread_mutex_lock( &ss->s_mutex );
                         op2 = *ss->s_op;                          op2 = *ss->s_op;
                         oh = *op->o_hdr;                          oh = *op->o_hdr;
                         oh.oh_conn = ss->s_op->o_conn;                          oh.oh_conn = ss->s_op->o_conn;
Line 1304  syncprov_matchops( Operation *op, opcook Line 1306  syncprov_matchops( Operation *op, opcook
                         op2.o_hdr = &oh;                          op2.o_hdr = &oh;
                         op2.o_extra = op->o_extra;                          op2.o_extra = op->o_extra;
                         op2.o_callback = NULL;                          op2.o_callback = NULL;
                         rc = test_filter( &op2, e, ss->s_op->ors_filter );                          if (ss->s_flags & PS_FIX_FILTER) {
                                   /* Skip the AND/GE clause that we stuck on in front. We
                                      would lose deletes/mods that happen during the refresh
                                      phase otherwise (ITS#6555) */
                                   op2.ors_filter = ss->s_op->ors_filter->f_and->f_next;
                           }
                           ldap_pvt_thread_mutex_unlock( &ss->s_mutex );
                           rc = test_filter( &op2, e, op2.ors_filter );
                 }                  }
   
                 Debug( LDAP_DEBUG_TRACE, "syncprov_matchops: sid %03x fscope %d rc %d\n",                  Debug( LDAP_DEBUG_TRACE, "syncprov_matchops: sid %03x fscope %d rc %d\n",
Line 1371  syncprov_op_cleanup( Operation *op, Slap Line 1380  syncprov_op_cleanup( Operation *op, Slap
         syncmatches *sm, *snext;          syncmatches *sm, *snext;
         modtarget *mt, mtdummy;          modtarget *mt, mtdummy;
   
           ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
           if ( si->si_active )
                   si->si_active--;
           ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
   
         for (sm = opc->smatches; sm; sm=snext) {          for (sm = opc->smatches; sm; sm=snext) {
                 snext = sm->sm_next;                  snext = sm->sm_next;
                 syncprov_free_syncop( sm->sm_op );                  syncprov_free_syncop( sm->sm_op );
Line 1416  syncprov_checkpoint( Operation *op, Slap Line 1430  syncprov_checkpoint( Operation *op, Slap
         SlapReply rsm = { 0 };          SlapReply rsm = { 0 };
         slap_callback cb = {0};          slap_callback cb = {0};
         BackendDB be;          BackendDB be;
           BackendInfo *bi;
   
 #ifdef CHECK_CSN  #ifdef CHECK_CSN
         Syntax *syn = slap_schema.si_ad_contextCSN->ad_type->sat_syntax;          Syntax *syn = slap_schema.si_ad_contextCSN->ad_type->sat_syntax;
Line 1445  syncprov_checkpoint( Operation *op, Slap Line 1460  syncprov_checkpoint( Operation *op, Slap
         }          }
         opm.o_req_dn = si->si_contextdn;          opm.o_req_dn = si->si_contextdn;
         opm.o_req_ndn = si->si_contextdn;          opm.o_req_ndn = si->si_contextdn;
           bi = opm.o_bd->bd_info;
         opm.o_bd->bd_info = on->on_info->oi_orig;          opm.o_bd->bd_info = on->on_info->oi_orig;
         opm.o_managedsait = SLAP_CONTROL_NONCRITICAL;          opm.o_managedsait = SLAP_CONTROL_NONCRITICAL;
         opm.o_no_schema_check = 1;          opm.o_no_schema_check = 1;
Line 1462  syncprov_checkpoint( Operation *op, Slap Line 1478  syncprov_checkpoint( Operation *op, Slap
                 if ( e == opm.ora_e )                  if ( e == opm.ora_e )
                         be_entry_release_w( &opm, opm.ora_e );                          be_entry_release_w( &opm, opm.ora_e );
         }          }
           opm.o_bd->bd_info = bi;
   
         if ( mod.sml_next != NULL ) {          if ( mod.sml_next != NULL ) {
                 slap_mods_free( mod.sml_next, 1 );                  slap_mods_free( mod.sml_next, 1 );
Line 1538  syncprov_playlog( Operation *op, SlapRep Line 1555  syncprov_playlog( Operation *op, SlapRep
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
         slog_entry *se;          slog_entry *se;
         int i, j, ndel, num, nmods, mmods;          int i, j, ndel, num, nmods, mmods;
         char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char cbuf[LDAP_PVT_CSNSTR_BUFSIZE];
         BerVarray uuids;          BerVarray uuids;
         struct berval delcsn[2];          struct berval delcsn[2];
   
Line 1713  syncprov_op_response( Operation *op, Sla Line 1730  syncprov_op_response( Operation *op, Sla
         if ( rs->sr_err == LDAP_SUCCESS )          if ( rs->sr_err == LDAP_SUCCESS )
         {          {
                 struct berval maxcsn;                  struct berval maxcsn;
                 char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];                  char cbuf[LDAP_PVT_CSNSTR_BUFSIZE];
                 int do_check = 0, have_psearches, foundit, csn_changed = 0;                  int do_check = 0, have_psearches, foundit, csn_changed = 0;
   
                 ldap_pvt_thread_mutex_lock( &si->si_resp_mutex );                  ldap_pvt_thread_mutex_lock( &si->si_resp_mutex );
Line 1798  syncprov_op_response( Operation *op, Sla Line 1815  syncprov_op_response( Operation *op, Sla
                                         csn_changed = 1;                                          csn_changed = 1;
                                 }                                  }
                         }                          }
                           if ( csn_changed )
                                   si->si_dirty = 0;
                         ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
   
                         if ( csn_changed ) {                          if ( csn_changed ) {
Line 1841  syncprov_op_response( Operation *op, Sla Line 1860  syncprov_op_response( Operation *op, Sla
                                 }                                  }
                         }                          }
                 }                  }
                   si->si_dirty = !csn_changed;
                 ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );                  ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
   
                 if ( do_check ) {                  if ( do_check ) {
Line 1968  syncprov_op_mod( Operation *op, SlapRepl Line 1988  syncprov_op_mod( Operation *op, SlapRepl
   
         ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );          ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
         have_psearches = ( si->si_ops != NULL );          have_psearches = ( si->si_ops != NULL );
           si->si_active++;
         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );          ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
   
         cbsize = sizeof(slap_callback) + sizeof(opcookie) +          cbsize = sizeof(slap_callback) + sizeof(opcookie) +
Line 2358  syncprov_op_search( Operation *op, SlapR Line 2379  syncprov_op_search( Operation *op, SlapR
         BerVarray ctxcsn;          BerVarray ctxcsn;
         int i, *sids, numcsns;          int i, *sids, numcsns;
         struct berval mincsn;          struct berval mincsn;
           int dirty = 0;
   
         if ( !(op->o_sync_mode & SLAP_SYNC_REFRESH) ) return SLAP_CB_CONTINUE;          if ( !(op->o_sync_mode & SLAP_SYNC_REFRESH) ) return SLAP_CB_CONTINUE;
   
Line 2402  syncprov_op_search( Operation *op, SlapR Line 2424  syncprov_op_search( Operation *op, SlapR
                 sop->s_inuse = 1;                  sop->s_inuse = 1;
   
                 ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );                  ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
                   while ( si->si_active ) {
                           /* Wait for active mods to finish before proceeding, as they
                            * may already have inspected the si_ops list looking for
                            * consumers to replicate the change to.  Using the log
                            * doesn't help, as we may finish playing it before the
                            * active mods gets added to it.
                            */
                           ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
                           if ( slapd_shutdown )
                                   return SLAPD_ABANDON;
                           if ( !ldap_pvt_thread_pool_pausecheck( &connection_pool ))
                                   ldap_pvt_thread_yield();
                           ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
                   }
                 sop->s_next = si->si_ops;                  sop->s_next = si->si_ops;
                 si->si_ops = sop;                  si->si_ops = sop;
                 ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );                  ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
Line 2419  syncprov_op_search( Operation *op, SlapR Line 2455  syncprov_op_search( Operation *op, SlapR
                 ctxcsn = NULL;                  ctxcsn = NULL;
                 sids = NULL;                  sids = NULL;
         }          }
           dirty = si->si_dirty;
         ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );          ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
                   
         /* If we have a cookie, handle the PRESENT lookups */          /* If we have a cookie, handle the PRESENT lookups */
Line 2475  syncprov_op_search( Operation *op, SlapR Line 2512  syncprov_op_search( Operation *op, SlapR
                                         if ( newer < 0 )                                          if ( newer < 0 )
                                                 changed = SS_CHANGED;                                                  changed = SS_CHANGED;
                                         else if ( newer > 0 ) {                                          else if ( newer > 0 ) {
                                         /* our state is older, tell consumer nothing */                                          /* our state is older, complain to consumer */
                                                   rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
                                                   rs->sr_text = "consumer state is newer than provider!";
   bailout:
                                                 if ( sop ) {                                                  if ( sop ) {
                                                         syncops **sp = &si->si_ops;                                                          syncops **sp = &si->si_ops;
                                                                                                                   
Line 2486  syncprov_op_search( Operation *op, SlapR Line 2526  syncprov_op_search( Operation *op, SlapR
                                                         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );                                                          ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
                                                         ch_free( sop );                                                          ch_free( sop );
                                                 }                                                  }
                                                 rs->sr_err = LDAP_SUCCESS;  
                                                 rs->sr_ctrls = NULL;                                                  rs->sr_ctrls = NULL;
                                                 send_ldap_result( op, rs );                                                  send_ldap_result( op, rs );
                                                 return rs->sr_err;                                                  return rs->sr_err;
Line 2496  syncprov_op_search( Operation *op, SlapR Line 2535  syncprov_op_search( Operation *op, SlapR
                                 if ( changed )                                  if ( changed )
                                         break;                                          break;
                         }                          }
                         if ( !changed ) {                          if ( !changed && !dirty ) {
                                 do_present = 0;                                  do_present = 0;
 no_change:              if ( !(op->o_sync_mode & SLAP_SYNC_PERSIST) ) {  no_change:              if ( !(op->o_sync_mode & SLAP_SYNC_PERSIST) ) {
                                         LDAPControl     *ctrls[2];                                          LDAPControl     *ctrls[2];
Line 2541  no_change:  if ( !(op->o_sync_mode & SLA Line 2580  no_change:  if ( !(op->o_sync_mode & SLA
                                         ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );                                          ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );
                                 if ( sids )                                  if ( sids )
                                         op->o_tmpfree( sids, op->o_tmpmemctx );                                          op->o_tmpfree( sids, op->o_tmpmemctx );
                                 send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" );                                  rs->sr_err = LDAP_SYNC_REFRESH_REQUIRED;
                                 return rs->sr_err;                                  rs->sr_text = "sync cookie is stale";
                                   goto bailout;
                         }                          }
                         if ( srs->sr_state.ctxcsn ) {                          if ( srs->sr_state.ctxcsn ) {
                                 ber_bvarray_free_x( srs->sr_state.ctxcsn, op->o_tmpmemctx );                                  ber_bvarray_free_x( srs->sr_state.ctxcsn, op->o_tmpmemctx );
Line 2562  no_change:  if ( !(op->o_sync_mode & SLA Line 2602  no_change:  if ( !(op->o_sync_mode & SLA
                                         ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );                                          ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );
                                 if ( sids )                                  if ( sids )
                                         op->o_tmpfree( sids, op->o_tmpmemctx );                                          op->o_tmpfree( sids, op->o_tmpmemctx );
                                 send_ldap_result( op, rs );                                  goto bailout;
                                 return rs->sr_err;  
                         }                          }
                 }                  }
         } else {          } else {
Line 2580  shortcut: Line 2619  shortcut:
         }          }
   
         /* If something changed, find the changes */          /* If something changed, find the changes */
         if ( gotstate && changed ) {          if ( gotstate && ( changed || dirty ) ) {
                 Filter *fand, *fava;                  Filter *fand, *fava;
   
                 fand = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );                  fand = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );
Line 2596  shortcut: Line 2635  shortcut:
 #endif  #endif
                 ber_dupbv_x( &fava->f_ava->aa_value, &mincsn, op->o_tmpmemctx );                  ber_dupbv_x( &fava->f_ava->aa_value, &mincsn, op->o_tmpmemctx );
                 fava->f_next = op->ors_filter;                  fava->f_next = op->ors_filter;
                   if ( sop )
                           ldap_pvt_thread_mutex_lock( &sop->s_mutex );
                 op->ors_filter = fand;                  op->ors_filter = fand;
                 filter2bv_x( op, op->ors_filter, &op->ors_filterstr );                  filter2bv_x( op, op->ors_filter, &op->ors_filterstr );
                 if ( sop )                  if ( sop ) {
                         sop->s_flags |= PS_FIX_FILTER;                          sop->s_flags |= PS_FIX_FILTER;
                           ldap_pvt_thread_mutex_unlock( &sop->s_mutex );
                   }
         }          }
   
         /* Let our callback add needed info to returned entries */          /* Let our callback add needed info to returned entries */
Line 2621  shortcut: Line 2664  shortcut:
          * the refresh phase, just invoke the response callback to transition           * the refresh phase, just invoke the response callback to transition
          * us into persist phase           * us into persist phase
          */           */
         if ( !changed ) {          if ( !changed && !dirty ) {
                 rs->sr_err = LDAP_SUCCESS;                  rs->sr_err = LDAP_SUCCESS;
                 rs->sr_nentries = 0;                  rs->sr_nentries = 0;
                 send_ldap_result( op, rs );                  send_ldap_result( op, rs );
Line 2637  syncprov_operational( Line 2680  syncprov_operational(
 {  {
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
         syncprov_info_t         *si = (syncprov_info_t *)on->on_bi.bi_private;          syncprov_info_t         *si = (syncprov_info_t *)on->on_bi.bi_private;
         OpExtra         *oex;  
   
         /* short-circuit, don't want backends handling this */  
         LDAP_SLIST_FOREACH(oex, &op->o_extra, oe_next) {  
                 if ( oex->oe_key == (void *)syncprov_qtask )  
                         return LDAP_SUCCESS;  
         }  
   
         /* This prevents generating unnecessarily; frontend will strip          /* This prevents generating unnecessarily; frontend will strip
          * any statically stored copy.           * any statically stored copy.
Line 2869  sp_cf_gen(ConfigArgs *c) Line 2905  sp_cf_gen(ConfigArgs *c)
                 }                  }
                 sl = si->si_logs;                  sl = si->si_logs;
                 if ( !sl ) {                  if ( !sl ) {
                         sl = ch_malloc( sizeof( sessionlog ) + LDAP_LUTIL_CSNSTR_BUFSIZE );                          sl = ch_malloc( sizeof( sessionlog ) + LDAP_PVT_CSNSTR_BUFSIZE );
                         sl->sl_mincsn.bv_val = (char *)(sl+1);                          sl->sl_mincsn.bv_val = (char *)(sl+1);
                         sl->sl_mincsn.bv_len = 0;                          sl->sl_mincsn.bv_len = 0;
                         sl->sl_num = 0;                          sl->sl_num = 0;
Line 2975  syncprov_db_open( Line 3011  syncprov_db_open(
   
         /* Didn't find a contextCSN, should we generate one? */          /* Didn't find a contextCSN, should we generate one? */
         if ( !si->si_ctxcsn ) {          if ( !si->si_ctxcsn ) {
                 char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE ];                  char csnbuf[ LDAP_PVT_CSNSTR_BUFSIZE ];
                 struct berval csn;                  struct berval csn;
   
                 if ( SLAP_SYNC_SHADOW( op->o_bd )) {                  if ( SLAP_SYNC_SHADOW( op->o_bd )) {
Line 3012  syncprov_db_close( Line 3048  syncprov_db_close(
 {  {
     slap_overinst   *on = (slap_overinst *) be->bd_info;      slap_overinst   *on = (slap_overinst *) be->bd_info;
     syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;      syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;
   #ifdef SLAP_CONFIG_DELETE
           syncops *so, *sonext;
   #endif /* SLAP_CONFIG_DELETE */
   
         if ( slapMode & SLAP_TOOL_MODE ) {          if ( slapMode & SLAP_TOOL_MODE ) {
                 return 0;                  return 0;
Line 3032  syncprov_db_close( Line 3071  syncprov_db_close(
                 syncprov_checkpoint( op, &rs, on );                  syncprov_checkpoint( op, &rs, on );
         }          }
   
   #ifdef SLAP_CONFIG_DELETE
           ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
           for ( so=si->si_ops, sonext=so;  so; so=sonext  ) {
                   SlapReply rs = {REP_RESULT};
                   rs.sr_err = LDAP_UNAVAILABLE;
                   send_ldap_result( so->s_op, &rs );
                   sonext=so->s_next;
                   syncprov_drop_psearch( so, 0);
           }
           si->si_ops=NULL;
           ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
           overlay_unregister_control( be, LDAP_CONTROL_SYNC );
   #endif /* SLAP_CONFIG_DELETE */
   
     return 0;      return 0;
 }  }
   

Removed from v.1.147.2.68  
changed lines
  Added in v.1.318


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org