Diff for /servers/slapd/backend.c between versions 1.150 and 1.150.2.12

version 1.150, 2002/02/12 03:50:40 version 1.150.2.12, 2002/10/10 01:45:55
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/backend.c,v 1.149 2002/01/29 05:06:20 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/backend.c,v 1.150.2.11 2002/09/29 18:21:29 kurt Exp $ */
 /*  /*
  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
Line 17 Line 17
   
 #include "slap.h"  #include "slap.h"
 #include "lutil.h"  #include "lutil.h"
   #include "lber_pvt.h"
   
 /*  /*
  * If a module is configured as dynamic, its header should not   * If a module is configured as dynamic, its header should not
Line 44 Line 45
 #if defined(SLAPD_MONITOR) && !defined(SLAPD_MONITOR_DYNAMIC)  #if defined(SLAPD_MONITOR) && !defined(SLAPD_MONITOR_DYNAMIC)
 #include "back-monitor/external.h"  #include "back-monitor/external.h"
 #endif  #endif
   #if defined(SLAPD_NULL) && !defined(SLAPD_NULL_DYNAMIC)
   #include "back-null/external.h"
   #endif
 #if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)  #if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)
 #include "back-passwd/external.h"  #include "back-passwd/external.h"
 #endif  #endif
Line 82  static BackendInfo binfo[] = { Line 86  static BackendInfo binfo[] = {
 #if defined(SLAPD_MONITOR) && !defined(SLAPD_MONITOR_DYNAMIC)  #if defined(SLAPD_MONITOR) && !defined(SLAPD_MONITOR_DYNAMIC)
         {"monitor",     monitor_back_initialize},          {"monitor",     monitor_back_initialize},
 #endif  #endif
   #if defined(SLAPD_NULL) && !defined(SLAPD_NULL_DYNAMIC)
           {"null",        null_back_initialize},
   #endif
 #if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)  #if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)
         {"passwd",      passwd_back_initialize},          {"passwd",      passwd_back_initialize},
 #endif  #endif
Line 117  int backend_init(void) Line 124  int backend_init(void)
         if((nBackendInfo != 0) || (backendInfo != NULL)) {          if((nBackendInfo != 0) || (backendInfo != NULL)) {
                 /* already initialized */                  /* already initialized */
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,                  LDAP_LOG( BACKEND, ERR, 
                            "backend_init:  backend already initialized\n" ));                          "backend_init:  backend already initialized\n", 0, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "backend_init: already initialized.\n", 0, 0, 0 );                          "backend_init: already initialized.\n", 0, 0, 0 );
Line 134  int backend_init(void) Line 141  int backend_init(void)
   
                 if(rc != 0) {                  if(rc != 0) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "backend", LDAP_LEVEL_INFO,                          LDAP_LOG( BACKEND, INFO, 
                                 "backend_init:  initialized for type \"%s\"\n",                                  "backend_init:  initialized for type \"%s\"\n",
                                 binfo[nBackendInfo].bi_type ));                                  binfo[nBackendInfo].bi_type, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "backend_init: initialized for type \"%s\"\n",                                  "backend_init: initialized for type \"%s\"\n",
Line 166  int backend_init(void) Line 173  int backend_init(void)
 #else  #else
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "backend", LDAP_LEVEL_ERR,          LDAP_LOG( BACKEND, ERR, "backend_init: failed\n", 0, 0, 0 );
                 "backend_init: failed\n" ));  
 #else  #else
         Debug( LDAP_DEBUG_ANY,          Debug( LDAP_DEBUG_ANY,
                 "backend_init: failed\n",                  "backend_init: failed\n",
Line 184  int backend_add(BackendInfo *aBackendInf Line 190  int backend_add(BackendInfo *aBackendInf
   
    if ((rc = aBackendInfo->bi_init(aBackendInfo)) != 0) {     if ((rc = aBackendInfo->bi_init(aBackendInfo)) != 0) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
        LDAP_LOG(( "backend", LDAP_LEVEL_ERR,          LDAP_LOG( BACKEND, ERR, 
                   "backend_add:  initialization for type \"%s\" failed\n",                    "backend_add:  initialization for type \"%s\" failed\n",
                   aBackendInfo->bi_type ));                    aBackendInfo->bi_type, 0, 0 );
 #else  #else
       Debug( LDAP_DEBUG_ANY,        Debug( LDAP_DEBUG_ANY,
              "backend_add: initialization for type \"%s\" failed\n",               "backend_add: initialization for type \"%s\" failed\n",
Line 225  int backend_startup(Backend *be) Line 231  int backend_startup(Backend *be)
         if( ! ( nBackendDB > 0 ) ) {          if( ! ( nBackendDB > 0 ) ) {
                 /* no databases */                  /* no databases */
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,                  LDAP_LOG( BACKEND, INFO, 
                            "backend_startup: %d databases to startup. \n",                          "backend_startup: %d databases to startup. \n", nBackendDB, 0, 0 );
                            nBackendDB ));  
 #else  #else
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "backend_startup: %d databases to startup.\n",                          "backend_startup: %d databases to startup.\n",
Line 239  int backend_startup(Backend *be) Line 244  int backend_startup(Backend *be)
         if(be != NULL) {          if(be != NULL) {
                 /* startup a specific backend database */                  /* startup a specific backend database */
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,                  LDAP_LOG( BACKEND, DETAIL1, "backend_startup:  starting \"%s\"\n",
                            "backend_startup:  starting \"%s\"\n",                             be->be_suffix[0].bv_val, 0, 0 );
                            be->be_suffix[0]->bv_val ));  
 #else  #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "backend_startup: starting \"%s\"\n",                          "backend_startup: starting \"%s\"\n",
                         be->be_suffix[0]->bv_val, 0, 0 );                          be->be_suffix[0].bv_val, 0, 0 );
 #endif  #endif
   
                 if ( be->bd_info->bi_open ) {                  if ( be->bd_info->bi_open ) {
                         rc = be->bd_info->bi_open( be->bd_info );                          rc = be->bd_info->bi_open( be->bd_info );
                 }                          if ( rc != 0 ) {
   
                 if(rc != 0) {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "backend", LDAP_LEVEL_CRIT,                                  LDAP_LOG( BACKEND, CRIT, "backend_startup: bi_open failed!\n", 0, 0, 0 );
                                    "backend_startup: bi_open failed!\n" ));  
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                 "backend_startup: bi_open failed!\n",                                          "backend_startup: bi_open failed!\n",
                                 0, 0, 0 );                                          0, 0, 0 );
 #endif  #endif
   
                         return rc;                                  return rc;
                           }
                 }                  }
   
                 if ( be->bd_info->bi_db_open ) {                  if ( be->bd_info->bi_db_open ) {
                         rc = be->bd_info->bi_db_open( be );                          rc = be->bd_info->bi_db_open( be );
                 }                          if ( rc != 0 ) {
   
                 if(rc != 0) {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "backend", LDAP_LEVEL_CRIT,                                  LDAP_LOG( BACKEND, CRIT, 
                                 "backend_startup: bi_db_open failed! (%d)\n", rc ));                                          "backend_startup: bi_db_open failed! (%d)\n", rc, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                 "backend_startup: bi_db_open failed! (%d)\n",                                          "backend_startup: bi_db_open failed! (%d)\n",
                                 rc, 0, 0 );                                          rc, 0, 0 );
 #endif  #endif
                         return rc;                                  return rc;
                           }
                 }                  }
   
                 return rc;                  return rc;
Line 294  int backend_startup(Backend *be) Line 295  int backend_startup(Backend *be)
                 if( backendInfo[i].bi_open ) {                  if( backendInfo[i].bi_open ) {
                         rc = backendInfo[i].bi_open(                          rc = backendInfo[i].bi_open(
                                 &backendInfo[i] );                                  &backendInfo[i] );
                 }                          if ( rc != 0 ) {
   
                 if(rc != 0) {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "backend", LDAP_LEVEL_CRIT,                                  LDAP_LOG( BACKEND, CRIT, 
                                    "backend_startup: bi_open %d failed!\n", i ));                                          "backend_startup: bi_open %d failed!\n", i, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                 "backend_startup: bi_open %d failed!\n",                                          "backend_startup: bi_open %d failed!\n",
                                 i, 0, 0 );                                          i, 0, 0 );
 #endif  #endif
                         return rc;                                  return rc;
                           }
                 }                  }
         }          }
   
Line 317  int backend_startup(Backend *be) Line 317  int backend_startup(Backend *be)
                 if ( backendDB[i].bd_info->bi_db_open ) {                  if ( backendDB[i].bd_info->bi_db_open ) {
                         rc = backendDB[i].bd_info->bi_db_open(                          rc = backendDB[i].bd_info->bi_db_open(
                                 &backendDB[i] );                                  &backendDB[i] );
                 }                          if ( rc != 0 ) {
   
                 if(rc != 0) {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "backend", LDAP_LEVEL_CRIT,                                  LDAP_LOG( BACKEND, CRIT, 
                                 "backend_startup: bi_db_open(%d) failed! (%d)\n",                                          "backend_startup: bi_db_open(%d) failed! (%d)\n", i, rc, 0 );
                                 i, rc ));  
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                 "backend_startup: bi_db_open(%d) failed! (%d)\n",                                          "backend_startup: bi_db_open(%d) failed! (%d)\n",
                                 i, rc, 0 );                                          i, rc, 0 );
 #endif  #endif
                         return rc;                                  return rc;
                           }
                 }                  }
         }          }
   
Line 381  int backend_shutdown( Backend *be ) Line 379  int backend_shutdown( Backend *be )
   
                 if(rc != 0) {                  if(rc != 0) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "backend", LDAP_LEVEL_NOTICE,                          LDAP_LOG( BACKEND, NOTICE, 
                                    "backend_shutdown: bi_close %s failed!\n",                                  "backend_shutdown: bi_close %s failed!\n",
                                    backendDB[i].be_type ));                                  backendDB[i].be_type, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "backend_close: bi_close %s failed!\n",                                  "backend_close: bi_close %s failed!\n",
Line 418  int backend_destroy(void) Line 416  int backend_destroy(void)
                 if ( bd->bd_info->bi_db_destroy ) {                  if ( bd->bd_info->bi_db_destroy ) {
                         bd->bd_info->bi_db_destroy( bd );                          bd->bd_info->bi_db_destroy( bd );
                 }                  }
                 ber_bvecfree( bd->be_suffix );                  ber_bvarray_free( bd->be_suffix );
                 ber_bvecfree( bd->be_nsuffix );                  ber_bvarray_free( bd->be_nsuffix );
                 if ( bd->be_rootdn.bv_val ) free( bd->be_rootdn.bv_val );                  if ( bd->be_rootdn.bv_val ) free( bd->be_rootdn.bv_val );
                 if ( bd->be_rootndn.bv_val ) free( bd->be_rootndn.bv_val );                  if ( bd->be_rootndn.bv_val ) free( bd->be_rootndn.bv_val );
                 if ( bd->be_rootpw.bv_val ) free( bd->be_rootpw.bv_val );                  if ( bd->be_rootpw.bv_val ) free( bd->be_rootpw.bv_val );
Line 533  select_backend( Line 531  select_backend(
   
         for ( i = 0; i < nbackends; i++ ) {          for ( i = 0; i < nbackends; i++ ) {
                 for ( j = 0; backends[i].be_nsuffix != NULL &&                  for ( j = 0; backends[i].be_nsuffix != NULL &&
                     backends[i].be_nsuffix[j] != NULL; j++ )                      backends[i].be_nsuffix[j].bv_val != NULL; j++ )
                 {                  {
                         if (( backends[i].be_flags & SLAP_BFLAG_GLUE_SUBORDINATE )                          if (( backends[i].be_flags & SLAP_BFLAG_GLUE_SUBORDINATE )
                                 && noSubs )                                  && noSubs )
Line 541  select_backend( Line 539  select_backend(
                                 continue;                                  continue;
                         }                          }
   
                         len = backends[i].be_nsuffix[j]->bv_len;                          len = backends[i].be_nsuffix[j].bv_len;
   
                         if ( len > dnlen ) {                          if ( len > dnlen ) {
                                 /* suffix is longer than DN */                                  /* suffix is longer than DN */
Line 558  select_backend( Line 556  select_backend(
                                 continue;                                  continue;
                         }                          }
   
                         if ( strcmp( backends[i].be_nsuffix[j]->bv_val,                          if ( strcmp( backends[i].be_nsuffix[j].bv_val,
                                 &dn->bv_val[dnlen-len] ) == 0 )                                  &dn->bv_val[dnlen-len] ) == 0 )
                         {                          {
                                 if( be == NULL ) {                                  if( be == NULL ) {
Line 586  be_issuffix( Line 584  be_issuffix(
 {  {
         int     i;          int     i;
   
         for ( i = 0; be->be_nsuffix != NULL && be->be_nsuffix[i] != NULL; i++ ) {          for ( i = 0; be->be_nsuffix != NULL && be->be_nsuffix[i].bv_val != NULL; i++ ) {
                 if ( ber_bvcmp( be->be_nsuffix[i], bvsuffix ) == 0 ) {                  if ( bvmatch( &be->be_nsuffix[i], bvsuffix ) ) {
                         return( 1 );                          return( 1 );
                 }                  }
         }          }
Line 738  backend_check_controls( Line 736  backend_check_controls(
         Operation *op,          Operation *op,
         const char **text )          const char **text )
 {  {
         LDAPControl **ctrls;          LDAPControl **ctrls = op->o_ctrls;
         ctrls = op->o_ctrls;  
         if( ctrls == NULL ) {          if( ctrls == NULL ) return LDAP_SUCCESS;
                 return LDAP_SUCCESS;  
         }  
   
         for( ; *ctrls != NULL ; ctrls++ ) {          for( ; *ctrls != NULL ; ctrls++ ) {
                 if( (*ctrls)->ldctl_iscritical &&                  if( (*ctrls)->ldctl_iscritical &&
                         !charray_inlist( be->be_controls, (*ctrls)->ldctl_oid ) )                          !ldap_charray_inlist( be->be_controls, (*ctrls)->ldctl_oid ) )
                 {                  {
                         *text = "control unavailable in context";                          *text = "control unavailable in context";
                         return LDAP_UNAVAILABLE_CRITICAL_EXTENSION;                          return LDAP_UNAVAILABLE_CRITICAL_EXTENSION;
Line 761  backend_check_restrictions( Line 757  backend_check_restrictions(
         Backend *be,          Backend *be,
         Connection *conn,          Connection *conn,
         Operation *op,          Operation *op,
         const void *opdata,          struct berval *opdata,
         const char **text )          const char **text )
 {  {
         int rc;          int rc;
Line 770  backend_check_restrictions( Line 766  backend_check_restrictions(
         slap_mask_t opflag;          slap_mask_t opflag;
         slap_ssf_set_t *ssf;          slap_ssf_set_t *ssf;
         int updateop = 0;          int updateop = 0;
           int starttls = 0;
           int session = 0;
   
         if( be ) {          if( be ) {
                 rc = backend_check_controls( be, conn, op, text );                  rc = backend_check_controls( be, conn, op, text );
Line 795  backend_check_restrictions( Line 793  backend_check_restrictions(
                 break;                  break;
         case LDAP_REQ_BIND:          case LDAP_REQ_BIND:
                 opflag = SLAP_RESTRICT_OP_BIND;                  opflag = SLAP_RESTRICT_OP_BIND;
                   session++;
                 break;                  break;
         case LDAP_REQ_COMPARE:          case LDAP_REQ_COMPARE:
                 opflag = SLAP_RESTRICT_OP_COMPARE;                  opflag = SLAP_RESTRICT_OP_COMPARE;
Line 805  backend_check_restrictions( Line 804  backend_check_restrictions(
                 break;                  break;
         case LDAP_REQ_EXTENDED:          case LDAP_REQ_EXTENDED:
                 opflag = SLAP_RESTRICT_OP_EXTENDED;                  opflag = SLAP_RESTRICT_OP_EXTENDED;
   
                   if( !opdata ) {
                           /* treat unspecified as a modify */
                           opflag = SLAP_RESTRICT_OP_MODIFY;
                           updateop++;
                           break;
                   }
   
                   {
                           struct berval bv = BER_BVC( LDAP_EXOP_START_TLS );
                           if( bvmatch( opdata, &bv ) ) {
                                   session++;
                                   starttls++;
                                   break;
                           }
                   }
   
                   {
                           struct berval bv = BER_BVC( LDAP_EXOP_X_WHO_AM_I );
                           if( bvmatch( opdata, &bv ) ) {
                                   break;
                           }
                   }
   
                   /* treat everything else as a modify */
                   opflag = SLAP_RESTRICT_OP_MODIFY;
                   updateop++;
                 break;                  break;
   
         case LDAP_REQ_MODIFY:          case LDAP_REQ_MODIFY:
                 updateop++;                  updateop++;
                 opflag = SLAP_RESTRICT_OP_MODIFY;                  opflag = SLAP_RESTRICT_OP_MODIFY;
Line 818  backend_check_restrictions( Line 845  backend_check_restrictions(
                 opflag = SLAP_RESTRICT_OP_SEARCH;                  opflag = SLAP_RESTRICT_OP_SEARCH;
                 break;                  break;
         case LDAP_REQ_UNBIND:          case LDAP_REQ_UNBIND:
                   session++;
                 opflag = 0;                  opflag = 0;
                 break;                  break;
         default:          default:
Line 825  backend_check_restrictions( Line 853  backend_check_restrictions(
                 return LDAP_OTHER;                  return LDAP_OTHER;
         }          }
   
         if ( op->o_tag != LDAP_REQ_EXTENDED          if ( !starttls ) {
                 || strcmp( (const char *) opdata, LDAP_EXOP_START_TLS ) )  
         {  
                 /* these checks don't apply to StartTLS */                  /* these checks don't apply to StartTLS */
   
                 if( op->o_tag == LDAP_REQ_EXTENDED ) {  
                         /* threat other extended operations as update ops */  
                         updateop++;  
                 }  
   
                 if( op->o_transport_ssf < ssf->sss_transport ) {                  if( op->o_transport_ssf < ssf->sss_transport ) {
                         *text = "transport confidentiality required";                          *text = "transport confidentiality required";
                         return LDAP_CONFIDENTIALITY_REQUIRED;                          return LDAP_CONFIDENTIALITY_REQUIRED;
Line 845  backend_check_restrictions( Line 866  backend_check_restrictions(
                         return LDAP_CONFIDENTIALITY_REQUIRED;                          return LDAP_CONFIDENTIALITY_REQUIRED;
                 }                  }
   
   
                   if( op->o_tag == LDAP_REQ_BIND && opdata == NULL ) {
                           /* simple bind specific check */
                           if( op->o_ssf < ssf->sss_simple_bind ) {
                                   *text = "confidentiality required";
                                   return LDAP_CONFIDENTIALITY_REQUIRED;
                           }
                   }
   
                 if( op->o_tag != LDAP_REQ_BIND || opdata == NULL ) {                  if( op->o_tag != LDAP_REQ_BIND || opdata == NULL ) {
                         /* these checks don't apply to SASL bind */                          /* these checks don't apply to SASL bind */
   
Line 882  backend_check_restrictions( Line 912  backend_check_restrictions(
   
                         if( op->o_ndn.bv_len == 0 ) {                          if( op->o_ndn.bv_len == 0 ) {
                                 *text = "modifications require authentication";                                  *text = "modifications require authentication";
                                 return LDAP_OPERATIONS_ERROR;                                  return LDAP_STRONG_AUTH_REQUIRED;
                         }                          }
                 }                  }
         }          }
   
         if ( op->o_tag != LDAP_REQ_BIND && ( op->o_tag != LDAP_REQ_EXTENDED ||          if ( !session ) {
                 strcmp( (const char *) opdata, LDAP_EXOP_START_TLS ) ) )                  /* these checks don't apply to Bind, StartTLS, or Unbind */
         {  
                 /* these checks don't apply to Bind or StartTLS */  
   
                 if( requires & SLAP_REQUIRE_STRONG ) {                  if( requires & SLAP_REQUIRE_STRONG ) {
                         /* should check mechanism */                          /* should check mechanism */
                         if( op->o_authmech.bv_len == 0 || op->o_dn.bv_len == 0 )                          if( ( op->o_transport_ssf < ssf->sss_transport
                                   && op->o_authmech.bv_len == 0 ) || op->o_dn.bv_len == 0 )
                         {                          {
                                 *text = "strong authentication required";                                  *text = "strong authentication required";
                                 return LDAP_STRONG_AUTH_REQUIRED;                                  return LDAP_STRONG_AUTH_REQUIRED;
Line 902  backend_check_restrictions( Line 931  backend_check_restrictions(
                 }                  }
   
                 if( requires & SLAP_REQUIRE_SASL ) {                  if( requires & SLAP_REQUIRE_SASL ) {
                         if( op->o_authmech.bv_len == 0 || op->o_dn.bv_len == 0 )                          if( op->o_authmech.bv_len == 0 || op->o_dn.bv_len == 0 ) {
                         {  
                                 *text = "SASL authentication required";                                  *text = "SASL authentication required";
                                 return LDAP_STRONG_AUTH_REQUIRED;                                  return LDAP_STRONG_AUTH_REQUIRED;
                         }                          }
Line 987  backend_group( Line 1015  backend_group(
 )  )
 {  {
         GroupAssertion *g;          GroupAssertion *g;
         int i;  
   
         ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );          if ( op->o_abandon ) return SLAPD_ABANDON;
         i = op->o_abandon;  
         ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );  
         if (i) return SLAPD_ABANDON;  
   
         if ( !dn_match( &target->e_nname, gr_ndn ) ) {          if ( !dn_match( &target->e_nname, gr_ndn ) ) {
                 /* we won't attempt to send it to a different backend */                  /* we won't attempt to send it to a different backend */
                                   
                 be = select_backend( gr_ndn, 0,                  be = select_backend( gr_ndn, 0, 0 );
                         (be->be_flags & SLAP_BFLAG_GLUE_INSTANCE));  
   
                 if (be == NULL) {                  if (be == NULL) {
                         return LDAP_NO_SUCH_OBJECT;                          return LDAP_NO_SUCH_OBJECT;
Line 1006  backend_group( Line 1029  backend_group(
         }           } 
   
         ldap_pvt_thread_mutex_lock( &conn->c_mutex );          ldap_pvt_thread_mutex_lock( &conn->c_mutex );
   
         for (g = conn->c_groups; g; g=g->ga_next) {          for (g = conn->c_groups; g; g=g->ga_next) {
                 if (g->ga_be != be || g->ga_oc != group_oc ||                  if (g->ga_be != be || g->ga_oc != group_oc ||
                         g->ga_at != group_at || g->ga_len != gr_ndn->bv_len)                          g->ga_at != group_at || g->ga_len != gr_ndn->bv_len)
Line 1013  backend_group( Line 1037  backend_group(
                 if (strcmp( g->ga_ndn, gr_ndn->bv_val ) == 0)                  if (strcmp( g->ga_ndn, gr_ndn->bv_val ) == 0)
                         break;                          break;
         }          }
   
         ldap_pvt_thread_mutex_unlock( &conn->c_mutex );          ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
   
         if (g) {          if (g) {
                 return g->ga_res;                  return g->ga_res;
         }          }
Line 1023  backend_group( Line 1049  backend_group(
                         target, gr_ndn, op_ndn,                          target, gr_ndn, op_ndn,
                         group_oc, group_at );                          group_oc, group_at );
                                   
                 if (op->o_tag != LDAP_REQ_BIND) {                  if ( op->o_tag != LDAP_REQ_BIND && !op->o_do_not_cache ) {
                         g = ch_malloc(sizeof(GroupAssertion) + gr_ndn->bv_len);                          g = ch_malloc(sizeof(GroupAssertion) + gr_ndn->bv_len);
                         g->ga_be = be;                          g->ga_be = be;
                         g->ga_oc = group_oc;                          g->ga_oc = group_oc;
Line 1057  backend_attribute( Line 1083  backend_attribute(
         if ( target == NULL || !dn_match( &target->e_nname, edn ) ) {          if ( target == NULL || !dn_match( &target->e_nname, edn ) ) {
                 /* we won't attempt to send it to a different backend */                  /* we won't attempt to send it to a different backend */
                                   
                 be = select_backend( edn, 0,                  be = select_backend( edn, 0, 0 );
                         (be->be_flags & SLAP_BFLAG_GLUE_INSTANCE));  
   
                 if (be == NULL) {                  if (be == NULL) {
                         return LDAP_NO_SUCH_OBJECT;                          return LDAP_NO_SUCH_OBJECT;
Line 1083  Attribute *backend_operational( Line 1108  Attribute *backend_operational(
 {  {
         Attribute *a = NULL, **ap = &a;          Attribute *a = NULL, **ap = &a;
   
 #ifdef SLAPD_SCHEMA_DN  
         *ap = slap_operational_subschemaSubentry();  
         ap = &(*ap)->a_next;  
 #endif  
   
         /*          /*
          * If operational attributes (allegedly) are required,            * If operational attributes (allegedly) are required, 
          * and the backend supports specific operational attributes,            * and the backend supports specific operational attributes, 
          * add them to the attribute list           * add them to the attribute list
          */           */
           if ( opattrs || ( attrs &&
                   ad_inlist( slap_schema.si_ad_subschemaSubentry, attrs )) ) {
                   *ap = slap_operational_subschemaSubentry( be );
                   ap = &(*ap)->a_next;
           }
   
         if ( ( opattrs || attrs ) && be && be->be_operational != NULL ) {          if ( ( opattrs || attrs ) && be && be->be_operational != NULL ) {
                 ( void )be->be_operational( be, conn, op, e, attrs, opattrs, ap );                  ( void )be->be_operational( be, conn, op, e, attrs, opattrs, ap );
         }          }

Removed from v.1.150  
changed lines
  Added in v.1.150.2.12


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