Diff for /servers/slapd/back-meta/init.c between versions 1.37.2.17 and 1.38

version 1.37.2.17, 2008/02/11 23:24:22 version 1.38, 2005/01/01 19:49:55
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/init.c,v 1.37.2.16 2007/01/26 22:05:36 ando Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/init.c,v 1.37 2004/11/15 18:45:50 ando 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-2008 The OpenLDAP Foundation.   * Copyright 1999-2005 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 28 Line 28
   
 int  int
 meta_back_open(  meta_back_open(
         BackendInfo     *bi )          BackendInfo *bi
   )
 {  {
         /* FIXME: need to remove the pagedResults, and likely more... */  
         bi->bi_controls = slap_known_controls;          bi->bi_controls = slap_known_controls;
   
         return 0;          return 0;
 }  }
   
 int  int
 meta_back_initialize(  meta_back_initialize(
         BackendInfo     *bi )                  BackendInfo     *bi
   )
 {  {
         bi->bi_open = meta_back_open;          bi->bi_open = meta_back_open;
         bi->bi_config = 0;          bi->bi_config = 0;
Line 47  meta_back_initialize( Line 47  meta_back_initialize(
   
         bi->bi_db_init = meta_back_db_init;          bi->bi_db_init = meta_back_db_init;
         bi->bi_db_config = meta_back_db_config;          bi->bi_db_config = meta_back_db_config;
         bi->bi_db_open = meta_back_db_open;          bi->bi_db_open = 0;
         bi->bi_db_close = 0;          bi->bi_db_close = 0;
         bi->bi_db_destroy = meta_back_db_destroy;          bi->bi_db_destroy = meta_back_db_destroy;
   
Line 73  meta_back_initialize( Line 73  meta_back_initialize(
   
 int  int
 meta_back_db_init(  meta_back_db_init(
         Backend         *be )                  Backend *be
   )
 {  {
         metainfo_t      *mi;          struct metainfo *li;
         int             i;  
           struct rewrite_info     *rwinfo;
   
           rwinfo = rewrite_info_init( REWRITE_MODE_USE_DEFAULT );
           if ( rwinfo == NULL ) {
                   return -1;
           }
   
         mi = ch_calloc( 1, sizeof( metainfo_t ) );          li = ch_calloc( 1, sizeof( struct metainfo ) );
         if ( mi == NULL ) {          if ( li == NULL ) {
                   rewrite_info_delete( &rwinfo );
                 return -1;                  return -1;
         }          }
   
Line 87  meta_back_db_init( Line 95  meta_back_db_init(
          * At present the default is no default target;           * At present the default is no default target;
          * this may change           * this may change
          */           */
         mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;          li->defaulttarget = META_DEFAULT_TARGET_NONE;
         mi->mi_bind_timeout.tv_sec = 0;          li->rwinfo = rwinfo;
         mi->mi_bind_timeout.tv_usec = META_BIND_TIMEOUT;  
           ldap_pvt_thread_mutex_init( &li->conn_mutex );
         mi->mi_rebind_f = meta_back_default_rebind;          ldap_pvt_thread_mutex_init( &li->cache.mutex );
           be->be_private = li;
         ldap_pvt_thread_mutex_init( &mi->mi_conninfo.lai_mutex );  
         ldap_pvt_thread_mutex_init( &mi->mi_cache.mutex );  
   
         /* safe default */  
         mi->mi_nretries = META_RETRY_DEFAULT;  
         mi->mi_version = LDAP_VERSION3;  
   
         for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {  
                 mi->mi_conn_priv[ i ].mic_num = 0;  
                 LDAP_TAILQ_INIT( &mi->mi_conn_priv[ i ].mic_priv );  
         }  
         mi->mi_conn_priv_max = LDAP_BACK_CONN_PRIV_DEFAULT;  
           
         be->be_private = mi;  
   
         return 0;          return 0;
 }  }
   
 int  static void
 meta_back_db_open(  conn_free( 
         Backend         *be )          void *v_lc
   )
 {  {
         metainfo_t      *mi = (metainfo_t *)be->be_private;          struct metaconn *lc = v_lc;
           struct metasingleconn *lsc;
   
         int             i,          for ( lsc = lc->conns; !META_LAST(lsc); lsc++ ) {
                         not_always = 0,                  if ( lsc->ld != NULL ) {
                         not_always_anon_proxyauthz = 0,                          ldap_unbind( lsc->ld );
                         not_always_anon_non_prescriptive = 0,  
                         rc;  
   
         if ( mi->mi_ntargets == 0 ) {  
                 Debug( LDAP_DEBUG_ANY,  
                         "meta_back_db_open: no targets defined\n",  
                         0, 0, 0 );  
                 return 1;  
         }  
   
         for ( i = 0; i < mi->mi_ntargets; i++ ) {  
                 metatarget_t    *mt = mi->mi_targets[ i ];  
   
                 if ( META_BACK_TGT_T_F_DISCOVER( mt ) ) {  
                         rc = slap_discover_feature( mt->mt_uri, mt->mt_version,  
                                         slap_schema.si_ad_supportedFeatures->ad_cname.bv_val,  
                                         LDAP_FEATURE_ABSOLUTE_FILTERS );  
                         if ( rc == LDAP_COMPARE_TRUE ) {  
                                 mt->mt_flags |= LDAP_BACK_F_T_F;  
                         }  
                 }                  }
                   if ( lsc->bound_dn.bv_val ) {
                 if ( META_BACK_TGT_CANCEL_DISCOVER( mt ) ) {                          ber_memfree( lsc->bound_dn.bv_val );
                         rc = slap_discover_feature( mt->mt_uri, mt->mt_version,  
                                         slap_schema.si_ad_supportedExtension->ad_cname.bv_val,  
                                         LDAP_EXOP_CANCEL );  
                         if ( rc == LDAP_COMPARE_TRUE ) {  
                                 mt->mt_flags |= LDAP_BACK_F_CANCEL_EXOP;  
                         }  
                 }                  }
                   if ( lsc->cred.bv_val ) {
                 if ( not_always == 0 ) {                          memset( lsc->cred.bv_val, 0, lsc->cred.bv_len );
                         if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_OVERRIDE )                          ber_memfree( lsc->cred.bv_val );
                                 || mt->mt_idassert_authz != NULL )  
                         {  
                                 not_always = 1;  
                         }  
                 }  
   
                 if ( ( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL )  
                         && !( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) )  
                 {  
                         Debug( LDAP_DEBUG_ANY, "meta_back_db_open(%s): "  
                                 "target #%d inconsistent idassert configuration "  
                                 "(likely authz=\"*\" used with \"non-prescriptive\" flag)\n",  
                                 be->be_suffix[ 0 ].bv_val, i, 0 );  
                         return 1;  
                 }  
   
                 if ( not_always_anon_proxyauthz == 0 ) {  
                         if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL ) )  
                         {  
                                 not_always_anon_proxyauthz = 1;  
                         }  
                 }  
   
                 if ( not_always_anon_non_prescriptive == 0 ) {  
                         if ( ( mt->mt_idassert_flags & LDAP_BACK_AUTH_PRESCRIPTIVE ) )  
                         {  
                                 not_always_anon_non_prescriptive = 1;  
                         }  
                 }                  }
         }          }
           free( lc->conns );
         if ( not_always == 0 ) {          free( lc );
                 mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ALWAYS;  
         }  
   
         if ( not_always_anon_proxyauthz == 0 ) {  
                 mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ANON;  
   
         } else if ( not_always_anon_non_prescriptive == 0 ) {  
                 mi->mi_flags |= META_BACK_F_PROXYAUTHZ_NOANON;  
         }  
   
         return 0;  
 }  
   
 /*  
  * meta_back_conn_free()  
  *  
  * actually frees a connection; the reference count must be 0,  
  * and it must not (or no longer) be in the cache.  
  */  
 void  
 meta_back_conn_free(   
         void            *v_mc )  
 {  
         metaconn_t              *mc = v_mc;  
         int                     ntargets;  
   
         assert( mc != NULL );  
         assert( mc->mc_refcnt == 0 );  
   
         /* at least one must be present... */  
         ntargets = mc->mc_info->mi_ntargets;  
         assert( ntargets > 0 );  
   
         for ( ; ntargets--; ) {  
                 (void)meta_clear_one_candidate( NULL, mc, ntargets );  
         }  
   
         if ( !BER_BVISNULL( &mc->mc_local_ndn ) ) {  
                 free( mc->mc_local_ndn.bv_val );  
         }  
   
         free( mc );  
 }  }
   
 static void  static void
 mapping_free(  mapping_free( void *v_mapping )
         void            *v_mapping )  
 {  {
         struct ldapmapping *mapping = v_mapping;          struct ldapmapping *mapping = v_mapping;
         ch_free( mapping->src.bv_val );          ch_free( mapping->src.bv_val );
Line 240  mapping_free( Line 139  mapping_free(
 }  }
   
 static void  static void
 mapping_dst_free(  
         void            *v_mapping )  
 {  
         struct ldapmapping *mapping = v_mapping;  
   
         if ( BER_BVISEMPTY( &mapping->dst ) ) {  
                 mapping_free( &mapping[ -1 ] );  
         }  
 }  
   
 static void  
 target_free(  target_free(
         metatarget_t    *mt )                  struct metatarget *lt
   )
 {  {
         if ( mt->mt_uri ) {          if ( lt->uri ) {
                 free( mt->mt_uri );                  free( lt->uri );
                 ldap_pvt_thread_mutex_destroy( &mt->mt_uri_mutex );  
         }  
         if ( mt->mt_subtree_exclude ) {  
                 ber_bvarray_free( mt->mt_subtree_exclude );  
         }  
         if ( !BER_BVISNULL( &mt->mt_psuffix ) ) {  
                 free( mt->mt_psuffix.bv_val );  
         }          }
         if ( !BER_BVISNULL( &mt->mt_nsuffix ) ) {          if ( lt->psuffix.bv_val ) {
                 free( mt->mt_nsuffix.bv_val );                  free( lt->psuffix.bv_val );
         }          }
         if ( !BER_BVISNULL( &mt->mt_binddn ) ) {          if ( lt->suffix.bv_val ) {
                 free( mt->mt_binddn.bv_val );                  free( lt->suffix.bv_val );
         }          }
         if ( !BER_BVISNULL( &mt->mt_bindpw ) ) {          if ( lt->binddn.bv_val ) {
                 free( mt->mt_bindpw.bv_val );                  free( lt->binddn.bv_val );
         }          }
         if ( !BER_BVISNULL( &mt->mt_idassert_authcID ) ) {          if ( lt->bindpw.bv_val ) {
                 ch_free( mt->mt_idassert_authcID.bv_val );                  free( lt->bindpw.bv_val );
         }          }
         if ( !BER_BVISNULL( &mt->mt_idassert_authcDN ) ) {          if ( lt->pseudorootdn.bv_val ) {
                 ch_free( mt->mt_idassert_authcDN.bv_val );                  free( lt->pseudorootdn.bv_val );
         }          }
         if ( !BER_BVISNULL( &mt->mt_idassert_passwd ) ) {          if ( lt->pseudorootpw.bv_val ) {
                 ch_free( mt->mt_idassert_passwd.bv_val );                  free( lt->pseudorootpw.bv_val );
         }          }
         if ( !BER_BVISNULL( &mt->mt_idassert_authzID ) ) {          if ( lt->rwmap.rwm_rw ) {
                 ch_free( mt->mt_idassert_authzID.bv_val );                  rewrite_info_delete( &lt->rwmap.rwm_rw );
         }          }
         if ( !BER_BVISNULL( &mt->mt_idassert_sasl_mech ) ) {          avl_free( lt->rwmap.rwm_oc.remap, NULL );
                 ch_free( mt->mt_idassert_sasl_mech.bv_val );          avl_free( lt->rwmap.rwm_oc.map, mapping_free );
         }          avl_free( lt->rwmap.rwm_at.remap, NULL );
         if ( !BER_BVISNULL( &mt->mt_idassert_sasl_realm ) ) {          avl_free( lt->rwmap.rwm_at.map, mapping_free );
                 ch_free( mt->mt_idassert_sasl_realm.bv_val );  
         }  
         if ( mt->mt_idassert_authz != NULL ) {  
                 ber_bvarray_free( mt->mt_idassert_authz );  
         }  
         if ( mt->mt_rwmap.rwm_rw ) {  
                 rewrite_info_delete( &mt->mt_rwmap.rwm_rw );  
         }  
         avl_free( mt->mt_rwmap.rwm_oc.remap, mapping_dst_free );  
         avl_free( mt->mt_rwmap.rwm_oc.map, mapping_free );  
         avl_free( mt->mt_rwmap.rwm_at.remap, mapping_dst_free );  
         avl_free( mt->mt_rwmap.rwm_at.map, mapping_free );  
   
         free( mt );  
 }  }
   
 int  int
 meta_back_db_destroy(  meta_back_db_destroy(
         Backend         *be )      Backend     *be
   )
 {  {
         metainfo_t      *mi;          struct metainfo *li;
   
         if ( be->be_private ) {          if ( be->be_private ) {
                 int i;                  int i;
   
                 mi = ( metainfo_t * )be->be_private;                  li = ( struct metainfo * )be->be_private;
   
                 /*                  /*
                  * Destroy the connection tree                   * Destroy the connection tree
                  */                   */
                 ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );                  ldap_pvt_thread_mutex_lock( &li->conn_mutex );
   
                 if ( mi->mi_conninfo.lai_tree ) {                  if ( li->conntree ) {
                         avl_free( mi->mi_conninfo.lai_tree, meta_back_conn_free );                          avl_free( li->conntree, conn_free );
                 }  
                 for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {  
                         while ( !LDAP_TAILQ_EMPTY( &mi->mi_conn_priv[ i ].mic_priv ) ) {  
                                 metaconn_t      *mc = LDAP_TAILQ_FIRST( &mi->mi_conn_priv[ i ].mic_priv );  
   
                                 LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ i ].mic_priv, mc, mc_q );  
                                 meta_back_conn_free( mc );  
                         }  
                 }                  }
   
                 /*                  /*
                  * Destroy the per-target stuff (assuming there's at                   * Destroy the per-target stuff (assuming there's at
                  * least one ...)                   * least one ...)
                  */                   */
                 if ( mi->mi_targets != NULL ) {                  for ( i = 0; i < li->ntargets; i++ ) {
                         for ( i = 0; i < mi->mi_ntargets; i++ ) {                          target_free( li->targets[ i ] );
                                 metatarget_t    *mt = mi->mi_targets[ i ];                          free( li->targets[ i ] );
   
                                 if ( META_BACK_TGT_QUARANTINE( mt ) ) {  
                                         if ( mt->mt_quarantine.ri_num != mi->mi_quarantine.ri_num )  
                                         {  
                                                 slap_retry_info_destroy( &mt->mt_quarantine );  
                                         }  
   
                                         ldap_pvt_thread_mutex_destroy( &mt->mt_quarantine_mutex );  
                                 }  
   
                                 target_free( mt );  
                         }  
   
                         free( mi->mi_targets );  
                 }                  }
   
                 ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex );                  free( li->targets );
                 if ( mi->mi_cache.tree ) {  
                         avl_free( mi->mi_cache.tree, meta_dncache_free );  
                 }  
                   
                 ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex );  
                 ldap_pvt_thread_mutex_destroy( &mi->mi_cache.mutex );  
   
                 ldap_pvt_thread_mutex_unlock( &mi->mi_conninfo.lai_mutex );                  ldap_pvt_thread_mutex_lock( &li->cache.mutex );
                 ldap_pvt_thread_mutex_destroy( &mi->mi_conninfo.lai_mutex );                  if ( li->cache.tree ) {
                           avl_free( li->cache.tree, meta_dncache_free );
                 if ( mi->mi_candidates != NULL ) {  
                         ber_memfree_x( mi->mi_candidates, NULL );  
                 }                  }
                   
                   ldap_pvt_thread_mutex_unlock( &li->cache.mutex );
                   ldap_pvt_thread_mutex_destroy( &li->cache.mutex );
   
                 if ( META_BACK_QUARANTINE( mi ) ) {                  ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
                         slap_retry_info_destroy( &mi->mi_quarantine );                  ldap_pvt_thread_mutex_destroy( &li->conn_mutex );
                 }  
         }          }
   
         free( be->be_private );          free( be->be_private );

Removed from v.1.37.2.17  
changed lines
  Added in v.1.38


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