Diff for /servers/slapd/overlays/syncprov.c between versions 1.21 and 1.23

version 1.21, 2004/11/27 06:05:24 version 1.23, 2004/11/27 06:47:24
Line 38  typedef struct modtarget { Line 38  typedef struct modtarget {
         ldap_pvt_thread_mutex_t mt_mutex;          ldap_pvt_thread_mutex_t mt_mutex;
 } modtarget;  } modtarget;
   
           
   
 /* A queued result of a persistent search */  /* A queued result of a persistent search */
 typedef struct syncres {  typedef struct syncres {
         struct syncres *s_next;          struct syncres *s_next;
Line 92  typedef struct syncmatches { Line 90  typedef struct syncmatches {
         syncops *sm_op;          syncops *sm_op;
 } syncmatches;  } syncmatches;
   
   /* The main state for this overlay */
 typedef struct syncprov_info_t {  typedef struct syncprov_info_t {
         syncops         *si_ops;          syncops         *si_ops;
         struct berval   si_ctxcsn;      /* ldapsync context */          struct berval   si_ctxcsn;      /* ldapsync context */
Line 123  typedef struct fbase_cookie { Line 122  typedef struct fbase_cookie {
 static AttributeName csn_anlist[2];  static AttributeName csn_anlist[2];
 static AttributeName uuid_anlist[2];  static AttributeName uuid_anlist[2];
   
   /* Build a LDAPsync intermediate state control */
 static int  static int
 syncprov_state_ctrl(  syncprov_state_ctrl(
         Operation       *op,          Operation       *op,
Line 182  syncprov_state_ctrl( Line 182  syncprov_state_ctrl(
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
   /* Build a LDAPsync final state control */
 static int  static int
 syncprov_done_ctrl(  syncprov_done_ctrl(
         Operation       *op,          Operation       *op,
Line 227  syncprov_done_ctrl( Line 228  syncprov_done_ctrl(
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
   #if 0
   /* Generate state based on session log - not implemented yet */
 static int  static int
 syncprov_state_ctrl_from_slog(  syncprov_state_ctrl_from_slog(
         Operation       *op,          Operation       *op,
Line 280  syncprov_state_ctrl_from_slog( Line 282  syncprov_state_ctrl_from_slog(
   
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   #endif
   
 static int  static int
 syncprov_sendinfo(  syncprov_sendinfo(
Line 345  syncprov_sendinfo( Line 348  syncprov_sendinfo(
                 return ret;                  return ret;
         }          }
   
           rs->sr_rspoid = LDAP_SYNC_INFO;
         rs->sr_rspdata = &rspdata;          rs->sr_rspdata = &rspdata;
         send_ldap_intermediate( op, rs );          send_ldap_intermediate( op, rs );
         rs->sr_rspdata = NULL;          rs->sr_rspdata = NULL;
Line 353  syncprov_sendinfo( Line 357  syncprov_sendinfo(
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
   /* Find a modtarget in an AVL tree */
 static int  static int
 sp_avl_cmp( const void *c1, const void *c2 )  sp_avl_cmp( const void *c1, const void *c2 )
 {  {
Line 545  findpres_cb( Operation *op, SlapReply *r Line 550  findpres_cb( Operation *op, SlapReply *r
                         pc->num++;                          pc->num++;
                         ret = LDAP_SUCCESS;                          ret = LDAP_SUCCESS;
                         if ( pc->num == SLAP_SYNCUUID_SET_SIZE ) {                          if ( pc->num == SLAP_SYNCUUID_SET_SIZE ) {
                                 rs->sr_rspoid = LDAP_SYNC_INFO;  
                                 ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,                                  ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,
                                         0, pc->uuids, 0 );                                          0, pc->uuids, 0 );
                                 ber_bvarray_free_x( pc->uuids, op->o_tmpmemctx );                                  ber_bvarray_free_x( pc->uuids, op->o_tmpmemctx );
Line 558  findpres_cb( Operation *op, SlapReply *r Line 562  findpres_cb( Operation *op, SlapReply *r
         } else if ( rs->sr_type == REP_RESULT ) {          } else if ( rs->sr_type == REP_RESULT ) {
                 ret = rs->sr_err;                  ret = rs->sr_err;
                 if ( pc->num ) {                  if ( pc->num ) {
                         rs->sr_rspoid = LDAP_SYNC_INFO;  
                         ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,                          ret = syncprov_sendinfo( op, rs, LDAP_TAG_SYNC_ID_SET, NULL,
                                 0, pc->uuids, 0 );                                  0, pc->uuids, 0 );
                         ber_bvarray_free_x( pc->uuids, op->o_tmpmemctx );                          ber_bvarray_free_x( pc->uuids, op->o_tmpmemctx );
Line 778  syncprov_sendresp( Operation *op, opcook Line 781  syncprov_sendresp( Operation *op, opcook
 }  }
   
 static void  static void
   syncprov_free_syncop( syncops *so )
   {
           syncres *sr, *srnext;
   
           ldap_pvt_thread_mutex_lock( &so->s_mutex );
           so->s_inuse--;
           if ( so->s_inuse > 0 ) {
                   ldap_pvt_thread_mutex_unlock( &so->s_mutex );
                   return;
           }
           ldap_pvt_thread_mutex_unlock( &so->s_mutex );
           filter_free( so->s_op->ors_filter );
           ch_free( so->s_op );
           ch_free( so->s_base.bv_val );
           for ( sr=so->s_res; sr; sr=srnext ) {
                   srnext = sr->s_next;
                   ch_free( sr );
           }
           ldap_pvt_thread_mutex_destroy( &so->s_mutex );
           ch_free( so );
   }
   
   static int
   syncprov_drop_psearch( syncops *so )
   {
           ldap_pvt_thread_mutex_lock( &so->s_op->o_conn->c_mutex );
           so->s_op->o_conn->c_n_ops_executing--;
           so->s_op->o_conn->c_n_ops_completed++;
           ldap_pvt_thread_mutex_unlock( &so->s_op->o_conn->c_mutex );
           syncprov_free_syncop( so );
   }
   
   static int
   syncprov_op_abandon( Operation *op, SlapReply *rs )
   {
           slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;
           syncprov_info_t         *si = on->on_bi.bi_private;
           syncops *so, *soprev;
   
           ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
           for ( so=si->si_ops, soprev = (syncops *)&si->si_ops; so;
                   soprev=so, so=so->s_next ) {
                   if ( so->s_op->o_connid == op->o_connid &&
                           so->s_op->o_msgid == op->orn_msgid ) {
                                   so->s_op->o_abandon = 1;
                                   soprev->s_next = so->s_next;
                                   break;
                   }
           }
           ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );
           if ( so ) {
                   /* Is this really a Cancel exop? */
                   if ( op->o_tag != LDAP_REQ_ABANDON ) {
                           rs->sr_err = LDAP_CANCELLED;
                           send_ldap_result( so->s_op, rs );
                   }
                   syncprov_drop_psearch( so );
           }
           return SLAP_CB_CONTINUE;
   }
   
   /* Find which persistent searches are affected by this operation */
   static void
 syncprov_matchops( Operation *op, opcookie *opc, int saveit )  syncprov_matchops( Operation *op, opcookie *opc, int saveit )
 {  {
         slap_overinst *on = opc->son;          slap_overinst *on = opc->son;
         syncprov_info_t         *si = on->on_bi.bi_private;          syncprov_info_t         *si = on->on_bi.bi_private;
   
         fbase_cookie fc;          fbase_cookie fc;
         syncops *ss;          syncops *ss, *sprev, *snext;
         Entry *e;          Entry *e;
         Attribute *a;          Attribute *a;
         int rc;          int rc;
Line 820  syncprov_matchops( Operation *op, opcook Line 886  syncprov_matchops( Operation *op, opcook
         }          }
   
         ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );          ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
         for (ss = si->si_ops; ss; ss=ss->s_next)          for (ss = si->si_ops, sprev = (syncops *)&si->si_ops; ss;
                   sprev = ss, ss=snext)
         {          {
                 syncmatches *sm;                  syncmatches *sm;
                 int found = 0;                  int found = 0;
   
                   snext = ss->s_next;
                 /* validate base */                  /* validate base */
                 fc.fss = ss;                  fc.fss = ss;
                 fc.fbase = 0;                  fc.fbase = 0;
                 fc.fscope = 0;                  fc.fscope = 0;
   
                   /* If the base of the search is missing, signal a refresh */
                 rc = syncprov_findbase( op, &fc );                  rc = syncprov_findbase( op, &fc );
                 if ( rc != LDAP_SUCCESS ) continue;                  if ( rc != LDAP_SUCCESS ) {
                           SlapReply rs = {REP_RESULT};
                           send_ldap_error( ss->s_op, &rs, LDAP_SYNC_REFRESH_REQUIRED,
                                   "search base has changed" );
                           sprev->s_next = snext;
                           syncprov_drop_psearch( ss );
                           continue;
                   }
   
                 /* If we're sending results now, look for this op in old matches */                  /* If we're sending results now, look for this op in old matches */
                 if ( !saveit ) {                  if ( !saveit ) {
Line 873  syncprov_matchops( Operation *op, opcook Line 950  syncprov_matchops( Operation *op, opcook
         }          }
 }  }
   
 static void  
 syncprov_free_syncop( syncops *so )  
 {  
         syncres *sr, *srnext;  
   
         ldap_pvt_thread_mutex_lock( &so->s_mutex );  
         so->s_inuse--;  
         if ( so->s_inuse > 0 ) {  
                 ldap_pvt_thread_mutex_unlock( &so->s_mutex );  
                 return;  
         }  
         ldap_pvt_thread_mutex_unlock( &so->s_mutex );  
         filter_free( so->s_op->ors_filter );  
         ch_free( so->s_op );  
         ch_free( so->s_base.bv_val );  
         for ( sr=so->s_res; sr; sr=srnext ) {  
                 srnext = sr->s_next;  
                 ch_free( sr );  
         }  
         ldap_pvt_thread_mutex_destroy( &so->s_mutex );  
         ch_free( so );  
 }  
   
 static int  static int
 syncprov_op_cleanup( Operation *op, SlapReply *rs )  syncprov_op_cleanup( Operation *op, SlapReply *rs )
 {  {
Line 950  syncprov_op_response( Operation *op, Sla Line 1004  syncprov_op_response( Operation *op, Sla
                 struct berval maxcsn;                  struct berval maxcsn;
                 char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];                  char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
   
                   /* Update our context CSN */
                 cbuf[0] = '\0';                  cbuf[0] = '\0';
                 ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );                  ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );
                 slap_get_commit_csn( op, &maxcsn );                  slap_get_commit_csn( op, &maxcsn );
Line 966  syncprov_op_response( Operation *op, Sla Line 1021  syncprov_op_response( Operation *op, Sla
                 opc->sctxcsn.bv_len = maxcsn.bv_len;                  opc->sctxcsn.bv_len = maxcsn.bv_len;
                 opc->sctxcsn.bv_val = cbuf;                  opc->sctxcsn.bv_val = cbuf;
   
                   /* Handle any persistent searches */
                 if ( si->si_ops ) {                  if ( si->si_ops ) {
                         switch(op->o_tag) {                          switch(op->o_tag) {
                         case LDAP_REQ_ADD:                          case LDAP_REQ_ADD:
Line 994  syncprov_op_response( Operation *op, Sla Line 1050  syncprov_op_response( Operation *op, Sla
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
 }  }
   
 static int  
 syncprov_op_abandon( Operation *op, SlapReply *rs )  
 {  
         slap_overinst           *on = (slap_overinst *)op->o_bd->bd_info;  
         syncprov_info_t         *si = on->on_bi.bi_private;  
         syncops *so, *soprev;  
   
         ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );  
         for ( so=si->si_ops, soprev = (syncops *)&si->si_ops; so;  
                 soprev=so, so=so->s_next ) {  
                 if ( so->s_op->o_connid == op->o_connid &&  
                         so->s_op->o_msgid == op->orn_msgid ) {  
                                 so->s_op->o_abandon = 1;  
                                 soprev->s_next = so->s_next;  
                                 break;  
                 }  
         }  
         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );  
         if ( so ) {  
                 ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex );  
                 op->o_conn->c_n_ops_executing--;  
                 op->o_conn->c_n_ops_completed++;  
                 ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex );  
                 /* Is this really a Cancel exop? */  
                 if ( op->o_tag != LDAP_REQ_ABANDON ) {  
                         rs->sr_err = LDAP_CANCELLED;  
                         send_ldap_result( so->s_op, rs );  
                 }  
                 syncprov_free_syncop( so );  
         }  
         return SLAP_CB_CONTINUE;  
 }  
   
 #if 0  #if 0
   /* We don't use a subentry to store the context CSN any more. But
    * we ought to expose the current context CSN as an operational attribute
    * somewhere, like on the suffix entry.
    */
 static int  static int
 syncprov_op_compare( Operation *op, SlapReply *rs )  syncprov_op_compare( Operation *op, SlapReply *rs )
 {  {
Line 1272  syncprov_search_response( Operation *op, Line 1299  syncprov_search_response( Operation *op,
                 } else {                  } else {
                         int locked = 0;                          int locked = 0;
                 /* It's RefreshAndPersist, transition to Persist phase */                  /* It's RefreshAndPersist, transition to Persist phase */
                         rs->sr_rspoid = LDAP_SYNC_INFO;  
                         syncprov_sendinfo( op, rs, rs->sr_nentries ?                          syncprov_sendinfo( op, rs, rs->sr_nentries ?
                                 LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,                                  LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,
                                 &cookie, 1, NULL, 0 );                                  &cookie, 1, NULL, 0 );

Removed from v.1.21  
changed lines
  Added in v.1.23


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