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

version 1.24, 2004/11/27 07:30:44 version 1.26, 2004/11/27 09:49:47
Line 147  syncprov_state_ctrl( Line 147  syncprov_state_ctrl(
         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] = slap_sl_malloc ( 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;
Line 200  syncprov_done_ctrl( Line 200  syncprov_done_ctrl(
         ber_init2( ber, NULL, LBER_USE_DER );          ber_init2( ber, NULL, 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] = ch_malloc ( sizeof ( LDAPControl ) );          ctrls[num_ctrls] = op->o_tmpalloc( sizeof ( LDAPControl ), op->o_tmpmemctx );
   
         ber_printf( ber, "{" );          ber_printf( ber, "{" );
         if ( send_cookie && cookie ) {          if ( send_cookie && cookie ) {
Line 776  syncprov_sendresp( Operation *op, opcook Line 776  syncprov_sendresp( Operation *op, opcook
         default:          default:
                 assert(0);                  assert(0);
         }          }
         free( rs.sr_ctrls[0] );          op->o_tmpfree( rs.sr_ctrls[0], op->o_tmpmemctx );
           rs.sr_ctrls = NULL;
         return rs.sr_err;          return rs.sr_err;
 }  }
   
Line 970  syncprov_op_cleanup( Operation *op, Slap Line 971  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 980  syncprov_op_cleanup( Operation *op, Slap Line 982  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 1198  typedef struct searchstate { Line 1201  typedef struct searchstate {
 static int  static int
 syncprov_search_cleanup( Operation *op, SlapReply *rs )  syncprov_search_cleanup( Operation *op, SlapReply *rs )
 {  {
         searchstate *ss = op->o_callback->sc_private;  #if 0
         if ( rs->sr_ctrls ) {          if ( rs->sr_ctrls ) {
                 free( rs->sr_ctrls[0] );                  free( rs->sr_ctrls[0] );
                 op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx );                  op->o_tmpfree( rs->sr_ctrls, op->o_tmpmemctx );
                   rs->sr_ctrls = NULL;
         }          }
   #endif
         return 0;          return 0;
 }  }
   
Line 1449  syncprov_op_search( Operation *op, SlapR Line 1454  syncprov_op_search( Operation *op, SlapR
                                         rs->sr_ctrls = ctrls;                                          rs->sr_ctrls = ctrls;
                                         rs->sr_err = LDAP_SUCCESS;                                          rs->sr_err = LDAP_SUCCESS;
                                         send_ldap_result( op, rs );                                          send_ldap_result( op, rs );
                                           rs->sr_ctrls = NULL;
                                         return rs->sr_err;                                          return rs->sr_err;
                                 }                                  }
                                 goto shortcut;                                  goto shortcut;
Line 1552  syncprov_operational( Line 1558  syncprov_operational(
                         a->a_desc = slap_schema.si_ad_contextCSN;                          a->a_desc = slap_schema.si_ad_contextCSN;
                         a->a_vals = ch_malloc( 2 * sizeof(struct berval));                          a->a_vals = ch_malloc( 2 * sizeof(struct berval));
   
   #if 0   /* causes a deadlock */
                           if ( !si->si_gotcsn ) {
                                   sync_control sc, *old;
                                   void *ctrls[SLAP_MAX_CIDS];
                                   struct berval bv = BER_BVC("1");
                   
                                   if ( !op->o_controls ) {
                                           memset(ctrls, 0, sizeof(ctrls));
                                           op->o_controls = ctrls;
                                   } else {
                                           old = op->o_controls[sync_cid];
                                   }
                                   op->o_controls[sync_cid] = ≻
                                   sc.sr_state.ctxcsn = &bv;
                                   syncprov_findcsn( op, FIND_CSN );
                                   if ( op->o_controls == ctrls ) {
                                           op->o_controls = NULL;
                                   } else {
                                           op->o_controls[sync_cid] = old;
                                   }
                           }
   #endif
                         ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );                          ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
                         ber_dupbv( &a->a_vals[0], &si->si_ctxcsn );                          ber_dupbv( &a->a_vals[0], &si->si_ctxcsn );
                         ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );                          ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );

Removed from v.1.24  
changed lines
  Added in v.1.26


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