Diff for /servers/slapd/overlays/syncprov.c between versions 1.70 and 1.74

version 1.70, 2005/02/18 06:12:57 version 1.74, 2005/04/15 04:58:04
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.69 2005/02/18 00:08:47 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.73 2005/04/09 09:26:31 hyc 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 250  syncprov_done_ctrl( Line 250  syncprov_done_ctrl(
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
 #if 0  
 /* Generate state based on session log - not implemented yet */  
 static int  
 syncprov_state_ctrl_from_slog(  
         Operation       *op,  
         SlapReply       *rs,  
         struct slog_entry *slog_e,  
         int                     entry_sync_state,  
         LDAPControl     **ctrls,  
         int                     num_ctrls,  
         int                     send_cookie,  
         struct berval   *cookie)  
 {  
         Attribute* a;  
         int ret;  
         int res;  
         const char *text = NULL;  
   
         BerElementBuffer berbuf;  
         BerElement *ber = (BerElement *)&berbuf;  
   
         struct berval entryuuid_bv      = BER_BVNULL;  
   
         ber_init2( ber, NULL, LBER_USE_DER );  
         ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx );  
   
         ctrls[num_ctrls] = ch_malloc ( sizeof ( LDAPControl ) );  
   
         entryuuid_bv = slog_e->sl_uuid;  
   
         if ( send_cookie && cookie ) {  
                 ber_printf( ber, "{eOON}",  
                         entry_sync_state, &entryuuid_bv, cookie );  
         } else {  
                 ber_printf( ber, "{eON}",  
                         entry_sync_state, &entryuuid_bv );  
         }  
   
         ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_STATE;  
         ctrls[num_ctrls]->ldctl_iscritical = (op->o_sync == SLAP_CONTROL_CRITICAL);  
         ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 );  
   
         ber_free_buf( ber );  
   
         if ( ret < 0 ) {  
                 Debug( LDAP_DEBUG_TRACE,  
                         "slap_build_sync_ctrl: ber_flatten2 failed\n",  
                         0, 0, 0 );  
                 send_ldap_error( op, rs, LDAP_OTHER, "internal error" );  
                 return ret;  
         }  
   
         return LDAP_SUCCESS;  
 }  
 #endif  
   
 static int  static int
 syncprov_sendinfo(  syncprov_sendinfo(
         Operation       *op,          Operation       *op,
Line 470  syncprov_findbase( Operation *op, fbase_ Line 414  syncprov_findbase( Operation *op, fbase_
         cb.sc_private = fc;          cb.sc_private = fc;
   
         fop.o_sync_mode &= SLAP_CONTROL_MASK;   /* turn off sync mode */          fop.o_sync_mode &= SLAP_CONTROL_MASK;   /* turn off sync mode */
           fop.o_managedsait = SLAP_CONTROL_CRITICAL;
         fop.o_callback = &cb;          fop.o_callback = &cb;
         fop.o_tag = LDAP_REQ_SEARCH;          fop.o_tag = LDAP_REQ_SEARCH;
         fop.ors_scope = LDAP_SCOPE_BASE;          fop.ors_scope = LDAP_SCOPE_BASE;
Line 604  syncprov_findcsn( Operation *op, int mod Line 549  syncprov_findcsn( Operation *op, int mod
         char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
         struct berval fbuf, maxcsn;          struct berval fbuf, maxcsn;
         Filter cf, af;          Filter cf, af;
         AttributeAssertion eq;  #ifdef LDAP_COMP_MATCH
           AttributeAssertion eq = { NULL, BER_BVNULL, NULL };
   #else
           AttributeAssertion eq = { NULL, BER_BVNULL };
   #endif
         int i, rc = LDAP_SUCCESS;          int i, rc = LDAP_SUCCESS;
         fpres_cookie pcookie;          fpres_cookie pcookie;
         sync_control *srs = NULL;          sync_control *srs = NULL;
Line 619  syncprov_findcsn( Operation *op, int mod Line 568  syncprov_findcsn( Operation *op, int mod
   
         fop = *op;          fop = *op;
         fop.o_sync_mode &= SLAP_CONTROL_MASK;   /* turn off sync_mode */          fop.o_sync_mode &= SLAP_CONTROL_MASK;   /* turn off sync_mode */
           /* We want pure entries, not referrals */
           fop.o_managedsait = SLAP_CONTROL_CRITICAL;
   
         fbuf.bv_val = buf;          fbuf.bv_val = buf;
         cf.f_ava = &eq;          cf.f_ava = &eq;
Line 669  syncprov_findcsn( Operation *op, int mod Line 620  syncprov_findcsn( Operation *op, int mod
                 fop.ors_attrsonly = 0;                  fop.ors_attrsonly = 0;
                 fop.ors_attrs = uuid_anlist;                  fop.ors_attrs = uuid_anlist;
                 fop.ors_slimit = SLAP_NO_LIMIT;                  fop.ors_slimit = SLAP_NO_LIMIT;
                 /* We want pure entries, not referrals */  
                 fop.o_managedsait = SLAP_CONTROL_CRITICAL;  
                 cb.sc_private = &pcookie;                  cb.sc_private = &pcookie;
                 cb.sc_response = findpres_cb;                  cb.sc_response = findpres_cb;
                 pcookie.num = 0;                  pcookie.num = 0;
Line 1080  syncprov_checkpoint( Operation *op, Slap Line 1029  syncprov_checkpoint( Operation *op, Slap
         Modifications mod;          Modifications mod;
         Operation opm;          Operation opm;
         struct berval bv[2];          struct berval bv[2];
         BackendInfo *orig;  
         slap_callback cb = {0};          slap_callback cb = {0};
           int manage = get_manageDSAit(op);
   
         mod.sml_values = bv;          mod.sml_values = bv;
         bv[1].bv_val = NULL;          bv[1].bv_val = NULL;
Line 1098  syncprov_checkpoint( Operation *op, Slap Line 1047  syncprov_checkpoint( Operation *op, Slap
         opm.orm_modlist = &mod;          opm.orm_modlist = &mod;
         opm.o_req_dn = op->o_bd->be_suffix[0];          opm.o_req_dn = op->o_bd->be_suffix[0];
         opm.o_req_ndn = op->o_bd->be_nsuffix[0];          opm.o_req_ndn = op->o_bd->be_nsuffix[0];
         orig = opm.o_bd->bd_info;  
         opm.o_bd->bd_info = on->on_info->oi_orig;          opm.o_bd->bd_info = on->on_info->oi_orig;
           opm.o_managedsait = SLAP_CONTROL_NONCRITICAL;
         opm.o_bd->be_modify( &opm, rs );          opm.o_bd->be_modify( &opm, rs );
           opm.o_managedsait = manage;
 }  }
   
 static void  static void
Line 1241  syncprov_playlog( Operation *op, SlapRep Line 1191  syncprov_playlog( Operation *op, SlapRep
                 SlapReply frs = { REP_RESULT };                  SlapReply frs = { REP_RESULT };
                 int rc;                  int rc;
                 Filter mf, af;                  Filter mf, af;
   #ifdef LDAP_COMP_MATCH
                   AttributeAssertion eq = { NULL, BER_BVNULL, NULL };
   #else
                 AttributeAssertion eq;                  AttributeAssertion eq;
   #endif
                 slap_callback cb = {0};                  slap_callback cb = {0};
   
                 fop = *op;                  fop = *op;
Line 1487  syncprov_op_mod( Operation *op, SlapRepl Line 1441  syncprov_op_mod( Operation *op, SlapRepl
                                 ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );                                  ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                                 ldap_pvt_thread_yield();                                  ldap_pvt_thread_yield();
                                 ldap_pvt_thread_mutex_lock( &mt->mt_mutex );                                  ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
   
                                   /* clean up if the caller is giving up */
                                   if ( op->o_abandon ) {
                                           modinst *m2;
                                           for ( m2 = mt->mt_mods; m2->mi_next != mi;
                                                   m2 = m2->mi_next );
                                           m2->mi_next = mi->mi_next;
                                           if ( mt->mt_tail == mi ) mt->mt_tail = m2;
                                           op->o_tmpfree( cb, op->o_tmpmemctx );
                                           ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                                           return SLAPD_ABANDON;
                                   }
                         }                          }
                         ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );                          ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                 } else {                  } else {
Line 1741  syncprov_op_search( Operation *op, SlapR Line 1707  syncprov_op_search( Operation *op, SlapR
         }          }
   
         srs = op->o_controls[slap_cids.sc_LDAPsync];          srs = op->o_controls[slap_cids.sc_LDAPsync];
           op->o_managedsait = SLAP_CONTROL_NONCRITICAL;
   
         /* 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 1856  shortcut: Line 1823  shortcut:
         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;
   #ifdef LDAP_COMP_MATCH
           fava->f_ava->aa_cf = NULL;
   #endif
         ber_dupbv_x( &fava->f_ava->aa_value, &ctxcsn, op->o_tmpmemctx );          ber_dupbv_x( &fava->f_ava->aa_value, &ctxcsn, op->o_tmpmemctx );
         fand->f_and = fava;          fand->f_and = fava;
         if ( gotstate ) {          if ( gotstate ) {
Line 1864  shortcut: Line 1834  shortcut:
                 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;
   #ifdef LDAP_COMP_MATCH
                   fava->f_ava->aa_cf = NULL;
   #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;          fava->f_next = op->ors_filter;
Line 2031  syncprov_db_open( Line 2004  syncprov_db_open(
         Attribute *a;          Attribute *a;
         int rc;          int rc;
   
           if ( slapMode & SLAP_TOOL_MODE ) {
                   return 0;
           }
   
         rc = overlay_register_control( be, LDAP_CONTROL_SYNC );          rc = overlay_register_control( be, LDAP_CONTROL_SYNC );
         if ( rc ) {          if ( rc ) {
                 return rc;                  return rc;
Line 2064  syncprov_db_open( Line 2041  syncprov_db_open(
                 op->o_req_ndn = be->be_nsuffix[0];                  op->o_req_ndn = be->be_nsuffix[0];
                 op->ors_scope = LDAP_SCOPE_SUBTREE;                  op->ors_scope = LDAP_SCOPE_SUBTREE;
                 syncprov_findcsn( op, FIND_MAXCSN );                  syncprov_findcsn( op, FIND_MAXCSN );
           } else if ( SLAP_SYNC_SHADOW( op->o_bd )) {
                   /* If we're also a consumer, and we didn't find the context entry,
                    * then don't generate anything, wait for our provider to send it
                    * to us.
                    */
                   goto out;
         }          }
   
         if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {          if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {
Line 2079  syncprov_db_open( Line 2062  syncprov_db_open(
                 syncprov_checkpoint( op, &rs, on );                  syncprov_checkpoint( op, &rs, on );
         }          }
   
   out:
         op->o_bd->bd_info = (BackendInfo *)on;          op->o_bd->bd_info = (BackendInfo *)on;
         return 0;          return 0;
 }  }
Line 2094  syncprov_db_close( Line 2078  syncprov_db_close(
     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;          int i;
   
           if ( slapMode & SLAP_TOOL_MODE ) {
                   return 0;
           }
         if ( si->si_numops ) {          if ( si->si_numops ) {
                 Connection conn;                  Connection conn;
                 char opbuf[OPERATION_BUFFER_SIZE];                  char opbuf[OPERATION_BUFFER_SIZE];

Removed from v.1.70  
changed lines
  Added in v.1.74


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