Diff for /servers/slapd/overlays/syncprov.c between versions 1.22 and 1.25

version 1.22, 2004/11/27 06:29:10 version 1.25, 2004/11/27 07:55:04
Line 780  syncprov_sendresp( Operation *op, opcook Line 780  syncprov_sendresp( Operation *op, opcook
         return rs.sr_err;          return rs.sr_err;
 }  }
   
   static void
   syncprov_free_syncop( syncops *so )
   {
           syncres *sr, *srnext;
   
           ldap_pvt_thread_mutex_lock( &so->s_mutex );
           so->s_inuse--;
           if ( so->s_inuse > 0 ) {
                   ldap_pvt_thread_mutex_unlock( &so->s_mutex );
                   return;
           }
           ldap_pvt_thread_mutex_unlock( &so->s_mutex );
           filter_free( so->s_op->ors_filter );
           ch_free( so->s_op );
           ch_free( so->s_base.bv_val );
           for ( sr=so->s_res; sr; sr=srnext ) {
                   srnext = sr->s_next;
                   ch_free( sr );
           }
           ldap_pvt_thread_mutex_destroy( &so->s_mutex );
           ch_free( so );
   }
   
   static int
   syncprov_drop_psearch( syncops *so )
   {
           ldap_pvt_thread_mutex_lock( &so->s_op->o_conn->c_mutex );
           so->s_op->o_conn->c_n_ops_executing--;
           so->s_op->o_conn->c_n_ops_completed++;
           ldap_pvt_thread_mutex_unlock( &so->s_op->o_conn->c_mutex );
           syncprov_free_syncop( so );
   }
   
   static int
   syncprov_op_abandon( Operation *op, SlapReply *rs )
   {
           slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
           syncprov_info_t         *si = on->on_bi.bi_private;
           syncops *so, *soprev;
   
           ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
           for ( so=si->si_ops, soprev = (syncops *)&si->si_ops; so;
                   soprev=so, so=so->s_next ) {
                   if ( so->s_op->o_connid == op->o_connid &&
                           so->s_op->o_msgid == op->orn_msgid ) {
                                   so->s_op->o_abandon = 1;
                                   soprev->s_next = so->s_next;
                                   break;
                   }
           }
           ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
           if ( so ) {
                   /* Is this really a Cancel exop? */
                   if ( op->o_tag != LDAP_REQ_ABANDON ) {
                           rs->sr_err = LDAP_CANCELLED;
                           send_ldap_result( so->s_op, rs );
                   }
                   syncprov_drop_psearch( so );
           }
           return SLAP_CB_CONTINUE;
   }
   
 /* Find which persistent searches are affected by this operation */  /* Find which persistent searches are affected by this operation */
 static void  static void
 syncprov_matchops( Operation *op, opcookie *opc, int saveit )  syncprov_matchops( Operation *op, opcookie *opc, int saveit )
Line 788  syncprov_matchops( Operation *op, opcook Line 850  syncprov_matchops( Operation *op, opcook
         syncprov_info_t         *si = on->on_bi.bi_private;          syncprov_info_t         *si = on->on_bi.bi_private;
   
         fbase_cookie fc;          fbase_cookie fc;
         syncops *ss;          syncops *ss, *sprev, *snext;
         Entry *e;          Entry *e;
         Attribute *a;          Attribute *a;
         int rc;          int rc;
Line 824  syncprov_matchops( Operation *op, opcook Line 886  syncprov_matchops( Operation *op, opcook
         }          }
   
         ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );          ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
         for (ss = si->si_ops; ss; ss=ss->s_next)          for (ss = si->si_ops, sprev = (syncops *)&si->si_ops; ss;
                   sprev = ss, ss=snext)
         {          {
                 syncmatches *sm;                  syncmatches *sm;
                 int found = 0;                  int found = 0;
   
                   snext = ss->s_next;
                 /* validate base */                  /* validate base */
                 fc.fss = ss;                  fc.fss = ss;
                 fc.fbase = 0;                  fc.fbase = 0;
                 fc.fscope = 0;                  fc.fscope = 0;
   
                   /* If the base of the search is missing, signal a refresh */
                 rc = syncprov_findbase( op, &fc );                  rc = syncprov_findbase( op, &fc );
                 if ( rc != LDAP_SUCCESS ) continue;                  if ( rc != LDAP_SUCCESS ) {
                           SlapReply rs = {REP_RESULT};
                           send_ldap_error( ss->s_op, &rs, LDAP_SYNC_REFRESH_REQUIRED,
                                   "search base has changed" );
                           sprev->s_next = snext;
                           syncprov_drop_psearch( ss );
                           continue;
                   }
   
                 /* If we're sending results now, look for this op in old matches */                  /* If we're sending results now, look for this op in old matches */
                 if ( !saveit ) {                  if ( !saveit ) {
Line 877  syncprov_matchops( Operation *op, opcook Line 950  syncprov_matchops( Operation *op, opcook
         }          }
 }  }
   
 static void  
 syncprov_free_syncop( syncops *so )  
 {  
         syncres *sr, *srnext;  
   
         ldap_pvt_thread_mutex_lock( &so->s_mutex );  
         so->s_inuse--;  
         if ( so->s_inuse > 0 ) {  
                 ldap_pvt_thread_mutex_unlock( &so->s_mutex );  
                 return;  
         }  
         ldap_pvt_thread_mutex_unlock( &so->s_mutex );  
         filter_free( so->s_op->ors_filter );  
         ch_free( so->s_op );  
         ch_free( so->s_base.bv_val );  
         for ( sr=so->s_res; sr; sr=srnext ) {  
                 srnext = sr->s_next;  
                 ch_free( sr );  
         }  
         ldap_pvt_thread_mutex_destroy( &so->s_mutex );  
         ch_free( so );  
 }  
   
 static int  static int
 syncprov_op_cleanup( Operation *op, SlapReply *rs )  syncprov_op_cleanup( Operation *op, SlapReply *rs )
 {  {
Line 920  syncprov_op_cleanup( Operation *op, Slap Line 970  syncprov_op_cleanup( Operation *op, Slap
         mtdummy.mt_op = op;          mtdummy.mt_op = op;
         ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );          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_mutex_unlock( &si->si_mods_mutex );
         if ( mt ) {          if ( mt ) {
                 modinst *mi = mt->mt_mods;                  modinst *mi = mt->mt_mods;
                                   
Line 930  syncprov_op_cleanup( Operation *op, Slap Line 981  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 );
                         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_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 );
                 }                  }
         }          }
         ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );  
         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 1000  syncprov_op_response( Operation *op, Sla Line 1052  syncprov_op_response( Operation *op, Sla
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
 }  }
   
 static int  /* We don't use a subentry to store the context CSN any more.
 syncprov_op_abandon( Operation *op, SlapReply *rs )   * We expose the current context CSN as an operational attribute
 {   * of the suffix entry.
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;  
         syncprov_info_t         *si = on->on_bi.bi_private;  
         syncops *so, *soprev;  
   
         ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );  
         for ( so=si->si_ops, soprev = (syncops *)&si->si_ops; so;  
                 soprev=so, so=so->s_next ) {  
                 if ( so->s_op->o_connid == op->o_connid &&  
                         so->s_op->o_msgid == op->orn_msgid ) {  
                                 so->s_op->o_abandon = 1;  
                                 soprev->s_next = so->s_next;  
                                 break;  
                 }  
         }  
         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );  
         if ( so ) {  
                 ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex );  
                 op->o_conn->c_n_ops_executing--;  
                 op->o_conn->c_n_ops_completed++;  
                 ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex );  
                 /* Is this really a Cancel exop? */  
                 if ( op->o_tag != LDAP_REQ_ABANDON ) {  
                         rs->sr_err = LDAP_CANCELLED;  
                         send_ldap_result( so->s_op, rs );  
                 }  
                 syncprov_free_syncop( so );  
         }  
         return SLAP_CB_CONTINUE;  
 }  
   
 #if 0  
 /* We don't use a subentry to store the context CSN any more. But  
  * we ought to expose the current context CSN as an operational attribute  
  * somewhere, like on the suffix entry.  
  */   */
 static int  static int
 syncprov_op_compare( Operation *op, SlapReply *rs )  syncprov_op_compare( Operation *op, SlapReply *rs )
Line 1045  syncprov_op_compare( Operation *op, Slap Line 1063  syncprov_op_compare( Operation *op, Slap
         syncprov_info_t         *si = on->on_bi.bi_private;          syncprov_info_t         *si = on->on_bi.bi_private;
         int rc = SLAP_CB_CONTINUE;          int rc = SLAP_CB_CONTINUE;
   
         if ( dn_match( &op->o_req_ndn, &si->si_e->e_nname ) )          if ( dn_match( &op->o_req_ndn, op->o_bd->be_nsuffix ) &&
                   op->oq_compare.rs_ava->aa_desc == slap_schema.si_ad_contextCSN )
         {          {
                 Attribute *a;                  Entry e = {0};
                   Attribute a = {0};
                   struct berval bv[2];
   
                   e.e_name = op->o_bd->be_suffix[0];
                   e.e_nname = op->o_bd->be_nsuffix[0];
   
                   bv[1].bv_val = NULL;
                   bv[0] = si->si_ctxcsn;
   
                   a.a_desc = slap_schema.si_ad_contextCSN;
                   a.a_vals = bv;
                   a.a_nvals = a.a_vals;
   
                 ldap_pvt_thread_mutex_lock( &si->si_e_mutex );                  ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
   
                   rs->sr_err = access_allowed( op, &e, op->oq_compare.rs_ava->aa_desc,
                           &op->oq_compare.rs_ava->aa_value, ACL_COMPARE, NULL );
                   if ( ! rs->sr_err ) {
                           rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
                           goto return_results;
                   }
   
                 if ( get_assert( op ) &&                  if ( get_assert( op ) &&
                         ( test_filter( op, si->si_e, get_assertion( op ) ) != LDAP_COMPARE_TRUE ) )                          ( test_filter( op, &e, get_assertion( op ) ) != LDAP_COMPARE_TRUE ) )
                 {                  {
                         rs->sr_err = LDAP_ASSERTION_FAILED;                          rs->sr_err = LDAP_ASSERTION_FAILED;
                         goto return_results;                          goto return_results;
                 }                  }
   
                 rs->sr_err = access_allowed( op, si->si_e, op->oq_compare.rs_ava->aa_desc,  
                         &op->oq_compare.rs_ava->aa_value, ACL_COMPARE, NULL );  
                 if ( ! rs->sr_err ) {  
                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;  
                         goto return_results;  
                 }  
   
                 rs->sr_err = LDAP_NO_SUCH_ATTRIBUTE;                  rs->sr_err = LDAP_COMPARE_FALSE;
   
                 for ( a = attr_find( si->si_e->e_attrs, op->oq_compare.rs_ava->aa_desc );                  if ( value_find_ex( op->oq_compare.rs_ava->aa_desc,
                         a != NULL;                          SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
                         a = attr_find( a->a_next, op->oq_compare.rs_ava->aa_desc ) )                                  SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
                                   a.a_nvals, &op->oq_compare.rs_ava->aa_value, op->o_tmpmemctx ) == 0 )
                 {                  {
                         rs->sr_err = LDAP_COMPARE_FALSE;                          rs->sr_err = LDAP_COMPARE_TRUE;
   
                         if ( value_find_ex( op->oq_compare.rs_ava->aa_desc,  
                                 SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |  
                                         SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,  
                                 a->a_nvals, &op->oq_compare.rs_ava->aa_value, op->o_tmpmemctx ) == 0 )  
                         {  
                                 rs->sr_err = LDAP_COMPARE_TRUE;  
                                 break;  
                         }  
                 }                  }
   
 return_results:;  return_results:;
   
                 ldap_pvt_thread_mutex_unlock( &si->si_e_mutex );                  ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );
   
                 send_ldap_result( op, rs );                  send_ldap_result( op, rs );
   
Line 1095  return_results:; Line 1119  return_results:;
                 rc = rs->sr_err;                  rc = rs->sr_err;
         }          }
   
         return SLAP_CB_CONTINUE;          return rc;
 }  }
 #endif  
                   
 static int  static int
 syncprov_op_mod( Operation *op, SlapReply *rs )  syncprov_op_mod( Operation *op, SlapReply *rs )
Line 1466  syncprov_op_search( Operation *op, SlapR Line 1489  syncprov_op_search( Operation *op, SlapR
         fava->f_choice = LDAP_FILTER_LE;          fava->f_choice = LDAP_FILTER_LE;
         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;
           ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
         ber_dupbv_x( &fava->f_ava->aa_value, &si->si_ctxcsn, op->o_tmpmemctx );          ber_dupbv_x( &fava->f_ava->aa_value, &si->si_ctxcsn, op->o_tmpmemctx );
           ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );
         fand->f_and = fava;          fand->f_and = fava;
         if ( gotstate ) {          if ( gotstate ) {
                 fava->f_next = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );                  fava->f_next = op->o_tmpalloc( sizeof(Filter), op->o_tmpmemctx );
Line 1508  shortcut: Line 1533  shortcut:
 }  }
   
 static int  static int
   syncprov_operational(
           Operation *op,
           SlapReply *rs )
   {
           slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
           syncprov_info_t         *si = (syncprov_info_t *)on->on_bi.bi_private;
   
           if ( rs->sr_entry &&
                   dn_match( &rs->sr_entry->e_nname, op->o_bd->be_nsuffix )) {
   
                   Attribute **ap;
   
                   for ( ap = &rs->sr_operational_attrs; *ap; ap=&(*ap)->a_next ) ;
   
                   if ( SLAP_OPATTRS( rs->sr_attr_flags ) ||
                           ad_inlist( slap_schema.si_ad_contextCSN, rs->sr_attrs )) {
                           
                           Attribute *a = ch_malloc( sizeof(Attribute));
                           a->a_desc = slap_schema.si_ad_contextCSN;
                           a->a_vals = ch_malloc( 2 * sizeof(struct berval));
   
                           ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
                           ber_dupbv( &a->a_vals[0], &si->si_ctxcsn );
                           ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );
   
                           a->a_vals[1].bv_val = NULL;
                           a->a_nvals = a->a_vals;
                           a->a_next = NULL;
                           a->a_flags = 0;
   
                           *ap = a;
                   }
           }
           return LDAP_SUCCESS;
   }
   
   static int
 syncprov_db_config(  syncprov_db_config(
         BackendDB       *be,          BackendDB       *be,
         const char      *fname,          const char      *fname,
Line 1707  syncprov_init() Line 1769  syncprov_init()
         syncprov.on_bi.bi_op_cancel = syncprov_op_abandon;          syncprov.on_bi.bi_op_cancel = syncprov_op_abandon;
   
         syncprov.on_bi.bi_op_add = syncprov_op_mod;          syncprov.on_bi.bi_op_add = syncprov_op_mod;
 #if 0  
         syncprov.on_bi.bi_op_compare = syncprov_op_compare;          syncprov.on_bi.bi_op_compare = syncprov_op_compare;
 #endif  
         syncprov.on_bi.bi_op_delete = syncprov_op_mod;          syncprov.on_bi.bi_op_delete = syncprov_op_mod;
         syncprov.on_bi.bi_op_modify = syncprov_op_mod;          syncprov.on_bi.bi_op_modify = syncprov_op_mod;
         syncprov.on_bi.bi_op_modrdn = syncprov_op_mod;          syncprov.on_bi.bi_op_modrdn = syncprov_op_mod;
         syncprov.on_bi.bi_op_search = syncprov_op_search;          syncprov.on_bi.bi_op_search = syncprov_op_search;
         syncprov.on_bi.bi_extended = syncprov_op_extended;          syncprov.on_bi.bi_extended = syncprov_op_extended;
           syncprov.on_bi.bi_operational = syncprov_operational;
   
 #if 0  #if 0
         syncprov.on_response = syncprov_response;          syncprov.on_response = syncprov_response;

Removed from v.1.22  
changed lines
  Added in v.1.25


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