X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Finit.c;h=8018f46f1f64676ac5cfb8a9ca8c97dc83870034;hb=0394c805abe5208f43255aff3b7c24a3337d2529;hp=4476d6a40e8317b5267100ed95ed27254764877a;hpb=eda2b46dd26b9c7e8ee202ad8292a2446936ddfb;p=openldap diff --git a/servers/slapd/init.c b/servers/slapd/init.c index 4476d6a40e..8018f46f1f 100644 --- a/servers/slapd/init.c +++ b/servers/slapd/init.c @@ -2,7 +2,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2006 The OpenLDAP Foundation. + * Copyright 1998-2009 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -55,28 +55,14 @@ int ldap_syslog_level = LOG_DEBUG; BerVarray default_referral = NULL; -struct berval AllUser = BER_BVC( LDAP_ALL_USER_ATTRIBUTES ); -struct berval AllOper = BER_BVC( LDAP_ALL_OPERATIONAL_ATTRIBUTES ); -struct berval NoAttrs = BER_BVC( LDAP_NO_ATTRS ); - /* * global variables that need mutex protection */ ldap_pvt_thread_pool_t connection_pool; int connection_pool_max = SLAP_MAX_WORKER_THREADS; int slap_tool_thread_max = 1; -#ifndef HAVE_GMTIME_R -ldap_pvt_thread_mutex_t gmtime_mutex; -#endif -slap_counters_t slap_counters; - -/* - * these mutexes must be used when calling the entry2str() - * routine since it returns a pointer to static data. - */ -ldap_pvt_thread_mutex_t entry2str_mutex; -ldap_pvt_thread_mutex_t replog_mutex; +slap_counters_t slap_counters, *slap_counters_list; static const char* slap_name = NULL; int slapMode = SLAP_UNDEFINED_MODE; @@ -85,7 +71,6 @@ int slap_init( int mode, const char *name ) { int rc; - int i; assert( mode ); @@ -101,6 +86,8 @@ slap_init( int mode, const char *name ) slapMode = mode; + slap_op_init(); + #ifdef SLAPD_MODULES if ( module_init() != 0 ) { slap_debug |= LDAP_DEBUG_NONE; @@ -119,9 +106,25 @@ slap_init( int mode, const char *name ) return 1; } + if ( filter_init() != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: filter_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( entry_init() != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: entry_init failed\n", + name, 0, 0 ); + return 1; + } switch ( slapMode & SLAP_MODE ) { case SLAP_SERVER_MODE: + root_dse_init(); /* FALLTHRU */ case SLAP_TOOL_MODE: @@ -134,33 +137,13 @@ slap_init( int mode, const char *name ) ldap_pvt_thread_pool_init( &connection_pool, connection_pool_max, 0); - ldap_pvt_thread_mutex_init( &entry2str_mutex ); - ldap_pvt_thread_mutex_init( &replog_mutex ); - ldap_pvt_thread_mutex_init( &slap_counters.sc_sent_mutex ); - ldap_pvt_thread_mutex_init( &slap_counters.sc_ops_mutex ); - ldap_pvt_mp_init( slap_counters.sc_bytes ); - ldap_pvt_mp_init( slap_counters.sc_pdu ); - ldap_pvt_mp_init( slap_counters.sc_entries ); - ldap_pvt_mp_init( slap_counters.sc_refs ); - - ldap_pvt_mp_init( slap_counters.sc_ops_initiated ); - ldap_pvt_mp_init( slap_counters.sc_ops_completed ); + slap_counters_init( &slap_counters ); ldap_pvt_thread_mutex_init( &slapd_rq.rq_mutex ); LDAP_STAILQ_INIT( &slapd_rq.task_list ); LDAP_STAILQ_INIT( &slapd_rq.run_list ); -#ifdef SLAPD_MONITOR - for ( i = 0; i < SLAP_OP_LAST; i++ ) { - ldap_pvt_mp_init( slap_counters.sc_ops_initiated_[ i ] ); - ldap_pvt_mp_init( slap_counters.sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ - -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_init( &gmtime_mutex ); -#endif slap_passwd_init(); rc = slap_sasl_init(); @@ -168,6 +151,8 @@ slap_init( int mode, const char *name ) if( rc == 0 ) { rc = backend_init( ); } + if ( rc ) + return rc; break; @@ -188,16 +173,6 @@ slap_init( int mode, const char *name ) return 1; } -#ifdef HAVE_TLS - /* Library defaults to full certificate checking. This is correct when - * a client is verifying a server because all servers should have a - * valid cert. But few clients have valid certs, so we want our default - * to be no checking. The config file can override this as usual. - */ - rc = 0; - (void) ldap_pvt_tls_set_option( NULL, LDAP_OPT_X_TLS_REQUIRE_CERT, &rc ); -#endif - if ( frontend_init() ) { slap_debug |= LDAP_DEBUG_NONE; Debug( LDAP_DEBUG_ANY, @@ -257,7 +232,6 @@ int slap_shutdown( Backend *be ) int slap_destroy(void) { int rc; - int i; Debug( LDAP_DEBUG_TRACE, "%s destroy: freeing system resources.\n", @@ -267,31 +241,22 @@ int slap_destroy(void) ber_bvarray_free( default_referral ); } + /* clear out any thread-keys for the main thread */ + ldap_pvt_thread_pool_context_reset( ldap_pvt_thread_pool_context()); + rc = backend_destroy(); slap_sasl_destroy(); + /* rootdse destroy goes before entry_destroy() + * because it may use entry_free() */ + root_dse_destroy(); entry_destroy(); switch ( slapMode & SLAP_MODE ) { case SLAP_SERVER_MODE: case SLAP_TOOL_MODE: - - ldap_pvt_thread_mutex_destroy( &slap_counters.sc_sent_mutex ); - ldap_pvt_thread_mutex_destroy( &slap_counters.sc_ops_mutex ); - ldap_pvt_mp_clear( slap_counters.sc_bytes ); - ldap_pvt_mp_clear( slap_counters.sc_pdu ); - ldap_pvt_mp_clear( slap_counters.sc_entries ); - ldap_pvt_mp_clear( slap_counters.sc_refs ); - ldap_pvt_mp_clear( slap_counters.sc_ops_initiated ); - ldap_pvt_mp_clear( slap_counters.sc_ops_completed ); - -#ifdef SLAPD_MONITOR - for ( i = 0; i < SLAP_OP_LAST; i++ ) { - ldap_pvt_mp_clear( slap_counters.sc_ops_initiated_[ i ] ); - ldap_pvt_mp_clear( slap_counters.sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ + slap_counters_destroy( &slap_counters ); break; default: @@ -303,8 +268,53 @@ int slap_destroy(void) } + slap_op_destroy(); + ldap_pvt_thread_destroy(); - /* should destory the above mutex */ + /* should destroy the above mutex */ return rc; } + +void slap_counters_init( slap_counters_t *sc ) +{ + int i; + + ldap_pvt_thread_mutex_init( &sc->sc_mutex ); + ldap_pvt_mp_init( sc->sc_bytes ); + ldap_pvt_mp_init( sc->sc_pdu ); + ldap_pvt_mp_init( sc->sc_entries ); + ldap_pvt_mp_init( sc->sc_refs ); + + ldap_pvt_mp_init( sc->sc_ops_initiated ); + ldap_pvt_mp_init( sc->sc_ops_completed ); + +#ifdef SLAPD_MONITOR + for ( i = 0; i < SLAP_OP_LAST; i++ ) { + ldap_pvt_mp_init( sc->sc_ops_initiated_[ i ] ); + ldap_pvt_mp_init( sc->sc_ops_completed_[ i ] ); + } +#endif /* SLAPD_MONITOR */ +} + +void slap_counters_destroy( slap_counters_t *sc ) +{ + int i; + + ldap_pvt_thread_mutex_destroy( &sc->sc_mutex ); + ldap_pvt_mp_clear( sc->sc_bytes ); + ldap_pvt_mp_clear( sc->sc_pdu ); + ldap_pvt_mp_clear( sc->sc_entries ); + ldap_pvt_mp_clear( sc->sc_refs ); + + ldap_pvt_mp_clear( sc->sc_ops_initiated ); + ldap_pvt_mp_clear( sc->sc_ops_completed ); + +#ifdef SLAPD_MONITOR + for ( i = 0; i < SLAP_OP_LAST; i++ ) { + ldap_pvt_mp_clear( sc->sc_ops_initiated_[ i ] ); + ldap_pvt_mp_clear( sc->sc_ops_completed_[ i ] ); + } +#endif /* SLAPD_MONITOR */ +} +