Diff for /servers/slapd/back-meta/init.c between versions 1.37 and 1.37.2.14

version 1.37, 2004/11/15 18:45:50 version 1.37.2.14, 2007/01/05 09:47:10
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/init.c,v 1.36 2004/11/13 17:52:45 ando Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-meta/init.c,v 1.37.2.13 2007/01/02 21:44:04 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-2004 The OpenLDAP Foundation.   * Copyright 1999-2007 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 = 0;          bi->bi_db_open = meta_back_db_open;
         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 )
 )  
 {  {
         struct metainfo *li;          metainfo_t      *mi;
           int             i;
         struct rewrite_info     *rwinfo;  
   
         rwinfo = rewrite_info_init( REWRITE_MODE_USE_DEFAULT );  
         if ( rwinfo == NULL ) {  
                 return -1;  
         }  
   
         li = ch_calloc( 1, sizeof( struct metainfo ) );          mi = ch_calloc( 1, sizeof( metainfo_t ) );
         if ( li == NULL ) {          if ( mi == NULL ) {
                 rewrite_info_delete( &rwinfo );  
                 return -1;                  return -1;
         }          }
   
Line 95  meta_back_db_init( Line 87  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
          */           */
         li->defaulttarget = META_DEFAULT_TARGET_NONE;          mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
         li->rwinfo = rwinfo;          mi->mi_bind_timeout.tv_sec = 0;
           mi->mi_bind_timeout.tv_usec = META_BIND_TIMEOUT;
         ldap_pvt_thread_mutex_init( &li->conn_mutex );  
         ldap_pvt_thread_mutex_init( &li->cache.mutex );          mi->mi_rebind_f = meta_back_default_rebind;
         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;
 }  }
   
 static void  int
 conn_free(   meta_back_db_open(
         void *v_lc          Backend         *be )
 )  
 {  {
         struct metaconn *lc = v_lc;          metainfo_t      *mi = (metainfo_t *)be->be_private;
         struct metasingleconn *lsc;  
   
         for ( lsc = lc->conns; !META_LAST(lsc); lsc++ ) {          int             i,
                 if ( lsc->ld != NULL ) {                          not_always = 0,
                         ldap_unbind( lsc->ld );                          rc;
   
           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 ) {  
                         ber_memfree( lsc->bound_dn.bv_val );                  if ( META_BACK_TGT_CANCEL_DISCOVER( mt ) ) {
                           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 ) {  
                         memset( lsc->cred.bv_val, 0, lsc->cred.bv_len );                  if ( not_always == 0 ) {
                         ber_memfree( lsc->cred.bv_val );                          if ( !( mt->mt_idassert_flags & LDAP_BACK_AUTH_OVERRIDE )
                                   || !( mt->mt_idassert_flags & LDAP_BACK_AUTH_AUTHZ_ALL ) )
                           {
                                   not_always = 1;
                           }
                 }                  }
         }          }
         free( lc->conns );  
         free( lc );          if ( not_always == 0 ) {
                   mi->mi_flags |= META_BACK_F_PROXYAUTHZ_ALWAYS;
           }
   
           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( void *v_mapping )  mapping_free(
           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 139  mapping_free( void *v_mapping ) Line 200  mapping_free( void *v_mapping )
 }  }
   
 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(
                 struct metatarget *lt          metatarget_t    *mt )
 )  
 {  {
         if ( lt->uri ) {          if ( mt->mt_uri ) {
                 free( lt->uri );                  free( mt->mt_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 ) ) {
                   free( mt->mt_nsuffix.bv_val );
           }
           if ( !BER_BVISNULL( &mt->mt_binddn ) ) {
                   free( mt->mt_binddn.bv_val );
         }          }
         if ( lt->psuffix.bv_val ) {          if ( !BER_BVISNULL( &mt->mt_bindpw ) ) {
                 free( lt->psuffix.bv_val );                  free( mt->mt_bindpw.bv_val );
         }          }
         if ( lt->suffix.bv_val ) {          if ( !BER_BVISNULL( &mt->mt_idassert_authcID ) ) {
                 free( lt->suffix.bv_val );                  ch_free( mt->mt_idassert_authcID.bv_val );
         }          }
         if ( lt->binddn.bv_val ) {          if ( !BER_BVISNULL( &mt->mt_idassert_authcDN ) ) {
                 free( lt->binddn.bv_val );                  ch_free( mt->mt_idassert_authcDN.bv_val );
         }          }
         if ( lt->bindpw.bv_val ) {          if ( !BER_BVISNULL( &mt->mt_idassert_passwd ) ) {
                 free( lt->bindpw.bv_val );                  ch_free( mt->mt_idassert_passwd.bv_val );
         }          }
         if ( lt->pseudorootdn.bv_val ) {          if ( !BER_BVISNULL( &mt->mt_idassert_authzID ) ) {
                 free( lt->pseudorootdn.bv_val );                  ch_free( mt->mt_idassert_authzID.bv_val );
         }          }
         if ( lt->pseudorootpw.bv_val ) {          if ( !BER_BVISNULL( &mt->mt_idassert_sasl_mech ) ) {
                 free( lt->pseudorootpw.bv_val );                  ch_free( mt->mt_idassert_sasl_mech.bv_val );
         }          }
         if ( lt->rwmap.rwm_rw ) {          if ( !BER_BVISNULL( &mt->mt_idassert_sasl_realm ) ) {
                 rewrite_info_delete( &lt->rwmap.rwm_rw );                  ch_free( mt->mt_idassert_sasl_realm.bv_val );
         }          }
         avl_free( lt->rwmap.rwm_oc.remap, NULL );          if ( mt->mt_idassert_authz != NULL ) {
         avl_free( lt->rwmap.rwm_oc.map, mapping_free );                  ber_bvarray_free( mt->mt_idassert_authz );
         avl_free( lt->rwmap.rwm_at.remap, NULL );          }
         avl_free( lt->rwmap.rwm_at.map, mapping_free );          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 )
 )  
 {  {
         struct metainfo *li;          metainfo_t      *mi;
   
         if ( be->be_private ) {          if ( be->be_private ) {
                 int i;                  int i;
   
                 li = ( struct metainfo * )be->be_private;                  mi = ( metainfo_t * )be->be_private;
   
                 /*                  /*
                  * Destroy the connection tree                   * Destroy the connection tree
                  */                   */
                 ldap_pvt_thread_mutex_lock( &li->conn_mutex );                  ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
   
                 if ( li->conntree ) {                  if ( mi->mi_conninfo.lai_tree ) {
                         avl_free( li->conntree, conn_free );                          avl_free( mi->mi_conninfo.lai_tree, meta_back_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 ...)
                  */                   */
                 for ( i = 0; i < li->ntargets; i++ ) {                  if ( mi->mi_targets != NULL ) {
                         target_free( li->targets[ i ] );                          for ( i = 0; i < mi->mi_ntargets; i++ ) {
                         free( li->targets[ i ] );                                  metatarget_t    *mt = mi->mi_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 );
                                   }
   
                 free( li->targets );                                  target_free( mt );
                           }
   
                 ldap_pvt_thread_mutex_lock( &li->cache.mutex );                          free( mi->mi_targets );
                 if ( li->cache.tree ) {                  }
                         avl_free( li->cache.tree, meta_dncache_free );  
                   ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex );
                   if ( mi->mi_cache.tree ) {
                           avl_free( mi->mi_cache.tree, meta_dncache_free );
                 }                  }
                                   
                 ldap_pvt_thread_mutex_unlock( &li->cache.mutex );                  ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex );
                 ldap_pvt_thread_mutex_destroy( &li->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_destroy( &mi->mi_conninfo.lai_mutex );
   
                 ldap_pvt_thread_mutex_unlock( &li->conn_mutex );                  if ( mi->mi_candidates != NULL ) {
                 ldap_pvt_thread_mutex_destroy( &li->conn_mutex );                          ber_memfree_x( mi->mi_candidates, NULL );
                   }
   
                   if ( META_BACK_QUARANTINE( mi ) ) {
                           slap_retry_info_destroy( &mi->mi_quarantine );
                   }
         }          }
   
         free( be->be_private );          free( be->be_private );

Removed from v.1.37  
changed lines
  Added in v.1.37.2.14


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