Diff for /servers/slapd/overlays/syncprov.c between versions 1.56.2.28 and 1.117

version 1.56.2.28, 2006/02/13 18:33:45 version 1.117, 2005/10/12 21:17:30
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.144 2006/01/23 21:23:00 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.116 2005/10/06 22:31:38 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/>.
  *   *
  * Copyright 2004-2006 The OpenLDAP Foundation.   * Copyright 2004-2005 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 122  typedef struct syncprov_info_t { Line 122  typedef struct syncprov_info_t {
         int             si_chktime;          int             si_chktime;
         int             si_numops;      /* number of ops since last checkpoint */          int             si_numops;      /* number of ops since last checkpoint */
         int             si_nopres;      /* Skip present phase */          int             si_nopres;      /* Skip present phase */
         int             si_usehint;     /* use reload hint */  
         time_t  si_chklast;     /* time of last checkpoint */          time_t  si_chklast;     /* time of last checkpoint */
         Avlnode *si_mods;       /* entries being modified */          Avlnode *si_mods;       /* entries being modified */
         sessionlog      *si_logs;          sessionlog      *si_logs;
Line 383  findbase_cb( Operation *op, SlapReply *r Line 382  findbase_cb( Operation *op, SlapReply *r
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
 static Filter generic_filter = { LDAP_FILTER_PRESENT, { 0 }, NULL };  
 static struct berval generic_filterstr = BER_BVC("(objectclass=*)");  
   
 static int  static int
 syncprov_findbase( Operation *op, fbase_cookie *fc )  syncprov_findbase( Operation *op, fbase_cookie *fc )
 {  {
Line 425  syncprov_findbase( Operation *op, fbase_ Line 421  syncprov_findbase( Operation *op, fbase_
                 fop.ors_tlimit = SLAP_NO_LIMIT;                  fop.ors_tlimit = SLAP_NO_LIMIT;
                 fop.ors_attrs = slap_anlist_no_attrs;                  fop.ors_attrs = slap_anlist_no_attrs;
                 fop.ors_attrsonly = 1;                  fop.ors_attrsonly = 1;
                 fop.ors_filter = &generic_filter;  
                 fop.ors_filterstr = generic_filterstr;  
   
                 fop.o_bd->bd_info = on->on_info->oi_orig;                  fop.o_bd->bd_info = on->on_info->oi_orig;
                 rc = fop.o_bd->be_search( &fop, &frs );                  rc = fop.o_bd->be_search( &fop, &frs );
Line 450  syncprov_findbase( Operation *op, fbase_ Line 444  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 481  syncprov_findbase( Operation *op, fbase_ Line 477  syncprov_findbase( Operation *op, fbase_
  * CSN, and generate Present records for them. We always collect this result   * CSN, and generate Present records for them. We always collect this result
  * in SyncID sets, even if there's only one match.   * in SyncID sets, even if there's only one match.
  */   */
 typedef enum find_csn_t {  #define FIND_MAXCSN     1
         FIND_MAXCSN     = 1,  #define FIND_CSN        2
         FIND_CSN        = 2,  #define FIND_PRESENT    3
         FIND_PRESENT    = 3  
 } find_csn_t;  
   
 static int  static int
 findmax_cb( Operation *op, SlapReply *rs )  findmax_cb( Operation *op, SlapReply *rs )
Line 508  findcsn_cb( Operation *op, SlapReply *rs Line 502  findcsn_cb( Operation *op, SlapReply *rs
 {  {
         slap_callback *sc = op->o_callback;          slap_callback *sc = op->o_callback;
   
         /* We just want to know that at least one exists, so it's OK if          if ( rs->sr_type == REP_SEARCH && rs->sr_err == LDAP_SUCCESS ) {
          * 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 568  findpres_cb( Operation *op, SlapReply *r Line 558  findpres_cb( Operation *op, SlapReply *r
 }  }
   
 static int  static int
 syncprov_findcsn( Operation *op, find_csn_t mode )  syncprov_findcsn( Operation *op, int mode )
 {  {
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
         syncprov_info_t         *si = on->on_bi.bi_private;          syncprov_info_t         *si = on->on_bi.bi_private;
Line 585  syncprov_findcsn( Operation *op, find_cs Line 575  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;
         struct slap_limits_set fc_limits;          int findcsn_retry = 1;
         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 639  again: Line 629  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 740  syncprov_free_syncop( syncops *so ) Line 728  syncprov_free_syncop( syncops *so )
   
 /* Send a persistent search response */  /* Send a persistent search response */
 static int  static int
 syncprov_sendresp( Operation *op, opcookie *opc, syncops *so,  syncprov_sendresp( Operation *op, opcookie *opc, syncops *so, Entry **e, int mode)
         Entry **e, int mode )  
 {  {
         slap_overinst *on = opc->son;          slap_overinst *on = opc->son;
   
Line 821  syncprov_qplay( Operation *op, slap_over Line 808  syncprov_qplay( Operation *op, slap_over
         syncres *sr;          syncres *sr;
         Entry *e;          Entry *e;
         opcookie opc;          opcookie opc;
         int rc = 0;          int rc;
   
         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 897  syncprov_qtask( void *ctx, void *arg ) Line 884  syncprov_qtask( void *ctx, void *arg )
         op->o_private = NULL;          op->o_private = NULL;
         op->o_callback = NULL;          op->o_callback = NULL;
   
         (void)syncprov_qplay( op, on, so );          syncprov_qplay( op, on, so );
   
         /* decrement use count... */          /* decrement use count... */
         syncprov_free_syncop( so );          syncprov_free_syncop( so );
Line 949  syncprov_qresp( opcookie *opc, syncops * Line 936  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 964  syncprov_qresp( opcookie *opc, syncops * Line 949  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 1231  syncprov_checkpoint( Operation *op, Slap Line 1213  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 = { 0 };  
         struct berval bv[2];          struct berval bv[2];
         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 1253  syncprov_checkpoint( Operation *op, Slap Line 1235  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, rs );
         opm.o_bd->be_modify( &opm, &rsm );          opm.o_managedsait = manage;
         SLAP_DBFLAGS( opm.o_bd ) ^= SLAP_DBFLAG_NOLASTMOD;  
         if ( mod.sml_next != NULL ) {  
                 slap_mods_free( mod.sml_next, 1 );  
         }  
 }  }
   
 static void  static void
Line 1278  syncprov_add_slog( Operation *op, struct Line 1256  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 1434  syncprov_playlog( Operation *op, SlapRep Line 1412  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 1762  syncprov_detach_op( Operation *op, synco Line 1739  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 = filter_dup( op->ors_filter, NULL );          op2->ors_filter = str2filter( ptr );
         so->s_op = op2;          so->s_op = op2;
   
         /* Copy any cached group ACLs individually */          /* Copy any cached group ACLs individually */
Line 1806  syncprov_search_response( Operation *op, Line 1783  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 snapshot'd contextCSN */                          /* Make sure entry is less than the snaphot'd contextCSN */
                         if ( ber_bvcmp( &a->a_nvals[0], &ss->ss_ctxcsn ) > 0 )                          if ( ber_bvcmp( &a->a_nvals[0], &ss->ss_ctxcsn ) > 0 )
                                 return LDAP_SUCCESS;                                  return LDAP_SUCCESS;
   
Line 1969  syncprov_op_search( Operation *op, SlapR Line 1943  syncprov_op_search( Operation *op, SlapR
                 /* Is the CSN still present in the database? */                  /* Is the CSN still present in the database? */
                 if ( syncprov_findcsn( op, FIND_CSN ) != LDAP_SUCCESS ) {                  if ( syncprov_findcsn( op, FIND_CSN ) != LDAP_SUCCESS ) {
                         /* No, so a reload is required */                          /* No, so a reload is required */
                         /* the 2.2 consumer doesn't send this hint */  #if 0           /* the consumer doesn't seem to send this hint */
                         if ( si->si_usehint && srs->sr_rhint == 0 ) {                          if ( op->o_sync_rhint == 0 ) {
                                 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;
                         }                          }
   #endif
                 } 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 2094  syncprov_operational( Line 2069  syncprov_operational(
 enum {  enum {
         SP_CHKPT = 1,          SP_CHKPT = 1,
         SP_SESSL,          SP_SESSL,
         SP_NOPRES,          SP_NOPRES
         SP_USEHINT  
 };  };
   
 static ConfigDriver sp_cf_gen;  static ConfigDriver sp_cf_gen;
Line 2113  static ConfigTable spcfg[] = { Line 2087  static ConfigTable spcfg[] = {
                 sp_cf_gen, "( OLcfgOvAt:1.3 NAME 'olcSpNoPresent' "                  sp_cf_gen, "( OLcfgOvAt:1.3 NAME 'olcSpNoPresent' "
                         "DESC 'Omit Present phase processing' "                          "DESC 'Omit Present phase processing' "
                         "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL },                          "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL },
         { "syncprov-reloadhint", NULL, 2, 2, 0, ARG_ON_OFF|ARG_MAGIC|SP_USEHINT,  
                 sp_cf_gen, "( OLcfgOvAt:1.4 NAME 'olcSpReloadHint' "  
                         "DESC 'Observe Reload Hint in Request control' "  
                         "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL },  
         { NULL, NULL, 0, 0, 0, ARG_IGNORED }          { NULL, NULL, 0, 0, 0, ARG_IGNORED }
 };  };
   
Line 2164  sp_cf_gen(ConfigArgs *c) Line 2134  sp_cf_gen(ConfigArgs *c)
                                 rc = 1;                                  rc = 1;
                         }                          }
                         break;                          break;
                 case SP_USEHINT:  
                         if ( si->si_usehint ) {  
                                 c->value_int = 1;  
                         } else {  
                                 rc = 1;  
                         }  
                         break;  
                 }                  }
                 return rc;                  return rc;
         } else if ( c->op == LDAP_MOD_DELETE ) {          } else if ( c->op == LDAP_MOD_DELETE ) {
Line 2191  sp_cf_gen(ConfigArgs *c) Line 2154  sp_cf_gen(ConfigArgs *c)
                         else                          else
                                 rc = LDAP_NO_SUCH_ATTRIBUTE;                                  rc = LDAP_NO_SUCH_ATTRIBUTE;
                         break;                          break;
                 case SP_USEHINT:  
                         if ( si->si_usehint )  
                                 si->si_usehint = 0;  
                         else  
                                 rc = LDAP_NO_SUCH_ATTRIBUTE;  
                         break;  
                 }                  }
                 return rc;                  return rc;
         }          }
         switch ( c->type ) {          switch ( c->type ) {
         case SP_CHKPT:          case SP_CHKPT:
                 if ( lutil_atoi( &si->si_chkops, c->argv[1] ) != 0 ) {                  si->si_chkops = atoi( c->argv[1] );
                         sprintf( c->msg, "%s unable to parse checkpoint ops # \"%s\"",                  si->si_chktime = atoi( c->argv[2] ) * 60;
                                 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 2254  sp_cf_gen(ConfigArgs *c) Line 2188  sp_cf_gen(ConfigArgs *c)
         case SP_NOPRES:          case SP_NOPRES:
                 si->si_nopres = c->value_int;                  si->si_nopres = c->value_int;
                 break;                  break;
         case SP_USEHINT:  
                 si->si_usehint = c->value_int;  
                 break;  
         }          }
         return rc;          return rc;
 }  }
Line 2285  syncprov_db_open( Line 2216  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 = { 0 };          Connection conn;
         OperationBuffer opbuf = { 0 };          OperationBuffer opbuf;
         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 2329  syncprov_db_open( Line 2260  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 );
                 if ( !BER_BVISEMPTY( &si->si_ctxcsn ) ) {                  op->o_bd->bd_info = (BackendInfo *)on;
                         op->o_bd->bd_info = (BackendInfo *)on;                  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;                  ldap_pvt_thread_create( &tid, 0, syncprov_db_otask, op );
                         ldap_pvt_thread_create( &tid, 0, syncprov_db_otask, op );                  ldap_pvt_thread_join( tid, NULL );
                         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 2346  syncprov_db_open( Line 2275  syncprov_db_open(
         }          }
   
         if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {          if ( BER_BVISEMPTY( &si->si_ctxcsn ) ) {
                 si->si_ctxcsn.bv_len = sizeof( si->si_ctxcsnbuf );                  slap_get_csn( op, si->si_ctxcsnbuf, sizeof(si->si_ctxcsnbuf),
                 slap_get_csn( op, &si->si_ctxcsn, 0 );                                  &si->si_ctxcsn, 0 );
         }          }
   
         /* If our ctxcsn is different from what was read from the root          /* If our ctxcsn is different from what was read from the root
Line 2430  syncprov_db_destroy( Line 2359  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 2517  static int syncprov_parseCtrl ( Line 2435  static int syncprov_parseCtrl (
                         rs->sr_text = "Sync control : cookie decoding error";                          rs->sr_text = "Sync control : cookie decoding error";
                         return LDAP_PROTOCOL_ERROR;                          return LDAP_PROTOCOL_ERROR;
                 }                  }
                 tag = ber_peek_tag( ber, &len );  
         }          }
         if ( tag == LDAP_TAG_RELOAD_HINT ) {          if ( tag == LDAP_TAG_RELOAD_HINT ) {
                 if (( ber_scanf( ber, /*{*/ "b", &rhint )) == LBER_ERROR ) {                  if (( ber_scanf( ber, /*{*/ "b", &rhint )) == LBER_ERROR ) {
Line 2559  static int syncprov_parseCtrl ( Line 2476  static int syncprov_parseCtrl (
 static slap_overinst            syncprov;  static slap_overinst            syncprov;
   
 int  int
 syncprov_initialize()  syncprov_init()
 {  {
         int rc;          int rc;
   
         rc = register_supported_control( LDAP_CONTROL_SYNC,          rc = register_supported_control( LDAP_CONTROL_SYNC,
                 SLAP_CTRL_SEARCH, NULL,                  SLAP_CTRL_HIDE|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 2592  syncprov_initialize() Line 2509  syncprov_initialize()
   
         syncprov.on_bi.bi_cf_ocs = spocs;          syncprov.on_bi.bi_cf_ocs = spocs;
   
         generic_filter.f_desc = slap_schema.si_ad_objectClass;  
   
         rc = config_register_schema( spcfg, spocs );          rc = config_register_schema( spcfg, spocs );
         if ( rc ) return rc;          if ( rc ) return rc;
   
Line 2604  syncprov_initialize() Line 2519  syncprov_initialize()
 int  int
 init_module( int argc, char *argv[] )  init_module( int argc, char *argv[] )
 {  {
         return syncprov_initialize();          return syncprov_init();
 }  }
 #endif /* SLAPD_OVER_SYNCPROV == SLAPD_MOD_DYNAMIC */  #endif /* SLAPD_OVER_SYNCPROV == SLAPD_MOD_DYNAMIC */
   

Removed from v.1.56.2.28  
changed lines
  Added in v.1.117


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