Diff for /servers/slapd/overlays/syncprov.c between versions 1.188 and 1.202

version 1.188, 2007/05/18 21:54:27 version 1.202, 2007/10/02 16:09:15
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.187 2007/05/14 19:25:48 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.201 2007/09/29 15:55:33 ando 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 585  syncprov_findcsn( Operation *op, find_cs Line 585  syncprov_findcsn( Operation *op, find_cs
         char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
         struct berval maxcsn;          struct berval maxcsn;
         Filter cf;          Filter cf;
 #ifdef LDAP_COMP_MATCH          AttributeAssertion eq = ATTRIBUTEASSERTION_INIT;
         AttributeAssertion eq = { NULL, BER_BVNULL, NULL };  
 #else  
         AttributeAssertion eq = { NULL, BER_BVNULL };  
 #endif  
         fpres_cookie pcookie;          fpres_cookie pcookie;
         sync_control *srs = NULL;          sync_control *srs = NULL;
         struct slap_limits_set fc_limits;          struct slap_limits_set fc_limits;
Line 628  again: Line 624  again:
                                 maxid = i;                                  maxid = i;
                         }                          }
                 }                  }
                 fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN>=%s)",                  fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),
                         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 ) ) {
                           return LDAP_OTHER;
                   }
                 fop.ors_attrsonly = 0;                  fop.ors_attrsonly = 0;
                 fop.ors_attrs = csn_anlist;                  fop.ors_attrs = csn_anlist;
                 fop.ors_slimit = SLAP_NO_LIMIT;                  fop.ors_slimit = SLAP_NO_LIMIT;
Line 653  again: Line 652  again:
                 /* Look for exact match the first time */                  /* Look for exact match the first time */
                 if ( findcsn_retry ) {                  if ( findcsn_retry ) {
                         cf.f_choice = LDAP_FILTER_EQUALITY;                          cf.f_choice = LDAP_FILTER_EQUALITY;
                         fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN=%s)",                          fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),
                                 cf.f_av_value.bv_val );                                  "(entryCSN=%s)", cf.f_av_value.bv_val );
                 /* On retry, look for <= */                  /* On retry, look for <= */
                 } else {                  } else {
                         cf.f_choice = LDAP_FILTER_LE;                          cf.f_choice = LDAP_FILTER_LE;
                         fop.ors_limit = &fc_limits;                          fop.ors_limit = &fc_limits;
                           memset( &fc_limits, 0, sizeof( fc_limits ));
                         fc_limits.lms_s_unchecked = 1;                          fc_limits.lms_s_unchecked = 1;
                         fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",                          fop.ors_filterstr.bv_len = snprintf( buf, sizeof( buf ),
                                 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 ) ) {
                           return LDAP_OTHER;
                 }                  }
                 fop.ors_attrsonly = 1;                  fop.ors_attrsonly = 1;
                 fop.ors_attrs = slap_anlist_no_attrs;                  fop.ors_attrs = slap_anlist_no_attrs;
Line 773  syncprov_sendresp( Operation *op, opcook Line 776  syncprov_sendresp( Operation *op, opcook
         BER_BVZERO( &csns[1] );          BER_BVZERO( &csns[1] );
         slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, so->s_sid );          slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, so->s_sid );
   
           Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: cookie=%s\n", cookie.bv_val, 0, 0 );
   
         e_uuid.e_attrs = &a_uuid;          e_uuid.e_attrs = &a_uuid;
         a_uuid.a_desc = slap_schema.si_ad_entryUUID;          a_uuid.a_desc = slap_schema.si_ad_entryUUID;
         a_uuid.a_nvals = &opc->suuid;          a_uuid.a_nvals = &opc->suuid;
Line 1284  syncprov_op_cleanup( Operation *op, Slap Line 1289  syncprov_op_cleanup( Operation *op, Slap
 static void  static void
 syncprov_checkpoint( Operation *op, SlapReply *rs, slap_overinst *on )  syncprov_checkpoint( Operation *op, SlapReply *rs, slap_overinst *on )
 {  {
     syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;          syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;
         Modifications mod;          Modifications mod;
         Operation opm;          Operation opm;
         SlapReply rsm = { 0 };          SlapReply rsm = { 0 };
         slap_callback cb = {0};          slap_callback cb = {0};
   
           mod.sml_numvals = si->si_numcsns;
         mod.sml_values = si->si_ctxcsn;          mod.sml_values = si->si_ctxcsn;
         mod.sml_nvalues = NULL;          mod.sml_nvalues = NULL;
         mod.sml_desc = slap_schema.si_ad_contextCSN;          mod.sml_desc = slap_schema.si_ad_contextCSN;
Line 1312  syncprov_checkpoint( Operation *op, Slap Line 1318  syncprov_checkpoint( Operation *op, Slap
         if ( mod.sml_next != NULL ) {          if ( mod.sml_next != NULL ) {
                 slap_mods_free( mod.sml_next, 1 );                  slap_mods_free( mod.sml_next, 1 );
         }          }
           opm.orm_no_opattrs = 0;
 }  }
   
 static void  static void
Line 1481  syncprov_playlog( Operation *op, SlapRep Line 1488  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 = ATTRIBUTEASSERTION_INIT;
                 AttributeAssertion eq = { NULL, BER_BVNULL, NULL };  
 #else  
                 AttributeAssertion eq;  
 #endif  
                 slap_callback cb = {0};                  slap_callback cb = {0};
   
                 fop = *op;                  fop = *op;
Line 1532  syncprov_playlog( Operation *op, SlapRep Line 1535  syncprov_playlog( Operation *op, SlapRep
   
                 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 );
   
                 uuids[ndel].bv_val = NULL;                  uuids[ndel].bv_val = NULL;
                 syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, &cookie, 0, uuids, 1 );                  syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, &cookie, 0, uuids, 1 );
                 op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );                  op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
Line 1685  syncprov_op_compare( Operation *op, Slap Line 1691  syncprov_op_compare( Operation *op, Slap
   
                 rs->sr_err = LDAP_COMPARE_FALSE;                  rs->sr_err = LDAP_COMPARE_FALSE;
   
                 if ( value_find_ex( op->oq_compare.rs_ava->aa_desc,                  if ( attr_valfind( &a,
                         SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |                          SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
                                 SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,                                  SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
                                 a.a_nvals, &op->oq_compare.rs_ava->aa_value, op->o_tmpmemctx ) == 0 )                                  &op->oq_compare.rs_ava->aa_value, NULL, op->o_tmpmemctx ) == 0 )
                 {                  {
                         rs->sr_err = LDAP_COMPARE_TRUE;                          rs->sr_err = LDAP_COMPARE_TRUE;
                 }                  }
Line 1985  syncprov_search_response( Operation *op, Line 1991  syncprov_search_response( Operation *op,
                 slap_compose_sync_cookie( op, &cookie, ss->ss_ctxcsn,                  slap_compose_sync_cookie( op, &cookie, ss->ss_ctxcsn,
                         srs->sr_state.rid, srs->sr_state.sid );                          srs->sr_state.rid, srs->sr_state.sid );
   
                   Debug( LDAP_DEBUG_SYNC, "syncprov_search_response: cookie=%s\n", cookie.bv_val, 0, 0 );
   
                 /* Is this a regular refresh? */                  /* Is this a regular refresh? */
                 if ( !ss->ss_so ) {                  if ( !ss->ss_so ) {
                         rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,                          rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,
Line 2306  syncprov_operational( Line 2314  syncprov_operational(
                                                 a = attr_find( rs->sr_entry->e_attrs,                                                  a = attr_find( rs->sr_entry->e_attrs,
                                                         slap_schema.si_ad_contextCSN );                                                          slap_schema.si_ad_contextCSN );
                                         }                                          }
                                         free( a->a_vals );                                          if ( a->a_nvals != a->a_vals ) {
                                                   ber_bvarray_free( a->a_nvals );
                                           }
                                           a->a_nvals = NULL;
                                           ber_bvarray_free( a->a_vals );
                                           a->a_vals = NULL;
                                           a->a_numvals = 0;
                                 }                                  }
                                 ber_bvarray_dup_x( &a->a_vals, si->si_ctxcsn, NULL );                                  attr_valadd( a, si->si_ctxcsn, si->si_ctxcsn, si->si_numcsns );
                                 a->a_nvals = a->a_vals;  
                         }                          }
                         ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
                 }                  }
Line 2368  sp_cf_gen(ConfigArgs *c) Line 2381  sp_cf_gen(ConfigArgs *c)
                 case SP_CHKPT:                  case SP_CHKPT:
                         if ( si->si_chkops || si->si_chktime ) {                          if ( si->si_chkops || si->si_chktime ) {
                                 struct berval bv;                                  struct berval bv;
                                 bv.bv_len = sprintf( c->msg, "%d %d",                                  bv.bv_len = snprintf( c->cr_msg, sizeof( c->cr_msg ),
                                         si->si_chkops, si->si_chktime );                                          "%d %d", si->si_chkops, si->si_chktime );
                                 bv.bv_val = c->msg;                                  if ( bv.bv_len < 0 || bv.bv_len >= sizeof( c->cr_msg ) ) {
                                 value_add_one( &c->rvalue_vals, &bv );                                          rc = 1;
                                   } else {
                                           bv.bv_val = c->cr_msg;
                                           value_add_one( &c->rvalue_vals, &bv );
                                   }
                         } else {                          } else {
                                 rc = 1;                                  rc = 1;
                         }                          }
Line 2429  sp_cf_gen(ConfigArgs *c) Line 2446  sp_cf_gen(ConfigArgs *c)
         switch ( c->type ) {          switch ( c->type ) {
         case SP_CHKPT:          case SP_CHKPT:
                 if ( lutil_atoi( &si->si_chkops, c->argv[1] ) != 0 ) {                  if ( lutil_atoi( &si->si_chkops, c->argv[1] ) != 0 ) {
                         snprintf( c->msg, sizeof( c->msg ), "%s unable to parse checkpoint ops # \"%s\"",                          snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s unable to parse checkpoint ops # \"%s\"",
                                 c->argv[0], c->argv[1] );                                  c->argv[0], c->argv[1] );
                         Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,                          Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
                                 "%s: %s\n", c->log, c->msg, 0 );                                  "%s: %s\n", c->log, c->cr_msg, 0 );
                         return ARG_BAD_CONF;                          return ARG_BAD_CONF;
                 }                  }
                 if ( si->si_chkops <= 0 ) {                  if ( si->si_chkops <= 0 ) {
                         snprintf( c->msg, sizeof( c->msg ), "%s invalid checkpoint ops # \"%d\"",                          snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s invalid checkpoint ops # \"%d\"",
                                 c->argv[0], si->si_chkops );                                  c->argv[0], si->si_chkops );
                         Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,                          Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
                                 "%s: %s\n", c->log, c->msg, 0 );                                  "%s: %s\n", c->log, c->cr_msg, 0 );
                         return ARG_BAD_CONF;                          return ARG_BAD_CONF;
                 }                  }
                 if ( lutil_atoi( &si->si_chktime, c->argv[2] ) != 0 ) {                  if ( lutil_atoi( &si->si_chktime, c->argv[2] ) != 0 ) {
                         snprintf( c->msg, sizeof( c->msg ), "%s unable to parse checkpoint time \"%s\"",                          snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s unable to parse checkpoint time \"%s\"",
                                 c->argv[0], c->argv[1] );                                  c->argv[0], c->argv[1] );
                         Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,                          Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
                                 "%s: %s\n", c->log, c->msg, 0 );                                  "%s: %s\n", c->log, c->cr_msg, 0 );
                         return ARG_BAD_CONF;                          return ARG_BAD_CONF;
                 }                  }
                 if ( si->si_chktime <= 0 ) {                  if ( si->si_chktime <= 0 ) {
                         snprintf( c->msg, sizeof( c->msg ), "%s invalid checkpoint time \"%d\"",                          snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s invalid checkpoint time \"%d\"",
                                 c->argv[0], si->si_chkops );                                  c->argv[0], si->si_chkops );
                         Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,                          Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
                                 "%s: %s\n", c->log, c->msg, 0 );                                  "%s: %s\n", c->log, c->cr_msg, 0 );
                         return ARG_BAD_CONF;                          return ARG_BAD_CONF;
                 }                  }
                 si->si_chktime *= 60;                  si->si_chktime *= 60;
Line 2463  sp_cf_gen(ConfigArgs *c) Line 2480  sp_cf_gen(ConfigArgs *c)
                 int size = c->value_int;                  int size = c->value_int;
   
                 if ( size < 0 ) {                  if ( size < 0 ) {
                         snprintf( c->msg, sizeof( c->msg ), "%s size %d is negative",                          snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s size %d is negative",
                                 c->argv[0], size );                                  c->argv[0], size );
                         Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,                          Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
                                 "%s: %s\n", c->log, c->msg, 0 );                                  "%s: %s\n", c->log, c->cr_msg, 0 );
                         return ARG_BAD_CONF;                          return ARG_BAD_CONF;
                 }                  }
                 sl = si->si_logs;                  sl = si->si_logs;
Line 2510  syncprov_db_otask( Line 2527  syncprov_db_otask(
  */   */
 static int  static int
 syncprov_db_open(  syncprov_db_open(
     BackendDB *be          BackendDB *be,
           ConfigReply *cr
 )  )
 {  {
         slap_overinst   *on = (slap_overinst *) be->bd_info;          slap_overinst   *on = (slap_overinst *) be->bd_info;
Line 2554  syncprov_db_open( Line 2572  syncprov_db_open(
   
                 a = attr_find( e->e_attrs, slap_schema.si_ad_contextCSN );                  a = attr_find( e->e_attrs, slap_schema.si_ad_contextCSN );
                 if ( a ) {                  if ( a ) {
                         int i;  
                         ber_bvarray_dup_x( &si->si_ctxcsn, a->a_vals, NULL );                          ber_bvarray_dup_x( &si->si_ctxcsn, a->a_vals, NULL );
                         for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ );                          si->si_numcsns = a->a_numvals;
                         si->si_numcsns = i;                          si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, a->a_numvals, NULL );
                         si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, i, 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 ) {
Line 2603  out: Line 2619  out:
  */   */
 static int  static int
 syncprov_db_close(  syncprov_db_close(
     BackendDB *be          BackendDB *be,
           ConfigReply *cr
 )  )
 {  {
     slap_overinst   *on = (slap_overinst *) be->bd_info;      slap_overinst   *on = (slap_overinst *) be->bd_info;
Line 2613  syncprov_db_close( Line 2630  syncprov_db_close(
                 return 0;                  return 0;
         }          }
         if ( si->si_numops ) {          if ( si->si_numops ) {
                 Connection conn;                  Connection conn = {0};
                 OperationBuffer opbuf;                  OperationBuffer opbuf;
                 Operation *op;                  Operation *op;
                 SlapReply rs = {REP_RESULT};                  SlapReply rs = {REP_RESULT};
Line 2633  syncprov_db_close( Line 2650  syncprov_db_close(
   
 static int  static int
 syncprov_db_init(  syncprov_db_init(
         BackendDB *be          BackendDB *be,
           ConfigReply *cr
 )  )
 {  {
         slap_overinst   *on = (slap_overinst *)be->bd_info;          slap_overinst   *on = (slap_overinst *)be->bd_info;
Line 2665  syncprov_db_init( Line 2683  syncprov_db_init(
   
 static int  static int
 syncprov_db_destroy(  syncprov_db_destroy(
         BackendDB *be          BackendDB *be,
           ConfigReply *cr
 )  )
 {  {
         slap_overinst   *on = (slap_overinst *)be->bd_info;          slap_overinst   *on = (slap_overinst *)be->bd_info;
Line 2784  static int syncprov_parseCtrl ( Line 2803  static int syncprov_parseCtrl (
         sr->sr_rhint = rhint;          sr->sr_rhint = rhint;
         if (!BER_BVISNULL(&cookie)) {          if (!BER_BVISNULL(&cookie)) {
                 ber_dupbv_x( &sr->sr_state.octet_str, &cookie, op->o_tmpmemctx );                  ber_dupbv_x( &sr->sr_state.octet_str, &cookie, op->o_tmpmemctx );
                 slap_parse_sync_cookie( &sr->sr_state, op->o_tmpmemctx );                  if ( slap_parse_sync_cookie( &sr->sr_state, op->o_tmpmemctx ) ||
                 if ( sr->sr_state.rid == -1 ) {                          sr->sr_state.rid == -1 ) {
                         rs->sr_text = "Sync control : cookie parsing error";                          rs->sr_text = "Sync control : cookie parsing error";
                         return LDAP_PROTOCOL_ERROR;                          return LDAP_PROTOCOL_ERROR;
                 }                  }

Removed from v.1.188  
changed lines
  Added in v.1.202


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