Diff for /servers/slapd/overlays/syncprov.c between versions 1.28 and 1.33

version 1.28, 2004/11/27 13:54:49 version 1.33, 2004/11/29 04:54:55
Line 65  typedef struct syncops { Line 65  typedef struct syncops {
         ldap_pvt_thread_mutex_t s_mutex;          ldap_pvt_thread_mutex_t s_mutex;
 } syncops;  } syncops;
   
 static int      sync_cid;  
   
 /* A received sync control */  /* A received sync control */
 typedef struct sync_control {  typedef struct sync_control {
         struct sync_cookie sr_state;          struct sync_cookie sr_state;
         int sr_rhint;          int sr_rhint;
 } sync_control;  } sync_control;
   
   #if 0 /* moved back to slap.h */
   #define o_sync  o_ctrlflag[slap_cids.sc_LDAPsync]
   #endif
 /* o_sync_mode uses data bits of o_sync */  /* o_sync_mode uses data bits of o_sync */
 #define o_sync  o_ctrlflag[sync_cid]  #define o_sync_mode     o_ctrlflag[slap_cids.sc_LDAPsync]
 #define o_sync_mode     o_ctrlflag[sync_cid]  
   
 #define SLAP_SYNC_NONE                                  (LDAP_SYNC_NONE<<SLAP_CONTROL_SHIFT)  #define SLAP_SYNC_NONE                                  (LDAP_SYNC_NONE<<SLAP_CONTROL_SHIFT)
 #define SLAP_SYNC_REFRESH                               (LDAP_SYNC_REFRESH_ONLY<<SLAP_CONTROL_SHIFT)  #define SLAP_SYNC_REFRESH                               (LDAP_SYNC_REFRESH_ONLY<<SLAP_CONTROL_SHIFT)
Line 101  typedef struct syncprov_info_t { Line 101  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_mutex_t si_mods_mutex;          ldap_pvt_thread_rdwr_t  si_mods_rwlock;
         char            si_ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char            si_ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
 } syncprov_info_t;  } syncprov_info_t;
   
Line 131  syncprov_state_ctrl( Line 131  syncprov_state_ctrl(
         Operation       *op,          Operation       *op,
         SlapReply       *rs,          SlapReply       *rs,
         Entry           *e,          Entry           *e,
         int                     entry_sync_state,          int             entry_sync_state,
         LDAPControl     **ctrls,          LDAPControl     **ctrls,
         int                     num_ctrls,          int             num_ctrls,
         int                     send_cookie,          int             send_cookie,
         struct berval   *cookie)          struct berval   *cookie )
 {  {
         Attribute* a;          Attribute* a;
         int ret;          int ret;
Line 145  syncprov_state_ctrl( Line 145  syncprov_state_ctrl(
         BerElementBuffer berbuf;          BerElementBuffer berbuf;
         BerElement *ber = (BerElement *)&berbuf;          BerElement *ber = (BerElement *)&berbuf;
   
         struct berval entryuuid_bv      = BER_BVNULL;          struct berval   entryuuid_bv = BER_BVNULL;
   
         ber_init2( ber, 0, LBER_USE_DER );          ber_init2( ber, 0, LBER_USE_DER );
         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 );
           
         for ( a = e->e_attrs; a != NULL; a = a->a_next ) {          for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
                 AttributeDescription *desc = a->a_desc;                  AttributeDescription *desc = a->a_desc;
                 if ( desc == slap_schema.si_ad_entryUUID ) {                  if ( desc == slap_schema.si_ad_entryUUID ) {
Line 427  findbase_cb( Operation *op, SlapReply *r Line 427  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 452  syncprov_findbase( Operation *op, fbase_ Line 455  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 558  syncprov_findcsn( Operation *op, int mod Line 562  syncprov_findcsn( Operation *op, int mod
         int rc;          int rc;
         fpres_cookie pcookie;          fpres_cookie pcookie;
         int locked = 0;          int locked = 0;
         sync_control *srs = op->o_controls[sync_cid];          sync_control *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;
Line 595  syncprov_findcsn( Operation *op, int mod Line 599  syncprov_findcsn( Operation *op, int mod
                 srs->sr_state.ctxcsn->bv_val );                  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;
Line 700  syncprov_sendresp( Operation *op, opcook Line 705  syncprov_sendresp( Operation *op, opcook
                 e_uuid.e_nname = opc->sndn;                  e_uuid.e_nname = opc->sndn;
                 rs.sr_entry = &e_uuid;                  rs.sr_entry = &e_uuid;
                 if ( opc->sreference ) {                  if ( opc->sreference ) {
                         struct berval bv;                          struct berval bv = BER_BVNULL;
                         bv.bv_val = NULL;  
                         bv.bv_len = 0;  
                         rs.sr_ref = &bv;                          rs.sr_ref = &bv;
                         send_search_reference( &sop, &rs );                          send_search_reference( &sop, &rs );
                 } else {                  } else {
Line 905  syncprov_op_cleanup( Operation *op, Slap Line 908  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_mutex_lock( &si->si_mods_mutex );          ldap_pvt_thread_rdwr_rlock( &si->si_mods_rwlock );
         mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );          mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
         ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );          ldap_pvt_thread_rdwr_runlock( &si->si_mods_rwlock );
         if ( mt ) {          if ( mt ) {
                 modinst *mi = mt->mt_mods;                  modinst *mi = mt->mt_mods;
                                   
Line 918  syncprov_op_cleanup( Operation *op, Slap Line 921  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_mutex_lock( &si->si_mods_mutex );                          ldap_pvt_thread_rdwr_wlock( &si->si_mods_rwlock );
                         avl_delete( &si->si_mods, mt, sp_avl_cmp );                          avl_delete( &si->si_mods, mt, sp_avl_cmp );
                         ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );                          ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );
                         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 );
Line 977  syncprov_op_response( Operation *op, Sla Line 980  syncprov_op_response( Operation *op, Sla
                 cbuf[0] = '\0';                  cbuf[0] = '\0';
                 ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );                  ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
                 slap_get_commit_csn( op, &maxcsn );                  slap_get_commit_csn( op, &maxcsn );
                 if ( maxcsn.bv_val ) {                  if ( !BER_BVISNULL( &maxcsn ) ) {
                         strcpy( cbuf, maxcsn.bv_val );                          strcpy( cbuf, maxcsn.bv_val );
                         if ( ber_bvcmp( &maxcsn, &si->si_ctxcsn ) > 0 ) {                          if ( ber_bvcmp( &maxcsn, &si->si_ctxcsn ) > 0 ) {
                                 strcpy( si->si_ctxcsnbuf, cbuf );                                  strcpy( si->si_ctxcsnbuf, cbuf );
Line 1056  syncprov_op_compare( Operation *op, Slap Line 1059  syncprov_op_compare( Operation *op, Slap
                 e.e_name = op->o_bd->be_suffix[0];                  e.e_name = op->o_bd->be_suffix[0];
                 e.e_nname = op->o_bd->be_nsuffix[0];                  e.e_nname = op->o_bd->be_nsuffix[0];
   
                 bv[1].bv_val = NULL;                  BER_BVZERO( &bv[1] );
                 bv[0] = si->si_ctxcsn;                  bv[0] = si->si_ctxcsn;
   
                 a.a_desc = slap_schema.si_ad_contextCSN;                  a.a_desc = slap_schema.si_ad_contextCSN;
Line 1135  syncprov_op_mod( Operation *op, SlapRepl Line 1138  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_mutex_lock( &si->si_mods_mutex );                  ldap_pvt_thread_rdwr_wlock( &si->si_mods_rwlock );
                 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_mutex_unlock( &si->si_mods_mutex );                          ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );
                         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 1153  syncprov_op_mod( Operation *op, SlapRepl
                         }                          }
                 } else {                  } else {
                         /* Record that we're modifying this entry now */                          /* Record that we're modifying this entry now */
                         mt = malloc( sizeof(modtarget) );                          mt = ch_malloc( sizeof(modtarget) );
                         mt->mt_mods = mi;                          mt->mt_mods = mi;
                         mt->mt_tail = mi;                          mt->mt_tail = mi;
                         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_mutex_unlock( &si->si_mods_mutex );                          ldap_pvt_thread_rdwr_wunlock( &si->si_mods_rwlock );
                 }                  }
   
                 if ( op->o_tag != LDAP_REQ_ADD )                  if ( op->o_tag != LDAP_REQ_ADD )
Line 1202  syncprov_detach_op( Operation *op, synco Line 1205  syncprov_detach_op( Operation *op, synco
         char *ptr;          char *ptr;
   
         /* count the search attrs */          /* count the search attrs */
         for (i=0; op->ors_attrs && op->ors_attrs[i].an_name.bv_val; i++) {          for (i=0; op->ors_attrs && !BER_BVISNULL( &op->ors_attrs[i].an_name ); i++) {
                 alen += op->ors_attrs[i].an_name.bv_len + 1;                  alen += op->ors_attrs[i].an_name.bv_len + 1;
         }          }
         /* Make a new copy of the operation */          /* Make a new copy of the operation */
Line 1219  syncprov_detach_op( Operation *op, synco Line 1222  syncprov_detach_op( Operation *op, synco
         if ( i ) {          if ( i ) {
                 op2->ors_attrs = (AttributeName *)(op2->o_hdr + 1);                  op2->ors_attrs = (AttributeName *)(op2->o_hdr + 1);
                 ptr = (char *)(op2->ors_attrs+i+1);                  ptr = (char *)(op2->ors_attrs+i+1);
                 for (i=0; op->ors_attrs[i].an_name.bv_val; i++) {                  for (i=0; !BER_BVISNULL( &op->ors_attrs[i].an_name ); i++) {
                         op2->ors_attrs[i] = op->ors_attrs[i];                          op2->ors_attrs[i] = op->ors_attrs[i];
                         op2->ors_attrs[i].an_name.bv_val = ptr;                          op2->ors_attrs[i].an_name.bv_val = ptr;
                         ptr = lutil_strcopy( ptr, op->ors_attrs[i].an_name.bv_val ) + 1;                          ptr = lutil_strcopy( ptr, op->ors_attrs[i].an_name.bv_val ) + 1;
                 }                  }
                 op2->ors_attrs[i].an_name.bv_val = NULL;                  BER_BVZERO( &op2->ors_attrs[i].an_name );
                 op2->ors_attrs[i].an_name.bv_len = 0;  
         } else {          } else {
                 ptr = (char *)(op2->o_hdr + 1);                  ptr = (char *)(op2->o_hdr + 1);
         }          }
Line 1257  syncprov_search_response( Operation *op, Line 1259  syncprov_search_response( Operation *op,
         searchstate *ss = op->o_callback->sc_private;          searchstate *ss = op->o_callback->sc_private;
         slap_overinst *on = ss->ss_on;          slap_overinst *on = ss->ss_on;
         syncprov_info_t         *si = on->on_bi.bi_private;          syncprov_info_t         *si = on->on_bi.bi_private;
         sync_control *srs = op->o_controls[sync_cid];          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 ) {
                 int i;                  int i;
Line 1366  syncprov_op_search( Operation *op, SlapR Line 1368  syncprov_op_search( Operation *op, SlapR
                 return rs->sr_err;                  return rs->sr_err;
         }          }
   
         srs = op->o_controls[sync_cid];          srs = op->o_controls[slap_cids.sc_LDAPsync];
   
         /* If this is a persistent search, set it up right away */          /* If this is a persistent search, set it up right away */
         if ( op->o_sync_mode & SLAP_SYNC_PERSIST ) {          if ( op->o_sync_mode & SLAP_SYNC_PERSIST ) {
Line 1590  syncprov_db_config( Line 1592  syncprov_db_config(
 typedef struct thread_keys {  typedef struct thread_keys {
         void *key;          void *key;
         void *data;          void *data;
         ldap_pvt_thread_pool_keyfree_t *free;          ldap_pvt_thread_pool_keyfree_t *xfree;
 } thread_keys;  } thread_keys;
   
   #define MAXKEYS 32
 /* A fake thread context */  /* A fake thread context */
 static thread_keys thrctx[8];  static thread_keys thrctx[MAXKEYS];
   
 /* 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,
Line 1605  syncprov_db_open( Line 1608  syncprov_db_open(
     BackendDB *be      BackendDB *be
 )  )
 {  {
     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;
   
         char opbuf[OPERATION_BUFFER_SIZE];          char opbuf[OPERATION_BUFFER_SIZE];
         Operation *op = (Operation *)opbuf;          Operation *op = (Operation *)opbuf;
Line 1638  syncprov_db_open( Line 1641  syncprov_db_open(
                 }                  }
                 be_entry_release_r( op, e );                  be_entry_release_r( op, e );
         }          }
   
           if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {
                   slap_get_csn( op, si->si_ctxcsnbuf, sizeof(si->si_ctxcsnbuf),
                                   &si->si_ctxcsn, 0 );
           }
           
         op->o_bd->bd_info = (BackendInfo *)on;          op->o_bd->bd_info = (BackendInfo *)on;
     return 0;          return 0;
 }  }
   
 /* Write the current contextCSN into the underlying db.  /* Write the current contextCSN into the underlying db.
Line 1666  syncprov_db_close( Line 1675  syncprov_db_close(
                 syncprov_checkpoint( op, &rs, on );                  syncprov_checkpoint( op, &rs, on );
         }          }
         for ( i=0; thrctx[i].key; i++) {          for ( i=0; thrctx[i].key; i++) {
                 if ( thrctx[i].free )                  if ( thrctx[i].xfree )
                         thrctx[i].free( thrctx[i].key, thrctx[i].data );                          thrctx[i].xfree( thrctx[i].key, thrctx[i].data );
                   thrctx[i].key = NULL;
         }          }
   
     return 0;      return 0;
Line 1685  syncprov_db_init( Line 1695  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_mutex_init( &si->si_mods_mutex );          ldap_pvt_thread_rdwr_init( &si->si_mods_rwlock );
         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 1706  syncprov_db_destroy( Line 1716  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_mutex_destroy( &si->si_mods_mutex );                  ldap_pvt_thread_rdwr_destroy( &si->si_mods_rwlock );
                 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 1738  static int syncprov_parseCtrl ( Line 1748  static int syncprov_parseCtrl (
                 return LDAP_PROTOCOL_ERROR;                  return LDAP_PROTOCOL_ERROR;
         }          }
   
         if ( ctrl->ldctl_value.bv_len == 0 ) {          if ( BER_BVISEMPTY( &ctrl->ldctl_value ) ) {
                 rs->sr_text = "Sync control value is empty (or absent)";                  rs->sr_text = "Sync control value is empty (or absent)";
                 return LDAP_PROTOCOL_ERROR;                  return LDAP_PROTOCOL_ERROR;
         }          }
Line 1803  static int syncprov_parseCtrl ( Line 1813  static int syncprov_parseCtrl (
                 slap_parse_sync_cookie( &sr->sr_state );                  slap_parse_sync_cookie( &sr->sr_state );
         }          }
   
         op->o_controls[sync_cid] = sr;          op->o_controls[slap_cids.sc_LDAPsync] = sr;
   
         (void) ber_free( ber, 1 );          (void) ber_free( ber, 1 );
   
Line 1830  syncprov_init() Line 1840  syncprov_init()
   
         rc = register_supported_control( LDAP_CONTROL_SYNC,          rc = register_supported_control( LDAP_CONTROL_SYNC,
                 SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,                  SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,
                 syncprov_parseCtrl, &sync_cid );                  syncprov_parseCtrl, &slap_cids.sc_LDAPsync );
         if ( rc != LDAP_SUCCESS ) {          if ( rc != LDAP_SUCCESS ) {
                 fprintf( stderr, "Failed to register control %d\n", rc );                  fprintf( stderr, "Failed to register control %d\n", rc );
                 return rc;                  return rc;

Removed from v.1.28  
changed lines
  Added in v.1.33


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