Diff for /servers/slapd/overlays/syncprov.c between versions 1.56.2.9 and 1.83

version 1.56.2.9, 2005/07/11 05:55:33 version 1.83, 2005/05/09 03:02:01
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.88 2005/07/10 08:20:21 hallvard Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.82 2005/04/28 16:36:47 hyc 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/>.
  *   *
Line 548  syncprov_findcsn( Operation *op, int mod Line 548  syncprov_findcsn( Operation *op, int mod
         SlapReply frs = { REP_RESULT };          SlapReply frs = { REP_RESULT };
         char buf[LDAP_LUTIL_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")];          char buf[LDAP_LUTIL_CSNSTR_BUFSIZE + STRLENOF("(entryCSN<=)")];
         char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
         struct berval maxcsn;          struct berval fbuf, maxcsn;
         Filter cf, af;          Filter cf, af;
 #ifdef LDAP_COMP_MATCH  #ifdef LDAP_COMP_MATCH
         AttributeAssertion eq = { NULL, BER_BVNULL, NULL };          AttributeAssertion eq = { NULL, BER_BVNULL, NULL };
Line 572  syncprov_findcsn( Operation *op, int mod Line 572  syncprov_findcsn( Operation *op, int mod
         /* We want pure entries, not referrals */          /* We want pure entries, not referrals */
         fop.o_managedsait = SLAP_CONTROL_CRITICAL;          fop.o_managedsait = SLAP_CONTROL_CRITICAL;
   
           fbuf.bv_val = buf;
         cf.f_ava = &eq;          cf.f_ava = &eq;
         cf.f_av_desc = slap_schema.si_ad_entryCSN;          cf.f_av_desc = slap_schema.si_ad_entryCSN;
         cf.f_next = NULL;          cf.f_next = NULL;
Line 580  syncprov_findcsn( Operation *op, int mod Line 581  syncprov_findcsn( Operation *op, int mod
         fop.ors_limit = NULL;          fop.ors_limit = NULL;
         fop.ors_tlimit = SLAP_NO_LIMIT;          fop.ors_tlimit = SLAP_NO_LIMIT;
         fop.ors_filter = &cf;          fop.ors_filter = &cf;
         fop.ors_filterstr.bv_val = buf;          fop.ors_filterstr = fbuf;
   
         switch( mode ) {          switch( mode ) {
         case FIND_MAXCSN:          case FIND_MAXCSN:
                 cf.f_choice = LDAP_FILTER_GE;                  cf.f_choice = LDAP_FILTER_GE;
                 cf.f_av_value = si->si_ctxcsn;                  cf.f_av_value = si->si_ctxcsn;
                 fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN>=%s)",                  fbuf.bv_len = sprintf( buf, "(entryCSN>=%s)",
                         cf.f_av_value.bv_val );                          cf.f_av_value.bv_val );
                 fop.ors_attrsonly = 0;                  fop.ors_attrsonly = 0;
                 fop.ors_attrs = csn_anlist;                  fop.ors_attrs = csn_anlist;
Line 600  syncprov_findcsn( Operation *op, int mod Line 601  syncprov_findcsn( Operation *op, int mod
         case FIND_CSN:          case FIND_CSN:
                 cf.f_choice = LDAP_FILTER_LE;                  cf.f_choice = LDAP_FILTER_LE;
                 cf.f_av_value = srs->sr_state.ctxcsn;                  cf.f_av_value = srs->sr_state.ctxcsn;
                 fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",                  fbuf.bv_len = sprintf( buf, "(entryCSN<=%s)",
                         cf.f_av_value.bv_val );                          cf.f_av_value.bv_val );
                 fop.ors_attrsonly = 1;                  fop.ors_attrsonly = 1;
                 fop.ors_attrs = slap_anlist_no_attrs;                  fop.ors_attrs = slap_anlist_no_attrs;
Line 1074  syncprov_matchops( Operation *op, opcook Line 1075  syncprov_matchops( Operation *op, opcook
                 }                  }
         }          }
         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );          ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
   done:
         if ( op->o_tag != LDAP_REQ_ADD && e ) {          if ( op->o_tag != LDAP_REQ_ADD && e ) {
                 op->o_bd->bd_info = (BackendInfo *)on->on_info;                  op->o_bd->bd_info = (BackendInfo *)on->on_info;
                 be_entry_release_rw( op, e, 0 );                  be_entry_release_rw( op, e, 0 );
Line 1150  syncprov_checkpoint( Operation *op, Slap Line 1151  syncprov_checkpoint( Operation *op, Slap
         mod.sml_nvalues = NULL;          mod.sml_nvalues = NULL;
         mod.sml_desc = slap_schema.si_ad_contextCSN;          mod.sml_desc = slap_schema.si_ad_contextCSN;
         mod.sml_op = LDAP_MOD_REPLACE;          mod.sml_op = LDAP_MOD_REPLACE;
         mod.sml_flags = 0;  
         mod.sml_next = NULL;          mod.sml_next = NULL;
   
         cb.sc_response = slap_null_cb;          cb.sc_response = slap_null_cb;
Line 2113  typedef struct thread_keys { Line 2113  typedef struct thread_keys {
 /* A fake thread context */  /* A fake thread context */
 static thread_keys thrctx[MAXKEYS];  static thread_keys thrctx[MAXKEYS];
   
 /* ITS#3456 we cannot run this search on the main thread, must use a  
  * child thread in order to insure we have a big enough stack.  
  */  
 static void *  
 syncprov_db_otask(  
         void *ptr  
 )  
 {  
         syncprov_findcsn( ptr, FIND_MAXCSN );  
         return NULL;  
 }  
   
 /* Read any existing contextCSN from the underlying db.  /* Read any existing contextCSN from the underlying db.
  * Then search for any entries newer than that. If no value exists,   * Then search for any entries newer than that. If no value exists,
  * just generate it. Cache whatever result.   * just generate it. Cache whatever result.
Line 2166  syncprov_db_open( Line 2154  syncprov_db_open(
                 slap_schema.si_ad_contextCSN, 0, &e );                  slap_schema.si_ad_contextCSN, 0, &e );
   
         if ( e ) {          if ( e ) {
                 ldap_pvt_thread_t tid;  
   
                 a = attr_find( e->e_attrs, slap_schema.si_ad_contextCSN );                  a = attr_find( e->e_attrs, slap_schema.si_ad_contextCSN );
                 if ( a ) {                  if ( a ) {
                         si->si_ctxcsn.bv_len = a->a_nvals[0].bv_len;                          si->si_ctxcsn.bv_len = a->a_nvals[0].bv_len;
Line 2183  syncprov_db_open( Line 2169  syncprov_db_open(
                 op->o_req_dn = be->be_suffix[0];                  op->o_req_dn = be->be_suffix[0];
                 op->o_req_ndn = be->be_nsuffix[0];                  op->o_req_ndn = be->be_nsuffix[0];
                 op->ors_scope = LDAP_SCOPE_SUBTREE;                  op->ors_scope = LDAP_SCOPE_SUBTREE;
                 ldap_pvt_thread_create( &tid, 0, syncprov_db_otask, op );                  syncprov_findcsn( op, FIND_MAXCSN );
                 ldap_pvt_thread_join( tid, NULL );  
         } else if ( SLAP_SYNC_SHADOW( op->o_bd )) {          } else if ( SLAP_SYNC_SHADOW( op->o_bd )) {
                 /* If we're also a consumer, and we didn't find the context entry,                  /* If we're also a consumer, and we didn't find the context entry,
                  * then don't generate anything, wait for our provider to send it                   * then don't generate anything, wait for our provider to send it
Line 2199  syncprov_db_open( Line 2184  syncprov_db_open(
         }          }
   
         /* If our ctxcsn is different from what was read from the root          /* If our ctxcsn is different from what was read from the root
          * entry, make sure we do a checkpoint on close           * entry, write the new value out.
          */           */
         if ( strcmp( si->si_ctxcsnbuf, ctxcsnbuf )) {          if ( strcmp( si->si_ctxcsnbuf, ctxcsnbuf )) {
                 si->si_numops++;                  SlapReply rs = {REP_RESULT};
                   syncprov_checkpoint( op, &rs, on );
         }          }
   
 out:  out:
Line 2404  syncprov_init() Line 2390  syncprov_init()
                 SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,                  SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,
                 syncprov_parseCtrl, &slap_cids.sc_LDAPsync );                  syncprov_parseCtrl, &slap_cids.sc_LDAPsync );
         if ( rc != LDAP_SUCCESS ) {          if ( rc != LDAP_SUCCESS ) {
                 Debug( LDAP_DEBUG_ANY,                  fprintf( stderr, "Failed to register control %d\n", rc );
                         "syncprov_init: Failed to register control %d\n", rc, 0, 0 );  
                 return rc;                  return rc;
         }          }
   

Removed from v.1.56.2.9  
changed lines
  Added in v.1.83


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