Diff for /servers/slapd/overlays/syncprov.c between versions 1.32 and 1.41

version 1.32, 2004/11/28 23:48:26 version 1.41, 2004/12/07 01:58:33
Line 1 Line 1
   /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.40 2004/12/07 01:20:15 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 101  typedef struct syncprov_info_t { Line 102  typedef struct syncprov_info_t {
         Avlnode *si_mods;       /* entries being modified */          Avlnode *si_mods;       /* entries being modified */
         ldap_pvt_thread_mutex_t si_csn_mutex;          ldap_pvt_thread_mutex_t si_csn_mutex;
         ldap_pvt_thread_mutex_t si_ops_mutex;          ldap_pvt_thread_mutex_t si_ops_mutex;
         ldap_pvt_thread_rdwr_t  si_mods_rwlock;          ldap_pvt_thread_mutex_t si_mods_mutex;
         char            si_ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char            si_ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
 } syncprov_info_t;  } syncprov_info_t;
   
Line 151  syncprov_state_ctrl( Line 152  syncprov_state_ctrl(
         ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );          ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );
   
         ctrls[num_ctrls] = op->o_tmpalloc( sizeof ( LDAPControl ), op->o_tmpmemctx );          ctrls[num_ctrls] = op->o_tmpalloc( sizeof ( LDAPControl ), op->o_tmpmemctx );
           
         /* NOTE: this function is called also for referrals;  
          * in this case, e is null, right? */  
         if ( e ) {  
                 for ( a = e->e_attrs; a != NULL; a = a->a_next ) {  
                         AttributeDescription *desc = a->a_desc;  
                         if ( desc == slap_schema.si_ad_entryUUID ) {  
                                 entryuuid_bv = a->a_nvals[0];  
                                 break;  
                         }  
                 }  
   
                 if ( send_cookie && cookie ) {          for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
                         ber_printf( ber, "{eOON}",                  AttributeDescription *desc = a->a_desc;
                                 entry_sync_state, &entryuuid_bv, cookie );                  if ( desc == slap_schema.si_ad_entryUUID ) {
                 } else {                          entryuuid_bv = a->a_nvals[0];
                         ber_printf( ber, "{eON}",                          break;
                                 entry_sync_state, &entryuuid_bv );  
                 }                  }
         }          }
   
           if ( send_cookie && cookie ) {
                   ber_printf( ber, "{eOON}",
                           entry_sync_state, &entryuuid_bv, cookie );
           } else {
                   ber_printf( ber, "{eON}",
                           entry_sync_state, &entryuuid_bv );
           }
   
         ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_STATE;          ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_STATE;
         ctrls[num_ctrls]->ldctl_iscritical = (op->o_sync == SLAP_CONTROL_CRITICAL);          ctrls[num_ctrls]->ldctl_iscritical = (op->o_sync == SLAP_CONTROL_CRITICAL);
         ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 );          ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 );
Line 216  syncprov_done_ctrl( Line 213  syncprov_done_ctrl(
         if ( refreshDeletes == LDAP_SYNC_REFRESH_DELETES ) {          if ( refreshDeletes == LDAP_SYNC_REFRESH_DELETES ) {
                 ber_printf( ber, "b", refreshDeletes );                  ber_printf( ber, "b", refreshDeletes );
         }          }
         ber_printf( ber, "N}" );                  ber_printf( ber, "N}" );
   
         ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_DONE;          ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_DONE;
         ctrls[num_ctrls]->ldctl_iscritical = (op->o_sync == SLAP_CONTROL_CRITICAL);          ctrls[num_ctrls]->ldctl_iscritical = (op->o_sync == SLAP_CONTROL_CRITICAL);
Line 431  findbase_cb( Operation *op, SlapReply *r Line 428  findbase_cb( Operation *op, SlapReply *r
                         }                          }
                 }                  }
         }          }
           if ( rs->sr_err != LDAP_SUCCESS ) {
                   Debug( LDAP_DEBUG_ANY, "findbase failed! %d\n", rs->sr_err,0,0 );
           }
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
Line 456  syncprov_findbase( Operation *op, fbase_ Line 456  syncprov_findbase( Operation *op, fbase_
         fop.o_tag = LDAP_REQ_SEARCH;          fop.o_tag = LDAP_REQ_SEARCH;
         fop.ors_scope = LDAP_SCOPE_BASE;          fop.ors_scope = LDAP_SCOPE_BASE;
         fop.ors_deref = fc->fss->s_op->ors_deref;          fop.ors_deref = fc->fss->s_op->ors_deref;
           fop.ors_limit = NULL;
         fop.ors_slimit = 1;          fop.ors_slimit = 1;
         fop.ors_tlimit = SLAP_NO_LIMIT;          fop.ors_tlimit = SLAP_NO_LIMIT;
         fop.ors_attrs = slap_anlist_no_attrs;          fop.ors_attrs = slap_anlist_no_attrs;
Line 478  syncprov_findbase( Operation *op, fbase_ Line 479  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 578  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 ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {          if ( mode != FIND_MAXCSN ) {
                 return LDAP_OTHER;                  srs = op->o_controls[slap_cids.sc_LDAPsync];
   
                   if ( srs->sr_state.ctxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ) {
                           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 641  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_tlimit = SLAP_NO_LIMIT;          fop.ors_tlimit = SLAP_NO_LIMIT;
         fop.ors_filter = &cf;          fop.ors_filter = &cf;
         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 794  syncprov_matchops( Operation *op, opcook Line 848  syncprov_matchops( Operation *op, opcook
         Attribute *a;          Attribute *a;
         int rc;          int rc;
         struct berval newdn;          struct berval newdn;
           int freefdn = 0;
   
         fc.fdn = &op->o_req_ndn;          fc.fdn = &op->o_req_ndn;
         /* compute new DN */          /* compute new DN */
Line 803  syncprov_matchops( Operation *op, opcook Line 858  syncprov_matchops( Operation *op, opcook
                 else dnParent( fc.fdn, &pdn );                  else dnParent( fc.fdn, &pdn );
                 build_new_dn( &newdn, &pdn, &op->orr_nnewrdn, op->o_tmpmemctx );                  build_new_dn( &newdn, &pdn, &op->orr_nnewrdn, op->o_tmpmemctx );
                 fc.fdn = &newdn;                  fc.fdn = &newdn;
                   freefdn = 1;
         }          }
         if ( op->o_tag != LDAP_REQ_ADD ) {          if ( op->o_tag != LDAP_REQ_ADD ) {
                 op->o_bd->bd_info = (BackendInfo *)on->on_info;                  op->o_bd->bd_info = (BackendInfo *)on->on_info;
Line 813  syncprov_matchops( Operation *op, opcook Line 869  syncprov_matchops( Operation *op, opcook
                 e = op->ora_e;                  e = op->ora_e;
         }          }
   
           /* Never replicate these */
           if ( is_entry_syncConsumerSubentry( e )) {
                   goto done;
           }
         if ( saveit ) {          if ( saveit ) {
                 ber_dupbv_x( &opc->sdn, &e->e_name, op->o_tmpmemctx );                  ber_dupbv_x( &opc->sdn, &e->e_name, op->o_tmpmemctx );
                 ber_dupbv_x( &opc->sndn, &e->e_nname, op->o_tmpmemctx );                  ber_dupbv_x( &opc->sndn, &e->e_nname, op->o_tmpmemctx );
Line 882  syncprov_matchops( Operation *op, opcook Line 942  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 ) {          if ( op->o_tag != LDAP_REQ_ADD ) {
                 op->o_bd->bd_info = (BackendInfo *)on->on_info;                  op->o_bd->bd_info = (BackendInfo *)on->on_info;
                 be_entry_release_r( op, e );                  be_entry_release_r( op, e );
                 op->o_bd->bd_info = (BackendInfo *)on;                  op->o_bd->bd_info = (BackendInfo *)on;
         }          }
           if ( freefdn ) {
                   op->o_tmpfree( fc.fdn->bv_val, op->o_tmpmemctx );
           }
 }  }
   
 static int  static int
Line 907  syncprov_op_cleanup( Operation *op, Slap Line 971  syncprov_op_cleanup( Operation *op, Slap
   
         /* Remove op from lock table */          /* Remove op from lock table */
         mtdummy.mt_op = op;          mtdummy.mt_op = op;
         ldap_pvt_thread_rdwr_rlock( &si->si_mods_rwlock );          ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
         mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );          mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
         ldap_pvt_thread_rdwr_runlock( &si->si_mods_rwlock );          ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
         if ( mt ) {          if ( mt ) {
                 modinst *mi = mt->mt_mods;                  modinst *mi = mt->mt_mods;
                   
                 /* If there are more, promote the next one */                  /* If there are more, promote the next one */
                 ldap_pvt_thread_mutex_lock( &mt->mt_mutex );                  ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
                 if ( mi->mi_next ) {                  if ( mi->mi_next ) {
Line 920  syncprov_op_cleanup( Operation *op, Slap Line 984  syncprov_op_cleanup( Operation *op, Slap
                         mt->mt_op = mt->mt_mods->mi_op;                          mt->mt_op = mt->mt_mods->mi_op;
                         ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );                          ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                 } else {                  } else {
                         ldap_pvt_thread_rdwr_wlock( &si->si_mods_rwlock );                          ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
                         avl_delete( &si->si_mods, mt, sp_avl_cmp );                          avl_delete( &si->si_mods, mt, sp_avl_cmp );
                         ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );                          ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
                         ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );                          ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                         ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );                          ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );
                         ch_free( mt );                          ch_free( mt );
                 }                  }
         }          }
           if ( !BER_BVISNULL( &opc->suuid ))
                   op->o_tmpfree( opc->suuid.bv_val, op->o_tmpmemctx );
           if ( !BER_BVISNULL( &opc->sndn ))
                   op->o_tmpfree( opc->sndn.bv_val, op->o_tmpmemctx );
           if ( !BER_BVISNULL( &opc->sdn ))
                   op->o_tmpfree( opc->sdn.bv_val, op->o_tmpmemctx );
         op->o_callback = cb->sc_next;          op->o_callback = cb->sc_next;
         op->o_tmpfree(cb, op->o_tmpmemctx);          op->o_tmpfree(cb, op->o_tmpmemctx);
 }  }
Line 994  syncprov_op_response( Operation *op, Sla Line 1064  syncprov_op_response( Operation *op, Sla
                                 do_check = 1;                                  do_check = 1;
                                 si->si_numops = 0;                                  si->si_numops = 0;
                         }                          }
                         if ( si->si_chktime &&                           if ( si->si_chktime &&
                                 (op->o_time - si->si_chklast >= si->si_chktime )) {                                  (op->o_time - si->si_chklast >= si->si_chktime )) {
                                 do_check = 1;                                  do_check = 1;
                                 si->si_chklast = op->o_time;                                  si->si_chklast = op->o_time;
Line 1106  return_results:; Line 1176  return_results:;
   
         return rc;          return rc;
 }  }
           
 static int  static int
 syncprov_op_mod( Operation *op, SlapReply *rs )  syncprov_op_mod( Operation *op, SlapReply *rs )
 {  {
Line 1137  syncprov_op_mod( Operation *op, SlapRepl Line 1207  syncprov_op_mod( Operation *op, SlapRepl
   
                 /* See if we're already modifying this entry... */                  /* See if we're already modifying this entry... */
                 mtdummy.mt_op = op;                  mtdummy.mt_op = op;
                 ldap_pvt_thread_rdwr_wlock( &si->si_mods_rwlock );                  ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
                 mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );                  mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
                 if ( mt ) {                  if ( mt ) {
                         ldap_pvt_thread_mutex_lock( &mt->mt_mutex );                          ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
                         ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );                          ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
                         mt->mt_tail->mi_next = mi;                          mt->mt_tail->mi_next = mi;
                         mt->mt_tail = mi;                          mt->mt_tail = mi;
                         /* wait for this op to get to head of list */                          /* wait for this op to get to head of list */
Line 1150  syncprov_op_mod( Operation *op, SlapRepl Line 1220  syncprov_op_mod( Operation *op, SlapRepl
                                 ldap_pvt_thread_yield();                                  ldap_pvt_thread_yield();
                                 ldap_pvt_thread_mutex_lock( &mt->mt_mutex );                                  ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
                         }                          }
                           ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                 } else {                  } else {
                         /* Record that we're modifying this entry now */                          /* Record that we're modifying this entry now */
                         mt = ch_malloc( sizeof(modtarget) );                          mt = ch_malloc( sizeof(modtarget) );
Line 1158  syncprov_op_mod( Operation *op, SlapRepl Line 1229  syncprov_op_mod( Operation *op, SlapRepl
                         mt->mt_op = mi->mi_op;                          mt->mt_op = mi->mi_op;
                         ldap_pvt_thread_mutex_init( &mt->mt_mutex );                          ldap_pvt_thread_mutex_init( &mt->mt_mutex );
                         avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error );                          avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error );
                         ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );                          ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
                 }                  }
   
                 if ( op->o_tag != LDAP_REQ_ADD )                  if ( op->o_tag != LDAP_REQ_ADD )
Line 1185  typedef struct searchstate { Line 1256  typedef struct searchstate {
 static int  static int
 syncprov_search_cleanup( Operation *op, SlapReply *rs )  syncprov_search_cleanup( Operation *op, SlapReply *rs )
 {  {
 #if 0  
         if ( rs->sr_ctrls ) {          if ( rs->sr_ctrls ) {
                 free( rs->sr_ctrls[0] );                  op->o_tmpfree( rs->sr_ctrls[0], op->o_tmpmemctx );
                 op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx );                  op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx );
                 rs->sr_ctrls = NULL;                  rs->sr_ctrls = NULL;
         }          }
 #endif  
         return 0;          return 0;
 }  }
   
Line 1262  syncprov_search_response( Operation *op, Line 1331  syncprov_search_response( Operation *op,
   
         if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {          if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {
                 int i;                  int i;
                 /* FIXME: when rs->sr_type == REP_SEARCHREF,                  /* If we got a referral without a referral object, there's
                  * rs->sr_entry is NULL! */                   * something missing that we cannot replicate. Just ignore it.
                 if ( srs->sr_state.ctxcsn && rs->sr_entry ) {                   * The consumer will abort because we didn't send the expected
                    * control.
                    */
                   if ( !rs->sr_entry ) {
                           assert( rs->sr_entry );
                           Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );
                           return SLAP_CB_CONTINUE;
                   }
                   if ( srs->sr_state.ctxcsn ) {
                         Attribute *a = attr_find( rs->sr_entry->e_attrs,                          Attribute *a = attr_find( rs->sr_entry->e_attrs,
                                 slap_schema.si_ad_entryCSN );                                  slap_schema.si_ad_entryCSN );
                         /* Don't send the ctx entry twice */                          /* Don't send the ctx entry twice */
Line 1314  syncprov_search_response( Operation *op, Line 1391  syncprov_search_response( Operation *op,
                                         opc.sctxcsn = sr->s_csn;                                          opc.sctxcsn = sr->s_csn;
                                         opc.sreference = sr->s_isreference;                                          opc.sreference = sr->s_isreference;
                                         e = NULL;                                          e = NULL;
                                           
                                         if ( sr->s_mode != LDAP_SYNC_DELETE ) {                                          if ( sr->s_mode != LDAP_SYNC_DELETE ) {
                                                 op->o_bd->bd_info = (BackendInfo *)on->on_info;                                                  op->o_bd->bd_info = (BackendInfo *)on->on_info;
                                                 rc = be_entry_get_rw( op, &opc.sndn, NULL, NULL, 0, &e );                                                  rc = be_entry_get_rw( op, &opc.sndn, NULL, NULL, 0, &e );
Line 1443  syncprov_op_search( Operation *op, SlapR Line 1520  syncprov_op_search( Operation *op, SlapR
                                         return rs->sr_err;                                          return rs->sr_err;
                                 }                                  }
                                 goto shortcut;                                  goto shortcut;
                         } else                           } else
                         /* If context has changed, check for Present UUIDs */                          /* If context has changed, check for Present UUIDs */
                         if ( syncprov_findcsn( op, FIND_PRESENT ) != LDAP_SUCCESS ) {                          if ( syncprov_findcsn( op, FIND_PRESENT ) != LDAP_SUCCESS ) {
                                 send_ldap_result( op, rs );                                  send_ldap_result( op, rs );
Line 1526  syncprov_operational( Line 1603  syncprov_operational(
                         ad_inlist( slap_schema.si_ad_contextCSN, rs->sr_attrs )) {                          ad_inlist( slap_schema.si_ad_contextCSN, rs->sr_attrs )) {
                         Attribute *a, **ap = NULL;                          Attribute *a, **ap = NULL;
   
                           
                         for ( a=rs->sr_entry->e_attrs; a; a=a->a_next ) {                          for ( a=rs->sr_entry->e_attrs; a; a=a->a_next ) {
                                 if ( a->a_desc == slap_schema.si_ad_contextCSN )                                  if ( a->a_desc == slap_schema.si_ad_contextCSN )
                                         break;                                          break;
Line 1554  syncprov_operational( Line 1630  syncprov_operational(
                         ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );                          ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );
                 }                  }
         }          }
         return LDAP_SUCCESS;          return SLAP_CB_CONTINUE;
 }  }
   
 static int  static int
Line 1569  syncprov_db_config( Line 1645  syncprov_db_config(
         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;
   
 #if 0  
         if ( strcasecmp( argv[ 0 ], "syncprov-checkpoint" ) == 0 ) {          if ( strcasecmp( argv[ 0 ], "syncprov-checkpoint" ) == 0 ) {
                 if ( argc != 3 ) {                  if ( argc != 3 ) {
                         fprintf( stderr, "%s: line %d: wrong number of arguments in "                          fprintf( stderr, "%s: line %d: wrong number of arguments in "
Line 1578  syncprov_db_config( Line 1653  syncprov_db_config(
                 }                  }
                 si->si_chkops = atoi( argv[1] );                  si->si_chkops = atoi( argv[1] );
                 si->si_chktime = atoi( argv[2] ) * 60;                  si->si_chktime = atoi( argv[2] ) * 60;
                   return 0;
   
         } else {  
                 return SLAP_CONF_UNKNOWN;  
         }          }
 #endif  
   
         return SLAP_CONF_UNKNOWN;          return SLAP_CONF_UNKNOWN;
 }  }
Line 1612  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];
           char ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
         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;          ctxcsnbuf[0] = '\0';
   
         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,
                 slap_schema.si_ad_contextCSN, 0, &e );                  slap_schema.si_ad_contextCSN, 0, &e );
   
         BER_BVZERO( &si->si_ctxcsn );  
   
         /* FIXME: when rs->sr_type == REP_SEARCHREF,  
          * rs->sr_entry == NULL! */  
         if ( e ) {          if ( e ) {
                 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 ) {
Line 1643  syncprov_db_open( Line 1713  syncprov_db_open(
                         strncpy( si->si_ctxcsnbuf, a->a_nvals[0].bv_val,                          strncpy( si->si_ctxcsnbuf, a->a_nvals[0].bv_val,
                                 si->si_ctxcsn.bv_len );                                  si->si_ctxcsn.bv_len );
                         si->si_ctxcsnbuf[si->si_ctxcsn.bv_len] = '\0';                          si->si_ctxcsnbuf[si->si_ctxcsn.bv_len] = '\0';
                           strcpy( ctxcsnbuf, si->si_ctxcsnbuf );
                 }                  }
                 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_BVISNULL( &si->si_ctxcsn ) ) {          if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {
                 slap_get_csn( op, si->si_ctxcsnbuf, sizeof(si->si_ctxcsnbuf),                  slap_get_csn( op, si->si_ctxcsnbuf, sizeof(si->si_ctxcsnbuf),
                                 &si->si_ctxcsn, 0 );                                  &si->si_ctxcsn, 0 );
         }          }
           
           /* If our ctxcsn is different from what was read from the root
            * entry, write the new value out.
            */
           if ( strcmp( si->si_ctxcsnbuf, ctxcsnbuf )) {
                   SlapReply rs = {REP_RESULT};
                   syncprov_checkpoint( op, &rs, on );
           }
   
         op->o_bd->bd_info = (BackendInfo *)on;          op->o_bd->bd_info = (BackendInfo *)on;
         return 0;          return 0;
 }  }
Line 1700  syncprov_db_init( Line 1784  syncprov_db_init(
         on->on_bi.bi_private = si;          on->on_bi.bi_private = si;
         ldap_pvt_thread_mutex_init( &si->si_csn_mutex );          ldap_pvt_thread_mutex_init( &si->si_csn_mutex );
         ldap_pvt_thread_mutex_init( &si->si_ops_mutex );          ldap_pvt_thread_mutex_init( &si->si_ops_mutex );
         ldap_pvt_thread_rdwr_init( &si->si_mods_rwlock );          ldap_pvt_thread_mutex_init( &si->si_mods_mutex );
         si->si_ctxcsn.bv_val = si->si_ctxcsnbuf;          si->si_ctxcsn.bv_val = si->si_ctxcsnbuf;
   
         csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;          csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;
Line 1721  syncprov_db_destroy( Line 1805  syncprov_db_destroy(
         syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;          syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;
   
         if ( si ) {          if ( si ) {
                 ldap_pvt_thread_rdwr_destroy( &si->si_mods_rwlock );                  ldap_pvt_thread_mutex_destroy( &si->si_mods_mutex );
                 ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );
                 ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );
                 ch_free( si );                  ch_free( si );
Line 1870  syncprov_init() Line 1954  syncprov_init()
         syncprov.on_bi.bi_extended = syncprov_op_extended;          syncprov.on_bi.bi_extended = syncprov_op_extended;
         syncprov.on_bi.bi_operational = syncprov_operational;          syncprov.on_bi.bi_operational = syncprov_operational;
   
 #if 0  
         syncprov.on_response = syncprov_response;  
 #endif  
   
         return overlay_register( &syncprov );          return overlay_register( &syncprov );
 }  }
   

Removed from v.1.32  
changed lines
  Added in v.1.41


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