Diff for /servers/slapd/overlays/syncprov.c between versions 1.96 and 1.102

version 1.96, 2005/08/14 22:04:13 version 1.102, 2005/08/26 19:42:48
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.95 2005/08/14 06:35:31 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.101 2005/08/25 06:57:08 ando 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 142  typedef struct fbase_cookie { Line 142  typedef struct fbase_cookie {
         int fscope;     /* if TRUE then fdn is within the psearch scope */          int fscope;     /* if TRUE then fdn is within the psearch scope */
 } fbase_cookie;  } fbase_cookie;
   
 static AttributeName csn_anlist[2];  static AttributeName csn_anlist[3];
 static AttributeName uuid_anlist[2];  static AttributeName uuid_anlist[2];
   
 /* Build a LDAPsync intermediate state control */  /* Build a LDAPsync intermediate state control */
Line 178  syncprov_state_ctrl( Line 178  syncprov_state_ctrl(
                 }                  }
         }          }
   
           /* FIXME: what if entryuuid is NULL or empty ? */
   
         if ( send_cookie && cookie ) {          if ( send_cookie && cookie ) {
                 ber_printf( ber, "{eOON}",                  ber_printf( ber, "{eOON}",
                         entry_sync_state, &entryuuid_bv, cookie );                          entry_sync_state, &entryuuid_bv, cookie );
Line 597  again: Line 599  again:
                 maxcsn.bv_len = si->si_ctxcsn.bv_len;                  maxcsn.bv_len = si->si_ctxcsn.bv_len;
                 break;                  break;
         case FIND_CSN:          case FIND_CSN:
                   cf.f_av_value = srs->sr_state.ctxcsn;
                 /* Look for exact match the first time */                  /* Look for exact match the first time */
                 if ( findcsn_retry ) {                  if ( findcsn_retry ) {
                         cf.f_choice = LDAP_FILTER_EQUALITY;                          cf.f_choice = LDAP_FILTER_EQUALITY;
Line 608  again: Line 611  again:
                         fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",                          fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",
                                 cf.f_av_value.bv_val );                                  cf.f_av_value.bv_val );
                 }                  }
                 cf.f_av_value = srs->sr_state.ctxcsn;  
                 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;
Line 1609  typedef struct searchstate { Line 1611  typedef struct searchstate {
         slap_overinst *ss_on;          slap_overinst *ss_on;
         syncops *ss_so;          syncops *ss_so;
         int ss_present;          int ss_present;
           struct berval ss_ctxcsn;
           char ss_csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
 } searchstate;  } searchstate;
   
 static int  static int
Line 1707  syncprov_search_response( Operation *op, Line 1711  syncprov_search_response( Operation *op,
         sync_control *srs = op->o_controls[slap_cids.sc_LDAPsync];          sync_control *srs = op->o_controls[slap_cids.sc_LDAPsync];
   
         if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {          if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {
                   Attribute *a;
                 /* If we got a referral without a referral object, there's                  /* If we got a referral without a referral object, there's
                  * something missing that we cannot replicate. Just ignore it.                   * something missing that we cannot replicate. Just ignore it.
                  * The consumer will abort because we didn't send the expected                   * The consumer will abort because we didn't send the expected
Line 1717  syncprov_search_response( Operation *op, Line 1722  syncprov_search_response( Operation *op,
                         Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );                          Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
                 if ( !BER_BVISNULL( &srs->sr_state.ctxcsn )) {                  a = attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_entryCSN );
                         Attribute *a = attr_find( rs->sr_entry->e_attrs,                  if ( a ) {
                                 slap_schema.si_ad_entryCSN );                          /* Make sure entry is less than the snaphot'd contextCSN */
                                                   if ( ber_bvcmp( &a->a_nvals[0], &ss->ss_ctxcsn ) > 0 )
                                   return LDAP_SUCCESS;
   
                         /* Don't send the ctx entry twice */                          /* Don't send the ctx entry twice */
                         if ( a && bvmatch( &a->a_nvals[0], &srs->sr_state.ctxcsn ) )                          if ( !BER_BVISNULL( &srs->sr_state.ctxcsn ) &&
                                   bvmatch( &a->a_nvals[0], &srs->sr_state.ctxcsn ) )
                                 return LDAP_SUCCESS;                                  return LDAP_SUCCESS;
                 }                  }
                 rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,                  rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,
Line 1733  syncprov_search_response( Operation *op, Line 1741  syncprov_search_response( Operation *op,
         } else if ( rs->sr_type == REP_RESULT && rs->sr_err == LDAP_SUCCESS ) {          } else if ( rs->sr_type == REP_RESULT && rs->sr_err == LDAP_SUCCESS ) {
                 struct berval cookie;                  struct berval cookie;
   
                 slap_compose_sync_cookie( op, &cookie,                  slap_compose_sync_cookie( op, &cookie, &ss->ss_ctxcsn,
                         &op->ors_filter->f_and->f_ava->aa_value,  
                         srs->sr_state.rid );                          srs->sr_state.rid );
   
                 /* Is this a regular refresh? */                  /* Is this a regular refresh? */
Line 1780  syncprov_op_search( Operation *op, SlapR Line 1787  syncprov_op_search( Operation *op, SlapR
         syncprov_info_t         *si = (syncprov_info_t *)on->on_bi.bi_private;          syncprov_info_t         *si = (syncprov_info_t *)on->on_bi.bi_private;
         slap_callback   *cb;          slap_callback   *cb;
         int gotstate = 0, nochange = 0, do_present = 1;          int gotstate = 0, nochange = 0, do_present = 1;
         Filter *fand, *fava;  
         syncops *sop = NULL;          syncops *sop = NULL;
         searchstate *ss;          searchstate *ss;
         sync_control *srs;          sync_control *srs;
Line 1904  shortcut: Line 1910  shortcut:
                 sop->s_filterstr= op->ors_filterstr;                  sop->s_filterstr= op->ors_filterstr;
         }          }
   
         fand = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );          /* If something changed, find the changes */
         fand->f_choice = LDAP_FILTER_AND;          if ( gotstate && !nochange ) {
         fand->f_next = NULL;                  Filter *fand, *fava;
         fava = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );  
         fava->f_choice = LDAP_FILTER_LE;                  fand = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );
         fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );                  fand->f_choice = LDAP_FILTER_AND;
         fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;                  fand->f_next = NULL;
 #ifdef LDAP_COMP_MATCH                  fava = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );
         fava->f_ava->aa_cf = NULL;                  fand->f_and = fava;
 #endif  
         ber_dupbv_x( &fava->f_ava->aa_value, &ctxcsn, op->o_tmpmemctx );  
         fand->f_and = fava;  
         if ( gotstate ) {  
                 fava->f_next = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );  
                 fava = fava->f_next;  
                 fava->f_choice = LDAP_FILTER_GE;                  fava->f_choice = LDAP_FILTER_GE;
                 fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );                  fava->f_ava = op->o_tmpalloc( sizeof(AttributeAssertion), op->o_tmpmemctx );
                 fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;                  fava->f_ava->aa_desc = slap_schema.si_ad_entryCSN;
Line 1926  shortcut: Line 1926  shortcut:
                 fava->f_ava->aa_cf = NULL;                  fava->f_ava->aa_cf = NULL;
 #endif  #endif
                 ber_dupbv_x( &fava->f_ava->aa_value, &srs->sr_state.ctxcsn, op->o_tmpmemctx );                  ber_dupbv_x( &fava->f_ava->aa_value, &srs->sr_state.ctxcsn, op->o_tmpmemctx );
                   fava->f_next = op->ors_filter;
                   op->ors_filter = fand;
                   filter2bv_x( op, op->ors_filter, &op->ors_filterstr );
         }          }
         fava->f_next = op->ors_filter;  
         op->ors_filter = fand;  
         filter2bv_x( op, op->ors_filter, &op->ors_filterstr );  
   
         /* Let our callback add needed info to returned entries */          /* Let our callback add needed info to returned entries */
         cb = op->o_tmpcalloc(1, sizeof(slap_callback)+sizeof(searchstate), op->o_tmpmemctx);          cb = op->o_tmpcalloc(1, sizeof(slap_callback)+sizeof(searchstate), op->o_tmpmemctx);
Line 1937  shortcut: Line 1937  shortcut:
         ss->ss_on = on;          ss->ss_on = on;
         ss->ss_so = sop;          ss->ss_so = sop;
         ss->ss_present = do_present;          ss->ss_present = do_present;
           ss->ss_ctxcsn.bv_len = ctxcsn.bv_len;
           ss->ss_ctxcsn.bv_val = ss->ss_csnbuf;
           strcpy( ss->ss_ctxcsn.bv_val, ctxcsn.bv_val );
         cb->sc_response = syncprov_search_response;          cb->sc_response = syncprov_search_response;
         cb->sc_cleanup = syncprov_search_cleanup;          cb->sc_cleanup = syncprov_search_cleanup;
         cb->sc_private = ss;          cb->sc_private = ss;
Line 2110  sp_cf_gen(ConfigArgs *c) Line 2113  sp_cf_gen(ConfigArgs *c)
         return rc;          return rc;
 }  }
   
 /* Cheating - we have no thread pool context for these functions,  
  * so make one.  
  */  
 typedef struct thread_keys {  
         void *key;  
         void *data;  
         ldap_pvt_thread_pool_keyfree_t *xfree;  
 } thread_keys;  
   
 #define MAXKEYS 32  
 /* A fake thread context */  
 static thread_keys thrctx[MAXKEYS];  
   
 /* ITS#3456 we cannot run this search on the main thread, must use a  /* 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.   * child thread in order to insure we have a big enough stack.
  */   */
Line 2154  syncprov_db_open( Line 2144  syncprov_db_open(
         Entry *e;          Entry *e;
         Attribute *a;          Attribute *a;
         int rc;          int rc;
           void *thrctx = NULL;
   
         if ( slapMode & SLAP_TOOL_MODE ) {          if ( slapMode & SLAP_TOOL_MODE ) {
                 return 0;                  return 0;
Line 2164  syncprov_db_open( Line 2155  syncprov_db_open(
                 return rc;                  return rc;
         }          }
   
           thrctx = ldap_pvt_thread_pool_context();
         connection_fake_init( &conn, op, thrctx );          connection_fake_init( &conn, op, thrctx );
         op->o_bd = be;          op->o_bd = be;
         op->o_dn = be->be_rootdn;          op->o_dn = be->be_rootdn;
Line 2217  syncprov_db_open( Line 2209  syncprov_db_open(
   
 out:  out:
         op->o_bd->bd_info = (BackendInfo *)on;          op->o_bd->bd_info = (BackendInfo *)on;
           ldap_pvt_thread_pool_context_reset( thrctx );
         return 0;          return 0;
 }  }
   
Line 2229  syncprov_db_close( Line 2222  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;
         int i;  
   
         if ( slapMode & SLAP_TOOL_MODE ) {          if ( slapMode & SLAP_TOOL_MODE ) {
                 return 0;                  return 0;
Line 2239  syncprov_db_close( Line 2231  syncprov_db_close(
                 char opbuf[OPERATION_BUFFER_SIZE];                  char opbuf[OPERATION_BUFFER_SIZE];
                 Operation *op = (Operation *)opbuf;                  Operation *op = (Operation *)opbuf;
                 SlapReply rs = {REP_RESULT};                  SlapReply rs = {REP_RESULT};
                   void *thrctx;
   
                   thrctx = ldap_pvt_thread_pool_context();
                 connection_fake_init( &conn, op, thrctx );                  connection_fake_init( &conn, op, thrctx );
                 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;
                 syncprov_checkpoint( op, &rs, on );                  syncprov_checkpoint( op, &rs, on );
         }                  ldap_pvt_thread_pool_context_reset( thrctx );
         for ( i=0; thrctx[i].key; i++) {  
                 if ( thrctx[i].xfree )  
                         thrctx[i].xfree( thrctx[i].key, thrctx[i].data );  
                 thrctx[i].key = NULL;  
         }          }
   
     return 0;      return 0;
Line 2272  syncprov_db_init( Line 2262  syncprov_db_init(
   
         csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;          csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;
         csn_anlist[0].an_name = slap_schema.si_ad_entryCSN->ad_cname;          csn_anlist[0].an_name = slap_schema.si_ad_entryCSN->ad_cname;
           csn_anlist[1].an_desc = slap_schema.si_ad_entryUUID;
           csn_anlist[1].an_name = slap_schema.si_ad_entryUUID->ad_cname;
   
         uuid_anlist[0].an_desc = slap_schema.si_ad_entryUUID;          uuid_anlist[0].an_desc = slap_schema.si_ad_entryUUID;
         uuid_anlist[0].an_name = slap_schema.si_ad_entryUUID->ad_cname;          uuid_anlist[0].an_name = slap_schema.si_ad_entryUUID->ad_cname;

Removed from v.1.96  
changed lines
  Added in v.1.102


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