Diff for /servers/slapd/overlays/syncprov.c between versions 1.36 and 1.37

version 1.36, 2004/11/29 18:33:35 version 1.37, 2004/12/05 19:52:49
Line 478  syncprov_findbase( Operation *op, fbase_ Line 478  syncprov_findbase( Operation *op, fbase_
 }  }
   
 /* syncprov_findcsn:  /* syncprov_findcsn:
  *   This function has two different purposes, but they both use a search   *   This function has three different purposes, but they all use a search
  * that filters on entryCSN so they're combined here.   * that filters on entryCSN so they're combined here.
  * 1: when the current contextCSN is known and we have a sync cookie, we search   * 1: at startup time, after a contextCSN has been read from the database,
    * we search for all entries with CSN >= contextCSN in case the contextCSN
    * was not checkpointed at the previous shutdown.
    *
    * 2: when the current contextCSN is known and we have a sync cookie, we search
  * for one entry with CSN <= the cookie CSN. (Used to search for =.) If an   * for one entry with CSN <= the cookie CSN. (Used to search for =.) If an
  * entry is found, the cookie CSN is valid, otherwise it is stale.   * entry is found, the cookie CSN is valid, otherwise it is stale.
  *   *
  * 2: during a refresh phase, we search for all entries with CSN <= the cookie   * 3: during a refresh phase, we search for all entries with CSN <= the cookie
  * CSN, and generate Present records for them. We always collect this result   * CSN, and generate Present records for them. We always collect this result
  * in SyncID sets, even if there's only one match.   * in SyncID sets, even if there's only one match.
  */   */
 #define FIND_CSN        1  #define FIND_MAXCSN     1
 #define FIND_PRESENT    2  #define FIND_CSN        2
   #define FIND_PRESENT    3
   
   static int
   findmax_cb( Operation *op, SlapReply *rs )
   {
           if ( rs->sr_type == REP_SEARCH && rs->sr_err == LDAP_SUCCESS ) {
                   struct berval *maxcsn = op->o_callback->sc_private;
                   Attribute *a = attr_find( rs->sr_entry->e_attrs,
                           slap_schema.si_ad_entryCSN );
   
                   if ( a && ber_bvcmp( &a->a_vals[0], maxcsn )) {
                           maxcsn->bv_len = a->a_vals[0].bv_len;
                           strcpy( maxcsn->bv_val, a->a_vals[0].bv_val );
                   }
           }
           return LDAP_SUCCESS;
   }
   
 static int  static int
 findcsn_cb( Operation *op, SlapReply *rs )  findcsn_cb( Operation *op, SlapReply *rs )
Line 556  syncprov_findcsn( Operation *op, int mod Line 577  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 fbuf;          struct berval fbuf, maxcsn;
         Filter cf;          Filter cf;
         AttributeAssertion eq;          AttributeAssertion eq;
         int rc;          int rc = LDAP_SUCCESS;
         fpres_cookie pcookie;          fpres_cookie pcookie;
         int locked = 0;          int locked = 0;
         sync_control *srs = op->o_controls[slap_cids.sc_LDAPsync];          sync_control *srs;
   
           if ( mode != FIND_MAXCSN ) {
                   srs = op->o_controls[slap_cids.sc_LDAPsync];
   
         if ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {                  if ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {
                 return LDAP_OTHER;                          return LDAP_OTHER;
                   }
         }          }
   
         fop = *op;          fop = *op;
         fop.o_sync_mode &= SLAP_CONTROL_MASK;   /* turn off sync_mode */          fop.o_sync_mode &= SLAP_CONTROL_MASK;   /* turn off sync_mode */
   
         fbuf.bv_val = buf;          fbuf.bv_val = buf;
         if ( mode == FIND_CSN ) {          cf.f_ava = &eq;
           cf.f_av_desc = slap_schema.si_ad_entryCSN;
           cf.f_next = NULL;
   
           switch( mode ) {
           case FIND_MAXCSN:
                   cf.f_choice = LDAP_FILTER_GE;
                   cf.f_av_value = si->si_ctxcsn;
                   fbuf.bv_len = sprintf( buf, "(entryCSN>=%s)",
                           cf.f_av_value.bv_val );
                   fop.ors_attrsonly = 0;
                   fop.ors_attrs = csn_anlist;
                   fop.ors_slimit = SLAP_NO_LIMIT;
                   cb.sc_private = &maxcsn;
                   cb.sc_response = findmax_cb;
                   maxcsn.bv_val = cbuf;
                   maxcsn.bv_len = 0;
                   break;
           case FIND_CSN:
                   cf.f_choice = LDAP_FILTER_LE;
                   cf.f_av_value = *srs->sr_state.ctxcsn;
                   fbuf.bv_len = sprintf( buf, "(entryCSN<=%s)",
                           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;
                 fop.ors_slimit = 1;                  fop.ors_slimit = 1;
                 cb.sc_private = NULL;                  cb.sc_private = NULL;
                 cb.sc_response = findcsn_cb;                  cb.sc_response = findcsn_cb;
                   break;
         } else if ( mode == FIND_PRESENT ) {          case FIND_PRESENT:
                   cf.f_choice = LDAP_FILTER_LE;
                   cf.f_av_value = *srs->sr_state.ctxcsn;
                   fbuf.bv_len = sprintf( buf, "(entryCSN<=%s)",
                           cf.f_av_value.bv_val );
                 fop.ors_attrsonly = 0;                  fop.ors_attrsonly = 0;
                 fop.ors_attrs = uuid_anlist;                  fop.ors_attrs = uuid_anlist;
                 fop.ors_slimit = SLAP_NO_LIMIT;                  fop.ors_slimit = SLAP_NO_LIMIT;
Line 589  syncprov_findcsn( Operation *op, int mod Line 640  syncprov_findcsn( Operation *op, int mod
                 cb.sc_response = findpres_cb;                  cb.sc_response = findpres_cb;
                 pcookie.num = 0;                  pcookie.num = 0;
                 pcookie.uuids = NULL;                  pcookie.uuids = NULL;
                   break;
         }          }
         cf.f_choice = LDAP_FILTER_LE;  
         cf.f_ava = &eq;  
         cf.f_av_desc = slap_schema.si_ad_entryCSN;  
         cf.f_av_value = *srs->sr_state.ctxcsn;  
         cf.f_next = NULL;  
         fbuf.bv_len = sprintf( buf, "(entryCSN<=%s)",  
                 srs->sr_state.ctxcsn->bv_val );  
   
         fop.o_callback = &cb;          fop.o_callback = &cb;
         fop.ors_limit = NULL;          fop.ors_limit = NULL;
         fop.ors_tlimit = SLAP_NO_LIMIT;          fop.ors_tlimit = SLAP_NO_LIMIT;
Line 605  syncprov_findcsn( Operation *op, int mod Line 649  syncprov_findcsn( Operation *op, int mod
         fop.ors_filterstr = fbuf;          fop.ors_filterstr = fbuf;
   
         fop.o_bd->bd_info = on->on_info->oi_orig;          fop.o_bd->bd_info = on->on_info->oi_orig;
         rc = fop.o_bd->be_search( &fop, &frs );          fop.o_bd->be_search( &fop, &frs );
         fop.o_bd->bd_info = (BackendInfo *)on;          fop.o_bd->bd_info = (BackendInfo *)on;
   
         if ( mode == FIND_CSN ) {          switch( mode ) {
                 if ( cb.sc_private ) return LDAP_SUCCESS;          case FIND_MAXCSN:
         } else if ( mode == FIND_PRESENT ) {                  if ( maxcsn.bv_len ) {
                 return LDAP_SUCCESS;                          strcpy( si->si_ctxcsnbuf, maxcsn.bv_val );
                           si->si_ctxcsn.bv_len = maxcsn.bv_len;
                   }
                   break;
           case FIND_CSN:
                   /* If matching CSN was not found, invalidate the context. */
                   if ( !cb.sc_private ) rc = LDAP_NO_SUCH_OBJECT;
                   break;
           case FIND_PRESENT:
                   break;
         }          }
   
         /* If matching CSN was not found, invalidate the context. */          return rc;
         return LDAP_NO_SUCH_OBJECT;  
 }  }
   
 /* Queue a persistent search response if still in Refresh stage */  /* Queue a persistent search response if still in Refresh stage */
Line 1633  syncprov_db_open( Line 1685  syncprov_db_open(
         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;
   
           Connection conn;
         char opbuf[OPERATION_BUFFER_SIZE];          char opbuf[OPERATION_BUFFER_SIZE];
         Operation *op = (Operation *)opbuf;          Operation *op = (Operation *)opbuf;
         Entry *e;          Entry *e;
         Attribute *a;          Attribute *a;
         int rc;          int rc;
   
         memset(opbuf, 0, sizeof(opbuf));          connection_fake_init( &conn, op, thrctx );
         op->o_hdr = (Opheader *)(op+1);  
         op->o_bd = be;          op->o_bd = be;
         op->o_dn = be->be_rootdn;          op->o_dn = be->be_rootdn;
         op->o_ndn = be->be_rootndn;          op->o_ndn = be->be_rootndn;
         op->o_threadctx = thrctx;  
         op->o_tmpmfuncs = &ch_mfuncs;  
   
         op->o_bd->bd_info = on->on_info->oi_orig;          op->o_bd->bd_info = on->on_info->oi_orig;
         rc = be_entry_get_rw( op, be->be_nsuffix, NULL,          rc = be_entry_get_rw( op, be->be_nsuffix, NULL,
Line 1662  syncprov_db_open( Line 1712  syncprov_db_open(
                         si->si_ctxcsnbuf[si->si_ctxcsn.bv_len] = '\0';                          si->si_ctxcsnbuf[si->si_ctxcsn.bv_len] = '\0';
                 }                  }
                 be_entry_release_r( op, e );                  be_entry_release_r( op, e );
                   op->o_bd->bd_info = (BackendInfo *)on;
                   op->o_req_dn = be->be_suffix[0];
                   op->o_req_ndn = be->be_nsuffix[0];
                   op->ors_scope = LDAP_SCOPE_SUBTREE;
                   syncprov_findcsn( op, FIND_MAXCSN );
         }          }
   
         if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {          if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {

Removed from v.1.36  
changed lines
  Added in v.1.37


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