Diff for /servers/slapd/overlays/syncprov.c between versions 1.23 and 1.24

version 1.23, 2004/11/27 06:47:24 version 1.24, 2004/11/27 07:30:44
Line 1050  syncprov_op_response( Operation *op, Sla Line 1050  syncprov_op_response( Operation *op, Sla
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
 }  }
   
 #if 0  /* We don't use a subentry to store the context CSN any more.
 /* We don't use a subentry to store the context CSN any more. But   * We expose the current context CSN as an operational attribute
  * we ought to expose the current context CSN as an operational attribute   * of the suffix entry.
  * 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 1062  syncprov_op_compare( Operation *op, Slap Line 1061  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];
   
                 ldap_pvt_thread_mutex_lock( &si->si_e_mutex );                  e.e_name = op->o_bd->be_suffix[0];
                   e.e_nname = op->o_bd->be_nsuffix[0];
   
                 if ( get_assert( op ) &&                  bv[1].bv_val = NULL;
                         ( test_filter( op, si->si_e, get_assertion( op ) ) != LDAP_COMPARE_TRUE ) )                  bv[0] = si->si_ctxcsn;
                 {  
                         rs->sr_err = LDAP_ASSERTION_FAILED;                  a.a_desc = slap_schema.si_ad_contextCSN;
                         goto return_results;                  a.a_vals = bv;
                 }                  a.a_nvals = a.a_vals;
   
                 rs->sr_err = access_allowed( op, si->si_e, op->oq_compare.rs_ava->aa_desc,                  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 );                          &op->oq_compare.rs_ava->aa_value, ACL_COMPARE, NULL );
                 if ( ! rs->sr_err ) {                  if ( ! rs->sr_err ) {
                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;                          rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
                         goto return_results;                          goto return_results;
                 }                  }
   
                 rs->sr_err = LDAP_NO_SUCH_ATTRIBUTE;                  if ( get_assert( op ) &&
                           ( test_filter( op, &e, get_assertion( op ) ) != LDAP_COMPARE_TRUE ) )
                 for ( a = attr_find( si->si_e->e_attrs, op->oq_compare.rs_ava->aa_desc );  
                         a != NULL;  
                         a = attr_find( a->a_next, op->oq_compare.rs_ava->aa_desc ) )  
                 {                  {
                         rs->sr_err = LDAP_COMPARE_FALSE;                          rs->sr_err = LDAP_ASSERTION_FAILED;
                           goto return_results;
                   }
   
                         if ( value_find_ex( op->oq_compare.rs_ava->aa_desc,  
                                 SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |                  rs->sr_err = LDAP_COMPARE_FALSE;
                                         SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,  
                                 a->a_nvals, &op->oq_compare.rs_ava->aa_value, op->o_tmpmemctx ) == 0 )                  if ( value_find_ex( op->oq_compare.rs_ava->aa_desc,
                         {                          SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
                                 rs->sr_err = LDAP_COMPARE_TRUE;                                  SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
                                 break;                                  a.a_nvals, &op->oq_compare.rs_ava->aa_value, op->o_tmpmemctx ) == 0 )
                         }                  {
                           rs->sr_err = LDAP_COMPARE_TRUE;
                 }                  }
   
 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 1112  return_results:; Line 1117  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 1483  syncprov_op_search( Operation *op, SlapR Line 1487  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 1525  shortcut: Line 1531  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 1724  syncprov_init() Line 1767  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.23  
changed lines
  Added in v.1.24


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