Diff for /servers/slapd/overlays/syncprov.c between versions 1.56.2.9 and 1.56.2.10

version 1.56.2.9, 2005/07/11 05:55:33 version 1.56.2.10, 2005/08/09 21:04:08
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.88 2005/07/10 08:20:21 hallvard Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.94 2005/08/08 22:26:39 hyc Exp $ */
 /* syncprov.c - syncrepl provider */  /* syncprov.c - syncrepl provider */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
Line 159  syncprov_state_ctrl( Line 159  syncprov_state_ctrl(
 {  {
         Attribute* a;          Attribute* a;
         int ret;          int ret;
         int res;  
         const char *text = NULL;  
   
         BerElementBuffer berbuf;          BerElementBuffer berbuf;
         BerElement *ber = (BerElement *)&berbuf;          BerElement *ber = (BerElement *)&berbuf;
Line 402  syncprov_findbase( Operation *op, fbase_ Line 400  syncprov_findbase( Operation *op, fbase_
 {  {
         opcookie *opc = op->o_callback->sc_private;          opcookie *opc = op->o_callback->sc_private;
         slap_overinst *on = opc->son;          slap_overinst *on = opc->son;
         syncprov_info_t         *si = on->on_bi.bi_private;  
   
         slap_callback cb = {0};          slap_callback cb = {0};
         Operation fop;          Operation fop;
Line 746  static int Line 743  static int
 syncprov_sendresp( Operation *op, opcookie *opc, syncops *so, Entry **e, int mode, int queue )  syncprov_sendresp( Operation *op, opcookie *opc, syncops *so, Entry **e, int mode, int queue )
 {  {
         slap_overinst *on = opc->son;          slap_overinst *on = opc->son;
         syncprov_info_t *si = on->on_bi.bi_private;  
   
         SlapReply rs = { REP_SEARCH };          SlapReply rs = { REP_SEARCH };
         LDAPControl *ctrls[2];          LDAPControl *ctrls[2];
Line 1184  syncprov_add_slog( Operation *op, struct Line 1180  syncprov_add_slog( Operation *op, struct
                 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);
                 se->se_csn.bv_val = se->se_uuid.bv_val + opc->suuid.bv_len + 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;
   
                   se->se_csn.bv_val = se->se_uuid.bv_val + opc->suuid.bv_len;
                 AC_MEMCPY( se->se_csn.bv_val, csn->bv_val, csn->bv_len );                  AC_MEMCPY( se->se_csn.bv_val, csn->bv_val, csn->bv_len );
                 se->se_csn.bv_val[csn->bv_len] = '\0';                  se->se_csn.bv_val[csn->bv_len] = '\0';
                 se->se_csn.bv_len = csn->bv_len;                  se->se_csn.bv_len = csn->bv_len;
Line 1231  syncprov_playlog( Operation *op, SlapRep Line 1227  syncprov_playlog( Operation *op, SlapRep
         struct berval *oldcsn, struct berval *ctxcsn )          struct berval *oldcsn, struct berval *ctxcsn )
 {  {
         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;  
         slog_entry *se;          slog_entry *se;
         int i, j, ndel, num, nmods, mmods;          int i, j, ndel, num, nmods, mmods;
         BerVarray uuids;          BerVarray uuids;
Line 1692  syncprov_search_response( Operation *op, Line 1687  syncprov_search_response( Operation *op,
 {  {
         searchstate *ss = op->o_callback->sc_private;          searchstate *ss = op->o_callback->sc_private;
         slap_overinst *on = ss->ss_on;          slap_overinst *on = ss->ss_on;
         syncprov_info_t         *si = on->on_bi.bi_private;  
         sync_control *srs = op->o_controls[slap_cids.sc_LDAPsync];          sync_control *srs = op->o_controls[slap_cids.sc_LDAPsync];
   
         if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {          if ( rs->sr_type == REP_SEARCH || rs->sr_type == REP_SEARCHREF ) {
                 int i;  
                 /* If we got a referral without a referral object, there's                  /* If we got a referral without a referral object, there's
                  * something missing that we cannot replicate. Just ignore it.                   * something missing that we cannot replicate. Just ignore it.
                  * The consumer will abort because we didn't send the expected                   * The consumer will abort because we didn't send the expected
                  * control.                   * control.
                  */                   */
                 if ( !rs->sr_entry ) {                  if ( !rs->sr_entry ) {
                         assert( rs->sr_entry );                          assert( rs->sr_entry != NULL );
                         Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );                          Debug( LDAP_DEBUG_ANY, "bogus referral in context\n",0,0,0 );
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
Line 2293  static int syncprov_parseCtrl ( Line 2286  static int syncprov_parseCtrl (
         LDAPControl *ctrl )          LDAPControl *ctrl )
 {  {
         ber_tag_t tag;          ber_tag_t tag;
         BerElement *ber;          BerElementBuffer berbuf;
           BerElement *ber = (BerElement *)&berbuf;
         ber_int_t mode;          ber_int_t mode;
         ber_len_t len;          ber_len_t len;
         struct berval cookie = BER_BVNULL;          struct berval cookie = BER_BVNULL;
Line 2327  static int syncprov_parseCtrl ( Line 2321  static int syncprov_parseCtrl (
          *      }           *      }
          */           */
   
         ber = ber_init( &ctrl->ldctl_value );          ber_init2( ber, &ctrl->ldctl_value, 0 );
         if( ber == NULL ) {  
                 rs->sr_text = "internal error";  
                 return LDAP_OTHER;  
         }  
   
         if ( (tag = ber_scanf( ber, "{i" /*}*/, &mode )) == LBER_ERROR ) {          if ( (tag = ber_scanf( ber, "{i" /*}*/, &mode )) == LBER_ERROR ) {
                 rs->sr_text = "Sync control : mode decoding error";                  rs->sr_text = "Sync control : mode decoding error";
Line 2353  static int syncprov_parseCtrl ( Line 2343  static int syncprov_parseCtrl (
         tag = ber_peek_tag( ber, &len );          tag = ber_peek_tag( ber, &len );
   
         if ( tag == LDAP_TAG_SYNC_COOKIE ) {          if ( tag == LDAP_TAG_SYNC_COOKIE ) {
                 if (( ber_scanf( ber, /*{*/ "o", &cookie )) == LBER_ERROR ) {                  if (( ber_scanf( ber, /*{*/ "m", &cookie )) == LBER_ERROR ) {
                         rs->sr_text = "Sync control : cookie decoding error";                          rs->sr_text = "Sync control : cookie decoding error";
                         return LDAP_PROTOCOL_ERROR;                          return LDAP_PROTOCOL_ERROR;
                 }                  }
Line 2371  static int syncprov_parseCtrl ( Line 2361  static int syncprov_parseCtrl (
         sr = op->o_tmpcalloc( 1, sizeof(struct sync_control), op->o_tmpmemctx );          sr = op->o_tmpcalloc( 1, sizeof(struct sync_control), op->o_tmpmemctx );
         sr->sr_rhint = rhint;          sr->sr_rhint = rhint;
         if (!BER_BVISNULL(&cookie)) {          if (!BER_BVISNULL(&cookie)) {
                 ber_dupbv( &sr->sr_state.octet_str, &cookie );                  ber_dupbv_x( &sr->sr_state.octet_str, &cookie, op->o_tmpmemctx );
                 slap_parse_sync_cookie( &sr->sr_state );                  slap_parse_sync_cookie( &sr->sr_state, op->o_tmpmemctx );
                   if ( sr->sr_state.rid == -1 ) {
                           rs->sr_text = "Sync control : cookie parsing error";
                           return LDAP_PROTOCOL_ERROR;
                   }
         }          }
   
         op->o_controls[slap_cids.sc_LDAPsync] = sr;          op->o_controls[slap_cids.sc_LDAPsync] = sr;
   
         (void) ber_free( ber, 1 );  
   
         op->o_sync = ctrl->ldctl_iscritical          op->o_sync = ctrl->ldctl_iscritical
                 ? SLAP_CONTROL_CRITICAL                  ? SLAP_CONTROL_CRITICAL
                 : SLAP_CONTROL_NONCRITICAL;                  : SLAP_CONTROL_NONCRITICAL;

Removed from v.1.56.2.9  
changed lines
  Added in v.1.56.2.10


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