Diff for /servers/slapd/back-meta/modify.c between versions 1.52 and 1.52.2.7

version 1.52, 2006/04/01 16:56:39 version 1.52.2.7, 2008/02/12 00:25:47
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/modify.c,v 1.51 2006/03/01 23:35:12 ando Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/modify.c,v 1.52.2.6 2008/02/11 23:26:47 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 1999-2006 The OpenLDAP Foundation.   * Copyright 1999-2008 The OpenLDAP Foundation.
  * Portions Copyright 2001-2003 Pierangelo Masarati.   * Portions Copyright 2001-2003 Pierangelo Masarati.
  * Portions Copyright 1999-2003 Howard Chu.   * Portions Copyright 1999-2003 Howard Chu.
  * All rights reserved.   * All rights reserved.
Line 35  int Line 35  int
 meta_back_modify( Operation *op, SlapReply *rs )  meta_back_modify( Operation *op, SlapReply *rs )
 {  {
         metainfo_t      *mi = ( metainfo_t * )op->o_bd->be_private;          metainfo_t      *mi = ( metainfo_t * )op->o_bd->be_private;
           metatarget_t    *mt;
         metaconn_t      *mc;          metaconn_t      *mc;
         int             rc = 0;          int             rc = 0;
         int             maperr = 1;  
         LDAPMod         **modv = NULL;          LDAPMod         **modv = NULL;
         LDAPMod         *mods = NULL;          LDAPMod         *mods = NULL;
         Modifications   *ml;          Modifications   *ml;
Line 48  meta_back_modify( Operation *op, SlapRep Line 48  meta_back_modify( Operation *op, SlapRep
         dncookie        dc;          dncookie        dc;
         int             msgid;          int             msgid;
         int             do_retry = 1;          int             do_retry = 1;
           LDAPControl     **ctrls = NULL;
   
         mc = meta_back_getconn( op, rs, &candidate, LDAP_BACK_SENDERR );          mc = meta_back_getconn( op, rs, &candidate, LDAP_BACK_SENDERR );
         if ( !mc || !meta_back_dobind( op, rs, mc, LDAP_BACK_SENDERR ) ) {          if ( !mc || !meta_back_dobind( op, rs, mc, LDAP_BACK_SENDERR ) ) {
Line 59  meta_back_modify( Operation *op, SlapRep Line 60  meta_back_modify( Operation *op, SlapRep
         /*          /*
          * Rewrite the modify dn, if needed           * Rewrite the modify dn, if needed
          */           */
         dc.target = &mi->mi_targets[ candidate ];          mt = mi->mi_targets[ candidate ];
           dc.target = mt;
         dc.conn = op->o_conn;          dc.conn = op->o_conn;
         dc.rs = rs;          dc.rs = rs;
         dc.ctx = "modifyDN";          dc.ctx = "modifyDN";
   
         if ( ldap_back_dn_massage( &dc, &op->o_req_dn, &mdn ) ) {          if ( ldap_back_dn_massage( &dc, &op->o_req_dn, &mdn ) ) {
                 maperr = 0;                  send_ldap_result( op, rs );
                 goto cleanup;                  goto cleanup;
         }          }
   
Line 74  meta_back_modify( Operation *op, SlapRep Line 76  meta_back_modify( Operation *op, SlapRep
   
         mods = ch_malloc( sizeof( LDAPMod )*i );          mods = ch_malloc( sizeof( LDAPMod )*i );
         if ( mods == NULL ) {          if ( mods == NULL ) {
                 rs->sr_err = LDAP_NO_MEMORY;                  rs->sr_err = LDAP_OTHER;
                 maperr = 0;                  send_ldap_result( op, rs );
                 goto cleanup;                  goto cleanup;
         }          }
         modv = ( LDAPMod ** )ch_malloc( ( i + 1 )*sizeof( LDAPMod * ) );          modv = ( LDAPMod ** )ch_malloc( ( i + 1 )*sizeof( LDAPMod * ) );
         if ( modv == NULL ) {          if ( modv == NULL ) {
                 rs->sr_err = LDAP_NO_MEMORY;                  rs->sr_err = LDAP_OTHER;
                 maperr = 0;                  send_ldap_result( op, rs );
                 goto cleanup;                  goto cleanup;
         }          }
   
Line 90  meta_back_modify( Operation *op, SlapRep Line 92  meta_back_modify( Operation *op, SlapRep
         for ( i = 0, ml = op->orm_modlist; ml; ml = ml->sml_next ) {          for ( i = 0, ml = op->orm_modlist; ml; ml = ml->sml_next ) {
                 int     j, is_oc = 0;                  int     j, is_oc = 0;
   
                 if ( !isupdate && !get_manageDIT( op ) && ml->sml_desc->ad_type->sat_no_user_mod  )                  if ( !isupdate && !get_relax( op ) && ml->sml_desc->ad_type->sat_no_user_mod  )
                 {                  {
                         continue;                          continue;
                 }                  }
Line 102  meta_back_modify( Operation *op, SlapRep Line 104  meta_back_modify( Operation *op, SlapRep
                         mapped = ml->sml_desc->ad_cname;                          mapped = ml->sml_desc->ad_cname;
   
                 } else {                  } else {
                         ldap_back_map( &mi->mi_targets[ candidate ].mt_rwmap.rwm_at,                          ldap_back_map( &mt->mt_rwmap.rwm_at,
                                         &ml->sml_desc->ad_cname, &mapped,                                          &ml->sml_desc->ad_cname, &mapped,
                                         BACKLDAP_MAP );                                          BACKLDAP_MAP );
                         if ( BER_BVISNULL( &mapped ) || BER_BVISEMPTY( &mapped ) ) {                          if ( BER_BVISNULL( &mapped ) || BER_BVISEMPTY( &mapped ) ) {
Line 129  meta_back_modify( Operation *op, SlapRep Line 131  meta_back_modify( Operation *op, SlapRep
                                 for ( j = 0; !BER_BVISNULL( &ml->sml_values[ j ] ); ) {                                  for ( j = 0; !BER_BVISNULL( &ml->sml_values[ j ] ); ) {
                                         struct ldapmapping      *mapping;                                          struct ldapmapping      *mapping;
   
                                         ldap_back_mapping( &mi->mi_targets[ candidate ].mt_rwmap.rwm_oc,                                          ldap_back_mapping( &mt->mt_rwmap.rwm_oc,
                                                         &ml->sml_values[ j ], &mapping, BACKLDAP_MAP );                                                          &ml->sml_values[ j ], &mapping, BACKLDAP_MAP );
   
                                         if ( mapping == NULL ) {                                          if ( mapping == NULL ) {
                                                 if ( mi->mi_targets[ candidate ].mt_rwmap.rwm_oc.drop_missing ) {                                                  if ( mt->mt_rwmap.rwm_oc.drop_missing ) {
                                                         continue;                                                          continue;
                                                 }                                                  }
                                                 mods[ i ].mod_bvalues[ j ] = &ml->sml_values[ j ];                                                  mods[ i ].mod_bvalues[ j ] = &ml->sml_values[ j ];
Line 175  meta_back_modify( Operation *op, SlapRep Line 177  meta_back_modify( Operation *op, SlapRep
         modv[ i ] = 0;          modv[ i ] = 0;
   
 retry:;  retry:;
           ctrls = op->o_ctrls;
           rc = meta_back_controls_add( op, rs, mc, candidate, &ctrls );
           if ( rc != LDAP_SUCCESS ) {
                   send_ldap_result( op, rs );
                   goto cleanup;
           }
   
         rs->sr_err = ldap_modify_ext( mc->mc_conns[ candidate ].msc_ld, mdn.bv_val,          rs->sr_err = ldap_modify_ext( mc->mc_conns[ candidate ].msc_ld, mdn.bv_val,
                         modv, op->o_ctrls, NULL, &msgid );                          modv, ctrls, NULL, &msgid );
           rs->sr_err = meta_back_op_result( mc, op, rs, candidate, msgid,
                   mt->mt_timeout[ SLAP_OP_MODIFY ], LDAP_BACK_SENDRESULT );
         if ( rs->sr_err == LDAP_UNAVAILABLE && do_retry ) {          if ( rs->sr_err == LDAP_UNAVAILABLE && do_retry ) {
                 do_retry = 0;                  do_retry = 0;
                 if ( meta_back_retry( op, rs, &mc, candidate, LDAP_BACK_SENDERR ) ) {                  if ( meta_back_retry( op, rs, &mc, candidate, LDAP_BACK_SENDERR ) ) {
                           /* if the identity changed, there might be need to re-authz */
                           (void)mi->mi_ldap_extra->controls_free( op, rs, &ctrls );
                         goto retry;                          goto retry;
                 }                  }
                 goto done;  
   
         } else if ( rs->sr_err == LDAP_SUCCESS ) {  
                 struct timeval  tv, *tvp = NULL;  
                 LDAPMessage     *res = NULL;  
   
                 if ( mi->mi_targets[ candidate ].mt_timeout[ LDAP_BACK_OP_MODIFY ] != 0 ) {  
                         tv.tv_sec = mi->mi_targets[ candidate ].mt_timeout[ LDAP_BACK_OP_MODIFY ];  
                         tv.tv_usec = 0;  
                         tvp = &tv;  
                 }  
   
                 rs->sr_err = LDAP_OTHER;  
                 rc = ldap_result( mc->mc_conns[ candidate ].msc_ld,  
                         msgid, LDAP_MSG_ALL, tvp, &res );  
                 switch ( rc ) {  
                 case -1:  
                         maperr = 0;  
                         break;  
   
                 case 0:  
                         ldap_abandon_ext( mc->mc_conns[ candidate ].msc_ld,  
                                 msgid, NULL, NULL );  
                         rs->sr_err = op->o_protocol >= LDAP_VERSION3 ?  
                                 LDAP_ADMINLIMIT_EXCEEDED : LDAP_OPERATIONS_ERROR;  
                         maperr = 0;  
                         break;  
   
                 case LDAP_RES_MODIFY:  
                         rc = ldap_parse_result( mc->mc_conns[ candidate ].msc_ld,  
                                 res, &rs->sr_err, NULL, NULL, NULL, NULL, 1 );  
                         if ( rc != LDAP_SUCCESS ) {  
                                 rs->sr_err = rc;  
                         }  
                         maperr = 1;  
                         break;  
   
                 default:  
                         maperr = 0;  
                         ldap_msgfree( res );  
                         break;  
                 }  
         }          }
   
 cleanup:;  cleanup:;
         if ( maperr ) {          (void)mi->mi_ldap_extra->controls_free( op, rs, &ctrls );
                 rc = meta_back_op_result( mc, op, rs, candidate );  
   
         } else {  
                 send_ldap_result( op, rs );  
         }  
   
 done:;  
         if ( mdn.bv_val != op->o_req_dn.bv_val ) {          if ( mdn.bv_val != op->o_req_dn.bv_val ) {
                 free( mdn.bv_val );                  free( mdn.bv_val );
                 BER_BVZERO( &mdn );                  BER_BVZERO( &mdn );
Line 248  done:; Line 213  done:;
         free( modv );          free( modv );
   
         if ( mc ) {          if ( mc ) {
                 meta_back_release_conn( op, mc );                  meta_back_release_conn( mi, mc );
         }          }
   
         return rs->sr_err;          return rs->sr_err;

Removed from v.1.52  
changed lines
  Added in v.1.52.2.7


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