From 7731832751ab9f3c6ddeb66f186d3d7fa1934a6d Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 13:11:40 +0200 Subject: Adding upstream version 2.4.57+dfsg. Signed-off-by: Daniel Baumann --- servers/slapd/init.c | 323 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 servers/slapd/init.c (limited to 'servers/slapd/init.c') diff --git a/servers/slapd/init.c b/servers/slapd/init.c new file mode 100644 index 0000000..043c3dd --- /dev/null +++ b/servers/slapd/init.c @@ -0,0 +1,323 @@ +/* init.c - initialize various things */ +/* $OpenLDAP$ */ +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2021 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . + */ +/* Portions Copyright (c) 1995 Regents of the University of Michigan. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that this notice is preserved and that due credit is given + * to the University of Michigan at Ann Arbor. The name of the University + * may not be used to endorse or promote products derived from this + * software without specific prior written permission. This software + * is provided ``as is'' without express or implied warranty. + */ + +#include "portable.h" + +#include + +#include +#include +#include + +#include "slap.h" +#include "lber_pvt.h" + +#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. + */ +int slap_debug = 0; + +#ifdef LDAP_DEBUG +int ldap_syslog = LDAP_DEBUG_STATS; +#else +int ldap_syslog; +#endif + +#ifdef LOG_DEBUG +int ldap_syslog_level = LOG_DEBUG; +#endif + +BerVarray default_referral = NULL; + +/* + * 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; + +slap_counters_t slap_counters, *slap_counters_list; + +static const char* slap_name = NULL; +int slapMode = SLAP_UNDEFINED_MODE; + +int +slap_init( int mode, const char *name ) +{ + int rc; + + 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 ); + + return 1; + } + + slapMode = mode; + + slap_op_init(); + +#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; + } + + 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: + 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, + connection_pool_max, 0); + + 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 ); + + slap_passwd_init(); + + rc = slap_sasl_init(); + + if( rc == 0 ) { + rc = backend_init( ); + } + if ( rc ) + return rc; + + break; + + default: + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s init: undefined mode (%d).\n", name, mode, 0 ); + + rc = 1; + 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; + } + + 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; +} + +int slap_startup( Backend *be ) +{ + int rc; + Debug( LDAP_DEBUG_TRACE, + "%s startup: initiated.\n", + slap_name, 0, 0 ); + + rc = backend_startup( be ); + if ( !rc && ( slapMode & SLAP_SERVER_MODE )) + slapMode |= SLAP_SERVER_RUNNING; + return rc; +} + +int slap_shutdown( Backend *be ) +{ + Debug( LDAP_DEBUG_TRACE, + "%s shutdown: initiated\n", + slap_name, 0, 0 ); + + /* let backends do whatever cleanup they need to do */ + return backend_shutdown( be ); +} + +int slap_destroy(void) +{ + int rc; + + Debug( LDAP_DEBUG_TRACE, + "%s destroy: freeing system resources.\n", + slap_name, 0, 0 ); + + if ( default_referral ) { + 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: + slap_counters_destroy( &slap_counters ); + break; + + default: + Debug( LDAP_DEBUG_ANY, + "slap_destroy(): undefined mode (%d).\n", slapMode, 0, 0 ); + + rc = 1; + break; + + } + + slap_op_destroy(); + + ldap_pvt_thread_destroy(); + + /* 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 */ +} + -- cgit v1.2.3