Diff for /servers/slapd/overlays/syncprov.c between versions 1.56.2.22 and 1.56.2.33

version 1.56.2.22, 2005/11/15 20:25:47 version 1.56.2.33, 2006/05/27 09:01:06
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.125 2005/11/15 17:27:40 ando Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.56.2.32 2006/05/15 15:51:59 kurt 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/>.
  *   *
  * Copyright 2004-2005 The OpenLDAP Foundation.   * Copyright 2004-2006 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 450  syncprov_findbase( Operation *op, fbase_ Line 450  syncprov_findbase( Operation *op, fbase_
                 case LDAP_SCOPE_SUBTREE:                  case LDAP_SCOPE_SUBTREE:
                         fc->fscope = dnIsSuffix( fc->fdn, &fc->fss->s_base );                          fc->fscope = dnIsSuffix( fc->fdn, &fc->fss->s_base );
                         break;                          break;
 #ifdef LDAP_SCOPE_SUBORDINATE  
                 case LDAP_SCOPE_SUBORDINATE:                  case LDAP_SCOPE_SUBORDINATE:
                         fc->fscope = dnIsSuffix( fc->fdn, &fc->fss->s_base ) &&                          fc->fscope = dnIsSuffix( fc->fdn, &fc->fss->s_base ) &&
                                 !dn_match( fc->fdn, &fc->fss->s_base );                                  !dn_match( fc->fdn, &fc->fss->s_base );
                         break;                          break;
 #endif  
                 }                  }
         }          }
   
Line 510  findcsn_cb( Operation *op, SlapReply *rs Line 508  findcsn_cb( Operation *op, SlapReply *rs
 {  {
         slap_callback *sc = op->o_callback;          slap_callback *sc = op->o_callback;
   
         if ( rs->sr_type == REP_SEARCH && rs->sr_err == LDAP_SUCCESS ) {          /* We just want to know that at least one exists, so it's OK if
            * we exceed the unchecked limit.
            */
           if ( rs->sr_err == LDAP_ADMINLIMIT_EXCEEDED ||
                   (rs->sr_type == REP_SEARCH && rs->sr_err == LDAP_SUCCESS )) {
                 sc->sc_private = (void *)1;                  sc->sc_private = (void *)1;
         }          }
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
Line 583  syncprov_findcsn( Operation *op, find_cs Line 585  syncprov_findcsn( Operation *op, find_cs
 #else  #else
         AttributeAssertion eq = { NULL, BER_BVNULL };          AttributeAssertion eq = { NULL, BER_BVNULL };
 #endif  #endif
         int i, rc = LDAP_SUCCESS;  
         fpres_cookie pcookie;          fpres_cookie pcookie;
         sync_control *srs = NULL;          sync_control *srs = NULL;
         int findcsn_retry = 1;          struct slap_limits_set fc_limits;
           int i, rc = LDAP_SUCCESS, findcsn_retry = 1;
   
         if ( mode != FIND_MAXCSN ) {          if ( mode != FIND_MAXCSN ) {
                 srs = op->o_controls[slap_cids.sc_LDAPsync];                  srs = op->o_controls[slap_cids.sc_LDAPsync];
Line 637  again: Line 639  again:
                 /* 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;
                           fc_limits.lms_s_unchecked = 1;
                         fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",                          fop.ors_filterstr.bv_len = sprintf( buf, "(entryCSN<=%s)",
                                 cf.f_av_value.bv_val );                                  cf.f_av_value.bv_val );
                 }                  }
Line 817  syncprov_qplay( Operation *op, slap_over Line 821  syncprov_qplay( Operation *op, slap_over
         syncres *sr;          syncres *sr;
         Entry *e;          Entry *e;
         opcookie opc;          opcookie opc;
         int rc;          int rc = 0;
   
         opc.son = on;          opc.son = on;
         op->o_bd->bd_info = (BackendInfo *)on->on_info;          op->o_bd->bd_info = (BackendInfo *)on->on_info;
Line 893  syncprov_qtask( void *ctx, void *arg ) Line 897  syncprov_qtask( void *ctx, void *arg )
         op->o_private = NULL;          op->o_private = NULL;
         op->o_callback = NULL;          op->o_callback = NULL;
   
         syncprov_qplay( op, on, so );          (void)syncprov_qplay( op, on, so );
   
         /* decrement use count... */          /* decrement use count... */
         syncprov_free_syncop( so );          syncprov_free_syncop( so );
Line 945  syncprov_qresp( opcookie *opc, syncops * Line 949  syncprov_qresp( opcookie *opc, syncops *
                 so->s_flags |= PS_FIND_BASE;                  so->s_flags |= PS_FIND_BASE;
         }          }
         if ( so->s_flags & PS_IS_DETACHED ) {          if ( so->s_flags & PS_IS_DETACHED ) {
                   int wake=0;
                 ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );                  ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
                 if ( !so->s_qtask ) {                  if ( !so->s_qtask ) {
                         so->s_qtask = ldap_pvt_runqueue_insert( &slapd_rq, RUNQ_INTERVAL,                          so->s_qtask = ldap_pvt_runqueue_insert( &slapd_rq, RUNQ_INTERVAL,
                                 syncprov_qtask, so, "syncprov_qtask",                                  syncprov_qtask, so, "syncprov_qtask",
                                 so->s_op->o_conn->c_peer_name.bv_val );                                  so->s_op->o_conn->c_peer_name.bv_val );
                         ++so->s_inuse;                          ++so->s_inuse;
                           wake = 1;
                 } else {                  } else {
                         if (!ldap_pvt_runqueue_isrunning( &slapd_rq, so->s_qtask ) &&                          if (!ldap_pvt_runqueue_isrunning( &slapd_rq, so->s_qtask ) &&
                                 !so->s_qtask->next_sched.tv_sec ) {                                  !so->s_qtask->next_sched.tv_sec ) {
Line 958  syncprov_qresp( opcookie *opc, syncops * Line 964  syncprov_qresp( opcookie *opc, syncops *
                                 ldap_pvt_runqueue_resched( &slapd_rq, so->s_qtask, 0 );                                  ldap_pvt_runqueue_resched( &slapd_rq, so->s_qtask, 0 );
                                 so->s_qtask->interval.tv_sec = RUNQ_INTERVAL;                                  so->s_qtask->interval.tv_sec = RUNQ_INTERVAL;
                                 ++so->s_inuse;                                  ++so->s_inuse;
                                   wake = 1;
                         }                          }
                 }                  }
                 ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );                  ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
                   if ( wake )
                           slap_wake_listener();
         }          }
         ldap_pvt_thread_mutex_unlock( &so->s_mutex );          ldap_pvt_thread_mutex_unlock( &so->s_mutex );
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
Line 1046  syncprov_matchops( Operation *op, opcook Line 1055  syncprov_matchops( Operation *op, opcook
         int rc;          int rc;
         struct berval newdn;          struct berval newdn;
         int freefdn = 0;          int freefdn = 0;
           BackendDB *b0 = op->o_bd, db;
   
         fc.fdn = &op->o_req_ndn;          fc.fdn = &op->o_req_ndn;
         /* compute new DN */          /* compute new DN */
Line 1058  syncprov_matchops( Operation *op, opcook Line 1068  syncprov_matchops( Operation *op, opcook
                 freefdn = 1;                  freefdn = 1;
         }          }
         if ( op->o_tag != LDAP_REQ_ADD ) {          if ( op->o_tag != LDAP_REQ_ADD ) {
                   if ( !SLAP_ISOVERLAY( op->o_bd )) {
                           db = *op->o_bd;
                           op->o_bd = &db;
                   }
                 op->o_bd->bd_info = (BackendInfo *)on->on_info;                  op->o_bd->bd_info = (BackendInfo *)on->on_info;
                 rc = be_entry_get_rw( op, fc.fdn, NULL, NULL, 0, &e );                  rc = be_entry_get_rw( op, fc.fdn, NULL, NULL, 0, &e );
                 /* If we're sending responses now, make a copy and unlock the DB */                  /* If we're sending responses now, make a copy and unlock the DB */
Line 1067  syncprov_matchops( Operation *op, opcook Line 1081  syncprov_matchops( Operation *op, opcook
                         e = e2;                          e = e2;
                 }                  }
                 op->o_bd->bd_info = (BackendInfo *)on;                  op->o_bd->bd_info = (BackendInfo *)on;
                 if ( rc ) return;                  if ( rc ) {
                           op->o_bd = b0;
                           return;
                   }
         } else {          } else {
                 e = op->ora_e;                  e = op->ora_e;
         }          }
Line 1165  syncprov_matchops( Operation *op, opcook Line 1182  syncprov_matchops( Operation *op, opcook
         if ( freefdn ) {          if ( freefdn ) {
                 op->o_tmpfree( fc.fdn->bv_val, op->o_tmpmemctx );                  op->o_tmpfree( fc.fdn->bv_val, op->o_tmpmemctx );
         }          }
           op->o_bd = b0;
 }  }
   
 static int  static int
Line 1222  syncprov_checkpoint( Operation *op, Slap Line 1240  syncprov_checkpoint( Operation *op, Slap
         syncprov_info_t         *si = on->on_bi.bi_private;          syncprov_info_t         *si = on->on_bi.bi_private;
         Modifications mod;          Modifications mod;
         Operation opm;          Operation opm;
         SlapReply rsm;          SlapReply rsm = { 0 };
         struct berval bv[2];          struct berval bv[2];
         slap_callback cb = {0};          slap_callback cb = {0};
   
Line 1244  syncprov_checkpoint( Operation *op, Slap Line 1262  syncprov_checkpoint( Operation *op, Slap
         opm.o_req_ndn = op->o_bd->be_nsuffix[0];          opm.o_req_ndn = op->o_bd->be_nsuffix[0];
         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_managedsait = SLAP_CONTROL_NONCRITICAL;
           SLAP_DBFLAGS( opm.o_bd ) |= SLAP_DBFLAG_NOLASTMOD;
         opm.o_bd->be_modify( &opm, &rsm );          opm.o_bd->be_modify( &opm, &rsm );
           SLAP_DBFLAGS( opm.o_bd ) ^= SLAP_DBFLAG_NOLASTMOD;
         if ( mod.sml_next != NULL ) {          if ( mod.sml_next != NULL ) {
                 slap_mods_free( mod.sml_next, 1 );                  slap_mods_free( mod.sml_next, 1 );
         }          }
Line 1267  syncprov_add_slog( Operation *op, struct Line 1287  syncprov_add_slog( Operation *op, struct
                 se->se_next = NULL;                  se->se_next = NULL;
                 se->se_tag = op->o_tag;                  se->se_tag = op->o_tag;
   
                 se->se_uuid.bv_val = (char *)(se+1);                  se->se_uuid.bv_val = (char *)(&se[1]);
                 AC_MEMCPY( se->se_uuid.bv_val, opc->suuid.bv_val, opc->suuid.bv_len );                  AC_MEMCPY( se->se_uuid.bv_val, opc->suuid.bv_val, opc->suuid.bv_len );
                 se->se_uuid.bv_len = opc->suuid.bv_len;                  se->se_uuid.bv_len = opc->suuid.bv_len;
   
Line 1291  syncprov_add_slog( Operation *op, struct Line 1311  syncprov_add_slog( Operation *op, struct
                         sl->sl_mincsn.bv_len = se->se_csn.bv_len;                          sl->sl_mincsn.bv_len = se->se_csn.bv_len;
                         ch_free( se );                          ch_free( se );
                         sl->sl_num--;                          sl->sl_num--;
                         if ( !sl->sl_head ) {  
                                 sl->sl_tail = NULL;  
                         }  
                 }                  }
                 ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );                  ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );
         }          }
Line 1312  playlog_cb( Operation *op, SlapReply *rs Line 1329  playlog_cb( Operation *op, SlapReply *rs
 /* enter with sl->sl_mutex locked, release before returning */  /* enter with sl->sl_mutex locked, release before returning */
 static void  static void
 syncprov_playlog( Operation *op, SlapReply *rs, sessionlog *sl,  syncprov_playlog( Operation *op, SlapReply *rs, sessionlog *sl,
         struct berval *oldcsn, struct berval *ctxcsn )          sync_control *srs, struct berval *ctxcsn )
 {  {
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
         slog_entry *se;          slog_entry *se;
         int i, j, ndel, num, nmods, mmods;          int i, j, ndel, num, nmods, mmods;
           char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
         BerVarray uuids;          BerVarray uuids;
           struct berval delcsn;
   
         if ( !sl->sl_num ) {          if ( !sl->sl_num ) {
                 ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );                  ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );
Line 1330  syncprov_playlog( Operation *op, SlapRep Line 1349  syncprov_playlog( Operation *op, SlapRep
   
         uuids = op->o_tmpalloc( (num+1) * sizeof( struct berval ) +          uuids = op->o_tmpalloc( (num+1) * sizeof( struct berval ) +
                 num * UUID_LEN, op->o_tmpmemctx );                  num * UUID_LEN, op->o_tmpmemctx );
   
         uuids[0].bv_val = (char *)(uuids + num + 1);          uuids[0].bv_val = (char *)(uuids + num + 1);
   
           delcsn.bv_len = 0;
           delcsn.bv_val = cbuf;
   
         /* Make a copy of the relevant UUIDs. Put the Deletes up front          /* Make a copy of the relevant UUIDs. Put the Deletes up front
          * and everything else at the end. Do this first so we can           * and everything else at the end. Do this first so we can
          * unlock the list mutex.           * unlock the list mutex.
          */           */
         for ( se=sl->sl_head; se; se=se->se_next ) {          for ( se=sl->sl_head; se; se=se->se_next ) {
                 if ( ber_bvcmp( &se->se_csn, oldcsn ) < 0 ) continue;                  if ( ber_bvcmp( &se->se_csn, &srs->sr_state.ctxcsn ) <= 0 ) continue;
                 if ( ber_bvcmp( &se->se_csn, ctxcsn ) > 0 ) break;                  if ( ber_bvcmp( &se->se_csn, ctxcsn ) > 0 ) break;
                 if ( se->se_tag == LDAP_REQ_DELETE ) {                  if ( se->se_tag == LDAP_REQ_DELETE ) {
                         j = i;                          j = i;
                         i++;                          i++;
                           AC_MEMCPY( cbuf, se->se_csn.bv_val, se->se_csn.bv_len );
                           delcsn.bv_len = se->se_csn.bv_len;
                 } else {                  } else {
                         nmods++;                          nmods++;
                         j = num - nmods;                          j = num - nmods;
Line 1423  syncprov_playlog( Operation *op, SlapRep Line 1446  syncprov_playlog( Operation *op, SlapRep
                         mf.f_av_value = uuids[i];                          mf.f_av_value = uuids[i];
                         cb.sc_private = NULL;                          cb.sc_private = NULL;
                         fop.ors_slimit = 1;                          fop.ors_slimit = 1;
                           frs.sr_nentries = 0;
                         rc = fop.o_bd->be_search( &fop, &frs );                          rc = fop.o_bd->be_search( &fop, &frs );
   
                         /* If entry was not found, add to delete list */                          /* If entry was not found, add to delete list */
Line 1433  syncprov_playlog( Operation *op, SlapRep Line 1457  syncprov_playlog( Operation *op, SlapRep
                 fop.o_bd->bd_info = (BackendInfo *)on;                  fop.o_bd->bd_info = (BackendInfo *)on;
         }          }
         if ( ndel ) {          if ( ndel ) {
                   struct berval cookie;
   
                   slap_compose_sync_cookie( op, &cookie, &delcsn, srs->sr_state.rid );
                 uuids[ndel].bv_val = NULL;                  uuids[ndel].bv_val = NULL;
                 syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL, 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( uuids, op->o_tmpmemctx );
 }  }
   
 static int  static int
Line 1750  syncprov_detach_op( Operation *op, synco Line 1779  syncprov_detach_op( Operation *op, synco
         op2->ors_filterstr.bv_val = ptr;          op2->ors_filterstr.bv_val = ptr;
         strcpy( ptr, so->s_filterstr.bv_val );          strcpy( ptr, so->s_filterstr.bv_val );
         op2->ors_filterstr.bv_len = so->s_filterstr.bv_len;          op2->ors_filterstr.bv_len = so->s_filterstr.bv_len;
         op2->ors_filter = str2filter( ptr );          op2->ors_filter = filter_dup( op->ors_filter, NULL );
         so->s_op = op2;          so->s_op = op2;
   
         /* Copy any cached group ACLs individually */          /* Copy any cached group ACLs individually */
Line 1772  syncprov_detach_op( Operation *op, synco Line 1801  syncprov_detach_op( Operation *op, synco
         LDAP_STAILQ_INSERT_TAIL( &op->o_conn->c_ops, op2, o_next );          LDAP_STAILQ_INSERT_TAIL( &op->o_conn->c_ops, op2, o_next );
         so->s_flags |= PS_IS_DETACHED;          so->s_flags |= PS_IS_DETACHED;
         ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex );          ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex );
   
           /* Prevent anyone else from trying to send a result for this op */
           op->o_abandon = 1;
 }  }
   
 static int  static int
Line 1794  syncprov_search_response( Operation *op, Line 1826  syncprov_search_response( Operation *op,
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
                 a = attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_entryCSN );                  a = attr_find( rs->sr_entry->e_attrs, slap_schema.si_ad_entryCSN );
                   if ( a == NULL && rs->sr_operational_attrs != NULL ) {
                           a = attr_find( rs->sr_operational_attrs, slap_schema.si_ad_entryCSN );
                   }
                 if ( a ) {                  if ( a ) {
                         /* Make sure entry is less than the snaphot'd contextCSN */                          /* Make sure entry is less than the snapshot'd contextCSN */
                         if ( ber_bvcmp( &a->a_nvals[0], &ss->ss_ctxcsn ) > 0 )                          if ( ber_bvcmp( &a->a_nvals[0], &ss->ss_ctxcsn ) > 0 ) {
                                   Debug( LDAP_DEBUG_SYNC, "Entry %s CSN %s greater than snapshot %s\n",
                                           rs->sr_entry->e_name.bv_val,
                                           a->a_nvals[0].bv_val,
                                           ss->ss_ctxcsn.bv_val );
                                 return LDAP_SUCCESS;                                  return LDAP_SUCCESS;
                           }
   
                         /* Don't send the ctx entry twice */                          /* Don't send the ctx entry twice */
                         if ( !BER_BVISNULL( &srs->sr_state.ctxcsn ) &&                          if ( !BER_BVISNULL( &srs->sr_state.ctxcsn ) &&
                                 bvmatch( &a->a_nvals[0], &srs->sr_state.ctxcsn ) )                                  bvmatch( &a->a_nvals[0], &srs->sr_state.ctxcsn ) ) {
                                   Debug( LDAP_DEBUG_SYNC, "Entry %s CSN %s matches ctx %s\n",
                                           rs->sr_entry->e_name.bv_val,
                                           a->a_nvals[0].bv_val,
                                           srs->sr_state.ctxcsn.bv_val );
                                 return LDAP_SUCCESS;                                  return LDAP_SUCCESS;
                           }
                 }                  }
                 rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,                  rs->sr_ctrls = op->o_tmpalloc( sizeof(LDAPControl *)*2,
                         op->o_tmpmemctx );                          op->o_tmpmemctx );
Line 1887  syncprov_op_search( Operation *op, SlapR Line 1932  syncprov_op_search( Operation *op, SlapR
                 /* syncprov_findbase expects to be called as a callback... */                  /* syncprov_findbase expects to be called as a callback... */
                 sc.sc_private = &opc;                  sc.sc_private = &opc;
                 opc.son = on;                  opc.son = on;
                   ldap_pvt_thread_mutex_init( &so.s_mutex );
                 cb = op->o_callback;                  cb = op->o_callback;
                 op->o_callback = &sc;                  op->o_callback = &sc;
                 rs->sr_err = syncprov_findbase( op, &fc );                  rs->sr_err = syncprov_findbase( op, &fc );
                 op->o_callback = cb;                  op->o_callback = cb;
                   ldap_pvt_thread_mutex_destroy( &so.s_mutex );
   
                 if ( rs->sr_err != LDAP_SUCCESS ) {                  if ( rs->sr_err != LDAP_SUCCESS ) {
                         send_ldap_result( op, rs );                          send_ldap_result( op, rs );
Line 1946  syncprov_op_search( Operation *op, SlapR Line 1993  syncprov_op_search( Operation *op, SlapR
                         if ( ber_bvcmp( &srs->sr_state.ctxcsn, &sl->sl_mincsn ) >= 0 ) {                          if ( ber_bvcmp( &srs->sr_state.ctxcsn, &sl->sl_mincsn ) >= 0 ) {
                                 do_present = 0;                                  do_present = 0;
                                 /* mutex is unlocked in playlog */                                  /* mutex is unlocked in playlog */
                                 syncprov_playlog( op, rs, sl, &srs->sr_state.ctxcsn, &ctxcsn );                                  syncprov_playlog( op, rs, sl, srs, &ctxcsn );
                         } else {                          } else {
                                 ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );                                  ldap_pvt_thread_mutex_unlock( &sl->sl_mutex );
                         }                          }
Line 2187  sp_cf_gen(ConfigArgs *c) Line 2234  sp_cf_gen(ConfigArgs *c)
         }          }
         switch ( c->type ) {          switch ( c->type ) {
         case SP_CHKPT:          case SP_CHKPT:
                 si->si_chkops = atoi( c->argv[1] );                  if ( lutil_atoi( &si->si_chkops, c->argv[1] ) != 0 ) {
                 si->si_chktime = atoi( c->argv[2] ) * 60;                          sprintf( c->msg, "%s unable to parse checkpoint ops # \"%s\"",
                                   c->argv[0], c->argv[1] );
                           Debug( LDAP_DEBUG_CONFIG, "%s: %s\n", c->log, c->msg, 0 );
                           return ARG_BAD_CONF;
                   }
                   if ( si->si_chkops <= 0 ) {
                           sprintf( c->msg, "%s invalid checkpoint ops # \"%d\"",
                                   c->argv[0], si->si_chkops );
                           Debug( LDAP_DEBUG_CONFIG, "%s: %s\n", c->log, c->msg, 0 );
                           return ARG_BAD_CONF;
                   }
                   if ( lutil_atoi( &si->si_chktime, c->argv[2] ) != 0 ) {
                           sprintf( c->msg, "%s unable to parse checkpoint time \"%s\"",
                                   c->argv[0], c->argv[1] );
                           Debug( LDAP_DEBUG_CONFIG, "%s: %s\n", c->log, c->msg, 0 );
                           return ARG_BAD_CONF;
                   }
                   if ( si->si_chktime <= 0 ) {
                           sprintf( c->msg, "%s invalid checkpoint time \"%d\"",
                                   c->argv[0], si->si_chkops );
                           Debug( LDAP_DEBUG_CONFIG, "%s: %s\n", c->log, c->msg, 0 );
                           return ARG_BAD_CONF;
                   }
                   si->si_chktime *= 60;
                 break;                  break;
         case SP_SESSL: {          case SP_SESSL: {
                 sessionlog *sl;                  sessionlog *sl;
Line 2247  syncprov_db_open( Line 2317  syncprov_db_open(
         slap_overinst   *on = (slap_overinst *) be->bd_info;          slap_overinst   *on = (slap_overinst *) be->bd_info;
         syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;          syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;
   
         Connection conn;          Connection conn = { 0 };
         OperationBuffer opbuf;          OperationBuffer opbuf = { 0 };
         char ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];          char ctxcsnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
         Operation *op = (Operation *) &opbuf;          Operation *op = (Operation *) &opbuf;
         Entry *e;          Entry *e;
Line 2291  syncprov_db_open( Line 2361  syncprov_db_open(
                         strcpy( ctxcsnbuf, si->si_ctxcsnbuf );                          strcpy( ctxcsnbuf, si->si_ctxcsnbuf );
                 }                  }
                 be_entry_release_rw( op, e, 0 );                  be_entry_release_rw( op, e, 0 );
                 op->o_bd->bd_info = (BackendInfo *)on;                  if ( !BER_BVISEMPTY( &si->si_ctxcsn ) ) {
                 op->o_req_dn = be->be_suffix[0];                          op->o_bd->bd_info = (BackendInfo *)on;
                 op->o_req_ndn = be->be_nsuffix[0];                          op->o_req_dn = be->be_suffix[0];
                 op->ors_scope = LDAP_SCOPE_SUBTREE;                          op->o_req_ndn = be->be_nsuffix[0];
                 ldap_pvt_thread_create( &tid, 0, syncprov_db_otask, op );                          op->ors_scope = LDAP_SCOPE_SUBTREE;
                 ldap_pvt_thread_join( tid, NULL );                          ldap_pvt_thread_create( &tid, 0, syncprov_db_otask, op );
                           ldap_pvt_thread_join( tid, NULL );
                   }
         } else if ( SLAP_SYNC_SHADOW( op->o_bd )) {          } else if ( SLAP_SYNC_SHADOW( op->o_bd )) {
                 /* If we're also a consumer, and we didn't find the context entry,                  /* 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                   * then don't generate anything, wait for our provider to send it
Line 2390  syncprov_db_destroy( Line 2462  syncprov_db_destroy(
         syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;          syncprov_info_t *si = (syncprov_info_t *)on->on_bi.bi_private;
   
         if ( si ) {          if ( si ) {
                   if ( si->si_logs ) {
                           slog_entry *se = si->si_logs->sl_head;
   
                           while ( se ) {
                                   slog_entry *se_next = se->se_next;
                                   ch_free( se );
                                   se = se_next;
                           }
                                   
                           ch_free( si->si_logs );
                   }
                 ldap_pvt_thread_mutex_destroy( &si->si_mods_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_mods_mutex );
                 ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );
                 ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );
Line 2508  static int syncprov_parseCtrl ( Line 2591  static int syncprov_parseCtrl (
 static slap_overinst            syncprov;  static slap_overinst            syncprov;
   
 int  int
 syncprov_init()  syncprov_initialize()
 {  {
         int rc;          int rc;
   
         rc = register_supported_control( LDAP_CONTROL_SYNC,          rc = register_supported_control( LDAP_CONTROL_SYNC,
                 SLAP_CTRL_HIDE|SLAP_CTRL_SEARCH, NULL,                  SLAP_CTRL_SEARCH, NULL,
                 syncprov_parseCtrl, &slap_cids.sc_LDAPsync );                  syncprov_parseCtrl, &slap_cids.sc_LDAPsync );
         if ( rc != LDAP_SUCCESS ) {          if ( rc != LDAP_SUCCESS ) {
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
Line 2553  syncprov_init() Line 2636  syncprov_init()
 int  int
 init_module( int argc, char *argv[] )  init_module( int argc, char *argv[] )
 {  {
         return syncprov_init();          return syncprov_initialize();
 }  }
 #endif /* SLAPD_OVER_SYNCPROV == SLAPD_MOD_DYNAMIC */  #endif /* SLAPD_OVER_SYNCPROV == SLAPD_MOD_DYNAMIC */
   

Removed from v.1.56.2.22  
changed lines
  Added in v.1.56.2.33


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