X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Finit.c;h=8cf3c7ae0e1fe3fc1874f783b5fe47cf1f68c278;hb=a17df0e810578d593808c6afeb0cdea55a65633c;hp=c20bb4bbd64ce8eb4bf65517d362568f2196352c;hpb=f0190506f1ac4175345a5bb90d5c73376c657ef0;p=openldap diff --git a/servers/slapd/init.c b/servers/slapd/init.c index c20bb4bbd6..8cf3c7ae0e 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-2004 The OpenLDAP Foundation. + * Copyright 1998-2006 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -38,6 +38,8 @@ #include "slapi/slapi.h" #endif +#include "ldap_rq.h" + /* * read-only global variables or variables only written by the listener * thread (after they are initialized) - no need to protect them with a mutex. @@ -65,12 +67,10 @@ struct berval NoAttrs = BER_BVC( LDAP_NO_ATTRS ); */ 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 -#if defined( SLAPD_CRYPT ) || defined( SLAPD_SPASSWD ) -ldap_pvt_thread_mutex_t passwd_mutex; -#endif slap_counters_t slap_counters; @@ -93,6 +93,8 @@ slap_init( int mode, const char *name ) assert( mode ); if ( slapMode != SLAP_UNDEFINED_MODE ) { + /* Make sure we write something to stderr */ + slap_debug |= LDAP_DEBUG_NONE; Debug( LDAP_DEBUG_ANY, "%s init: init called twice (old=%d, new=%d)\n", name, slapMode, mode ); @@ -102,15 +104,35 @@ slap_init( int mode, const char *name ) slapMode = mode; +#ifdef SLAPD_MODULES + if ( module_init() != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: module_init failed\n", + name, 0, 0 ); + return 1; + } +#endif + + if ( slap_schema_init( ) != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: slap_schema_init failed\n", + name, 0, 0 ); + return 1; + } + + switch ( slapMode & SLAP_MODE ) { case SLAP_SERVER_MODE: + + /* FALLTHRU */ case SLAP_TOOL_MODE: Debug( LDAP_DEBUG_TRACE, "%s init: initiated %s.\n", name, (mode & SLAP_MODE) == SLAP_TOOL_MODE ? "tool" : "server", 0 ); - slap_name = name; ldap_pvt_thread_pool_init( &connection_pool, @@ -121,43 +143,29 @@ slap_init( int mode, const char *name ) ldap_pvt_thread_mutex_init( &slap_counters.sc_sent_mutex ); ldap_pvt_thread_mutex_init( &slap_counters.sc_ops_mutex ); -#ifdef HAVE_GMP - mpz_init( slap_counters.sc_bytes ); - mpz_init( slap_counters.sc_pdu ); - mpz_init( slap_counters.sc_entries ); - mpz_init( slap_counters.sc_refs ); + 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 ); - mpz_init( slap_counters.sc_ops_completed ); - mpz_init( slap_counters.sc_ops_initiated ); + ldap_pvt_mp_init( slap_counters.sc_ops_initiated ); + ldap_pvt_mp_init( slap_counters.sc_ops_completed ); + + 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++ ) { - mpz_init( slap_counters.sc_ops_initiated_[ i ] ); - mpz_init( slap_counters.sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ -#else /* ! HAVE_GMP */ - slap_counters.sc_bytes = 0; - slap_counters.sc_pdu = 0; - slap_counters.sc_entries = 0; - slap_counters.sc_refs = 0; - - slap_counters.sc_ops_completed = 0; - slap_counters.sc_ops_initiated = 0; -#ifdef SLAPD_MONITOR - for ( i = 0; i < SLAP_OP_LAST; i++ ) { - slap_counters.sc_ops_initiated_[ i ] = 0; - slap_counters.sc_ops_completed_[ i ] = 0; + ldap_pvt_mp_init( slap_counters.sc_ops_initiated_[ i ] ); + ldap_pvt_mp_init( slap_counters.sc_ops_completed_[ i ] ); } #endif /* SLAPD_MONITOR */ -#endif /* ! HAVE_GMP */ #ifndef HAVE_GMTIME_R ldap_pvt_thread_mutex_init( &gmtime_mutex ); #endif -#if defined( SLAPD_CRYPT ) || defined( SLAPD_SPASSWD ) - ldap_pvt_thread_mutex_init( &passwd_mutex ); -#endif + slap_passwd_init(); rc = slap_sasl_init(); @@ -168,6 +176,7 @@ slap_init( int mode, const char *name ) break; default: + slap_debug |= LDAP_DEBUG_NONE; Debug( LDAP_DEBUG_ANY, "%s init: undefined mode (%d).\n", name, mode, 0 ); @@ -175,6 +184,57 @@ slap_init( int mode, const char *name ) break; } + if ( slap_controls_init( ) != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: slap_controls_init failed\n", + name, 0, 0 ); + 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, + "%s: frontend_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( overlay_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: overlay_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( glue_sub_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: glue/subordinate init failed\n", + name, 0, 0 ); + + return 1; + } + + if ( acl_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: acl_init failed\n", + name, 0, 0 ); + return 1; + } + return rc; } @@ -193,7 +253,7 @@ int slap_startup( Backend *be ) if( rc == 0 ) { Slapi_PBlock *pb = slapi_pblock_new(); - if ( slapi_int_call_plugins( NULL, SLAPI_PLUGIN_START_FN, pb ) < 0 ) { + if ( slapi_int_call_plugins( frontendDB, SLAPI_PLUGIN_START_FN, pb ) < 0 ) { rc = -1; } slapi_pblock_destroy( pb ); @@ -219,7 +279,7 @@ int slap_shutdown( Backend *be ) #ifdef LDAP_SLAPI pb = slapi_pblock_new(); - (void) slapi_int_call_plugins( NULL, SLAPI_PLUGIN_CLOSE_FN, pb ); + (void) slapi_int_call_plugins( frontendDB, SLAPI_PLUGIN_CLOSE_FN, pb ); slapi_pblock_destroy( pb ); #endif /* LDAP_SLAPI */ @@ -251,21 +311,19 @@ int slap_destroy(void) ldap_pvt_thread_mutex_destroy( &slap_counters.sc_sent_mutex ); ldap_pvt_thread_mutex_destroy( &slap_counters.sc_ops_mutex ); -#ifdef HAVE_GMP - mpz_clear( slap_counters.sc_bytes ); - mpz_clear( slap_counters.sc_pdu ); - mpz_clear( slap_counters.sc_entries ); - mpz_clear( slap_counters.sc_refs ); - mpz_clear( slap_counters.sc_ops_completed ); - mpz_clear( slap_counters.sc_ops_initiated ); + 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++ ) { - mpz_clear( slap_counters.sc_ops_initiated_[ i ] ); - mpz_clear( slap_counters.sc_ops_completed_[ i ] ); + ldap_pvt_mp_clear( slap_counters.sc_ops_initiated_[ i ] ); + ldap_pvt_mp_clear( slap_counters.sc_ops_completed_[ i ] ); } #endif /* SLAPD_MONITOR */ -#endif /* HAVE_GMP */ break; default: