Diff for /servers/slapd/overlays/syncprov.c between versions 1.241 and 1.253

version 1.241, 2008/05/29 22:55:46 version 1.253, 2008/11/23 19:43:39
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.240 2008/05/29 21:48:35 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.252 2008/11/06 20:10:25 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 393  static struct berval generic_filterstr = Line 393  static struct berval generic_filterstr =
 static int  static int
 syncprov_findbase( Operation *op, fbase_cookie *fc )  syncprov_findbase( Operation *op, fbase_cookie *fc )
 {  {
         opcookie *opc = op->o_callback->sc_private;  
         slap_overinst *on = opc->son;  
   
         /* Use basic parameters from syncrepl search, but use          /* Use basic parameters from syncrepl search, but use
          * current op's threadctx / tmpmemctx           * current op's threadctx / tmpmemctx
          */           */
Line 630  again: Line 627  again:
                 cf.f_av_value = si->si_ctxcsn[maxid];                  cf.f_av_value = si->si_ctxcsn[maxid];
                 fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),                  fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),
                         "(entryCSN>=%s)", cf.f_av_value.bv_val );                          "(entryCSN>=%s)", cf.f_av_value.bv_val );
                 if ( fop.ors_filterstr.bv_len < 0 || fop.ors_filterstr.bv_len >= sizeof( buf ) ) {                  if ( fop.ors_filterstr.bv_len >= sizeof( buf ) ) {
                         return LDAP_OTHER;                          return LDAP_OTHER;
                 }                  }
                 fop.ors_attrsonly = 0;                  fop.ors_attrsonly = 0;
Line 667  again: Line 664  again:
                         fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),                          fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),
                                 "(entryCSN<=%s)", cf.f_av_value.bv_val );                                  "(entryCSN<=%s)", cf.f_av_value.bv_val );
                 }                  }
                 if ( fop.ors_filterstr.bv_len < 0 || fop.ors_filterstr.bv_len >= sizeof( buf ) ) {                  if ( fop.ors_filterstr.bv_len >= sizeof( buf ) ) {
                         return LDAP_OTHER;                          return LDAP_OTHER;
                 }                  }
                 fop.ors_attrsonly = 1;                  fop.ors_attrsonly = 1;
Line 911  syncprov_qplay( Operation *op, struct re Line 908  syncprov_qplay( Operation *op, struct re
         } else {          } else {
                 /* bail out on any error */                  /* bail out on any error */
                 ldap_pvt_runqueue_remove( &slapd_rq, rtask );                  ldap_pvt_runqueue_remove( &slapd_rq, rtask );
   
                   /* Prevent duplicate remove */
                   if ( so->s_qtask == rtask )
                           so->s_qtask = NULL;
         }          }
         ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );          ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
         ldap_pvt_thread_mutex_unlock( &so->s_mutex );          ldap_pvt_thread_mutex_unlock( &so->s_mutex );
Line 1181  syncprov_matchops( Operation *op, opcook Line 1182  syncprov_matchops( Operation *op, opcook
                 sprev = ss, ss=snext)                  sprev = ss, ss=snext)
         {          {
                 Operation op2;                  Operation op2;
                   Opheader oh;
                 syncmatches *sm;                  syncmatches *sm;
                 int found = 0;                  int found = 0;
   
Line 1230  syncprov_matchops( Operation *op, opcook Line 1232  syncprov_matchops( Operation *op, opcook
   
                 if ( fc.fscope ) {                  if ( fc.fscope ) {
                         op2 = *ss->s_op;                          op2 = *ss->s_op;
                         op2.o_hdr = op->o_hdr;                          oh = *op->o_hdr;
                           oh.oh_conn = ss->s_op->o_conn;
                           oh.oh_connid = ss->s_op->o_connid;
                           op2.o_hdr = &oh;
                         op2.o_extra = op->o_extra;                          op2.o_extra = op->o_extra;
                 }                  }
   
Line 1254  syncprov_matchops( Operation *op, opcook Line 1259  syncprov_matchops( Operation *op, opcook
                         /* send DELETE */                          /* send DELETE */
                         syncprov_qresp( opc, ss, LDAP_SYNC_DELETE );                          syncprov_qresp( opc, ss, LDAP_SYNC_DELETE );
                 }                  }
                   if ( !saveit && found ) {
                           /* Decrement s_inuse, was incremented when called
                            * with saveit == TRUE
                            */
                           syncprov_free_syncop( ss );
                   }
         }          }
         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );          ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
   
Line 1334  syncprov_checkpoint( Operation *op, Slap Line 1345  syncprov_checkpoint( Operation *op, Slap
         mod.sml_nvalues = NULL;          mod.sml_nvalues = NULL;
         mod.sml_desc = slap_schema.si_ad_contextCSN;          mod.sml_desc = slap_schema.si_ad_contextCSN;
         mod.sml_op = LDAP_MOD_REPLACE;          mod.sml_op = LDAP_MOD_REPLACE;
         mod.sml_flags = 0;          mod.sml_flags = SLAP_MOD_INTERNAL;
         mod.sml_next = NULL;          mod.sml_next = NULL;
   
         cb.sc_response = slap_null_cb;          cb.sc_response = slap_null_cb;
Line 1573  syncprov_playlog( Operation *op, SlapRep Line 1584  syncprov_playlog( Operation *op, SlapRep
                 if ( delcsn[0].bv_len ) {                  if ( delcsn[0].bv_len ) {
                         slap_compose_sync_cookie( op, &cookie, delcsn, srs->sr_state.rid,                          slap_compose_sync_cookie( op, &cookie, delcsn, srs->sr_state.rid,
                                 srs->sr_state.sid );                                  srs->sr_state.sid );
                 }  
   
                 Debug( LDAP_DEBUG_SYNC, "syncprov_playlog: cookie=%s\n", cookie.bv_val, 0, 0 );                          Debug( LDAP_DEBUG_SYNC, "syncprov_playlog: cookie=%s\n", cookie.bv_val, 0, 0 );
                   }
   
                 uuids[ndel].bv_val = NULL;                  uuids[ndel].bv_val = NULL;
                 syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET,                  syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET,
                         delcsn[0].bv_len ? &cookie : NULL, 0, uuids, 1 );                          delcsn[0].bv_len ? &cookie : NULL, 0, uuids, 1 );
                 op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );                  if ( delcsn[0].bv_len ) {
                           op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
                   }
         }          }
         op->o_tmpfree( uuids, op->o_tmpmemctx );          op->o_tmpfree( uuids, op->o_tmpmemctx );
 }  }
Line 1597  syncprov_op_response( Operation *op, Sla Line 1610  syncprov_op_response( Operation *op, Sla
         {          {
                 struct berval maxcsn = BER_BVNULL;                  struct berval maxcsn = BER_BVNULL;
                 char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];                  char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
                 int do_check = 0, have_psearches;                  int do_check = 0, have_psearches, foundit;
   
                 /* Update our context CSN */                  /* Update our context CSN */
                 cbuf[0] = '\0';                  cbuf[0] = '\0';
                 ldap_pvt_thread_rdwr_wlock( &si->si_csn_rwlock );                  ldap_pvt_thread_rdwr_wlock( &si->si_csn_rwlock );
                 slap_get_commit_csn( op, &maxcsn );                  slap_get_commit_csn( op, &maxcsn, &foundit );
                 if ( BER_BVISNULL( &maxcsn ) && SLAP_GLUE_SUBORDINATE( op->o_bd )) {                  if ( BER_BVISNULL( &maxcsn ) && SLAP_GLUE_SUBORDINATE( op->o_bd )) {
                         /* syncrepl queues the CSN values in the db where                          /* syncrepl queues the CSN values in the db where
                          * it is configured , not where the changes are made.                           * it is configured , not where the changes are made.
Line 1611  syncprov_op_response( Operation *op, Sla Line 1624  syncprov_op_response( Operation *op, Sla
                          */                           */
                         BackendDB *be = op->o_bd;                          BackendDB *be = op->o_bd;
                         op->o_bd = select_backend( &be->be_nsuffix[0], 1);                          op->o_bd = select_backend( &be->be_nsuffix[0], 1);
                         slap_get_commit_csn( op, &maxcsn );                          slap_get_commit_csn( op, &maxcsn, &foundit );
                         op->o_bd = be;                          op->o_bd = be;
                 }                  }
                 if ( !BER_BVISNULL( &maxcsn ) ) {                  if ( !BER_BVISNULL( &maxcsn ) ) {
Line 1634  syncprov_op_response( Operation *op, Sla Line 1647  syncprov_op_response( Operation *op, Sla
                                         sizeof(int));                                          sizeof(int));
                                 si->si_sids[i] = sid;                                  si->si_sids[i] = sid;
                         }                          }
                 } else {                  } else if ( !foundit ) {
                         /* internal ops that aren't meant to be replicated */                          /* internal ops that aren't meant to be replicated */
                         ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
   
                 /* Don't do any processing for consumer contextCSN updates */                  /* Don't do any processing for consumer contextCSN updates */
                 if ( SLAP_SYNC_SHADOW( op->o_bd ) &&                   if ( op->o_dont_replicate ) {
                         op->o_msgid == SLAP_SYNC_UPDATE_MSGID ) {  
                         ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
Line 1671  syncprov_op_response( Operation *op, Sla Line 1683  syncprov_op_response( Operation *op, Sla
                         ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
                 }                  }
   
                 opc->sctxcsn.bv_len = maxcsn.bv_len;                  /* only update consumer ctx if this is the greatest csn */
                 opc->sctxcsn.bv_val = cbuf;                  if ( bvmatch( &maxcsn, &op->o_csn )) {
                           opc->sctxcsn.bv_len = maxcsn.bv_len;
                           opc->sctxcsn.bv_val = cbuf;
                   }
   
                 /* Handle any persistent searches */                  /* Handle any persistent searches */
                 ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );                  ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
Line 2319  no_change:  if ( !(op->o_sync_mode & SLA Line 2334  no_change:  if ( !(op->o_sync_mode & SLA
                                 send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" );                                  send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" );
                                 return rs->sr_err;                                  return rs->sr_err;
                         }                          }
                           if ( srs->sr_state.ctxcsn ) {
                                   ber_bvarray_free_x( srs->sr_state.ctxcsn, op->o_tmpmemctx );
                                   srs->sr_state.ctxcsn = NULL;
                           }
                           if ( srs->sr_state.sids ) {
                                   slap_sl_free( srs->sr_state.sids, op->o_tmpmemctx );
                                   srs->sr_state.sids = NULL;
                           }
                           srs->sr_state.numcsns = 0;
                 } else {                  } else {
                         gotstate = 1;                          gotstate = 1;
                         /* If changed and doing Present lookup, send Present UUIDs */                          /* If changed and doing Present lookup, send Present UUIDs */
Line 2497  static ConfigOCs spocs[] = { Line 2521  static ConfigOCs spocs[] = {
                 "NAME 'olcSyncProvConfig' "                  "NAME 'olcSyncProvConfig' "
                 "DESC 'SyncRepl Provider configuration' "                  "DESC 'SyncRepl Provider configuration' "
                 "SUP olcOverlayConfig "                  "SUP olcOverlayConfig "
                 "MAY ( olcSpCheckpoint $ olcSpSessionlog $ olcSpNoPresent ) )",                  "MAY ( olcSpCheckpoint "
                           "$ olcSpSessionlog "
                           "$ olcSpNoPresent "
                           "$ olcSpReloadHint "
                   ") )",
                         Cft_Overlay, spcfg },                          Cft_Overlay, spcfg },
         { NULL, 0, NULL }          { NULL, 0, NULL }
 };  };
Line 2516  sp_cf_gen(ConfigArgs *c) Line 2544  sp_cf_gen(ConfigArgs *c)
                                 struct berval bv;                                  struct berval bv;
                                 bv.bv_len = snprintf( c->cr_msg, sizeof( c->cr_msg ),                                  bv.bv_len = snprintf( c->cr_msg, sizeof( c->cr_msg ),
                                         "%d %d", si->si_chkops, si->si_chktime );                                          "%d %d", si->si_chkops, si->si_chktime );
                                 if ( bv.bv_len < 0 || bv.bv_len >= sizeof( c->cr_msg ) ) {                                  if ( bv.bv_len >= sizeof( c->cr_msg ) ) {
                                         rc = 1;                                          rc = 1;
                                 } else {                                  } else {
                                         bv.bv_val = c->cr_msg;                                          bv.bv_val = c->cr_msg;
Line 2710  syncprov_db_open( Line 2738  syncprov_db_open(
                         si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, a->a_numvals, NULL );                          si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, a->a_numvals, NULL );
                 }                  }
                 overlay_entry_release_ov( op, e, 0, on );                  overlay_entry_release_ov( op, e, 0, on );
                 if ( si->si_ctxcsn ) {                  if ( si->si_ctxcsn && !SLAP_DBCLEAN( be )) {
                         op->o_req_dn = be->be_suffix[0];                          op->o_req_dn = be->be_suffix[0];
                         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;

Removed from v.1.241  
changed lines
  Added in v.1.253


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