From 67ed7c6017c6d310cc203ea5898f769a76748048 Mon Sep 17 00:00:00 2001 From: William Brown Date: Thu, 8 Dec 2016 15:26:53 +1000 Subject: [PATCH] Ticket 49066 - Memory leaks in server Bug Description: This resolves a number of memory leaks and code cleanups in the server. Fix Description: This fixes leaks from server shutdown especially in ldbm which was not freeing the entry cache correctly. https://fedorahosted.org/389/ticket/49066 Author: wibrown Review by: ??? --- ldap/servers/plugins/pwdstorage/crypt_pwd.c | 12 +++++- ldap/servers/plugins/pwdstorage/pwd_init.c | 35 +++++++++-------- ldap/servers/plugins/pwdstorage/pwdstorage.h | 3 +- ldap/servers/plugins/replication/cl5_api.c | 7 +++- ldap/servers/plugins/retrocl/retrocl_trim.c | 2 + ldap/servers/slapd/back-ldbm/cleanup.c | 6 ++- ldap/servers/slapd/back-ldbm/close.c | 3 ++ ldap/servers/slapd/back-ldbm/instance.c | 36 +++++------------ ldap/servers/slapd/back-ldbm/ldbm_config.c | 12 ++++++ ldap/servers/slapd/back-ldbm/ldbm_config.h | 1 + ldap/servers/slapd/back-ldbm/proto-back-ldbm.h | 4 +- ldap/servers/slapd/backend_manager.c | 44 +++++---------------- ldap/servers/slapd/daemon.c | 54 ++++++++++++++------------ ldap/servers/slapd/defbackend.c | 7 ++-- ldap/servers/slapd/fedse.c | 4 +- ldap/servers/slapd/pblock.c | 4 ++ ldap/servers/slapd/plugin.c | 54 +++++++++++++------------- ldap/servers/slapd/proto-slap.h | 2 +- ldap/servers/slapd/schema.c | 12 ++++-- ldap/servers/slapd/uuid.c | 9 +++-- ldap/servers/slapd/valueset.c | 14 ++++--- ldap/servers/slapd/vattr.c | 27 ++++++++----- 22 files changed, 185 insertions(+), 167 deletions(-) diff --git a/ldap/servers/plugins/pwdstorage/crypt_pwd.c b/ldap/servers/plugins/pwdstorage/crypt_pwd.c index 93b54b2..0fd3b85 100644 --- a/ldap/servers/plugins/pwdstorage/crypt_pwd.c +++ b/ldap/servers/plugins/pwdstorage/crypt_pwd.c @@ -39,10 +39,18 @@ static unsigned char itoa64[] = /* 0 ... 63 => ascii - 64 */ -void -crypt_init() +int +crypt_start(Slapi_PBlock *pb __attribute__((unused))) { cryptlock = PR_NewLock(); + return 0; +} + +int +crypt_close(Slapi_PBlock *pb __attribute__((unused))) +{ + PR_DestroyLock(cryptlock); + return 0; } int diff --git a/ldap/servers/plugins/pwdstorage/pwd_init.c b/ldap/servers/plugins/pwdstorage/pwd_init.c index 779c7fb..0781c09 100644 --- a/ldap/servers/plugins/pwdstorage/pwd_init.c +++ b/ldap/servers/plugins/pwdstorage/pwd_init.c @@ -231,24 +231,25 @@ ssha512_pwd_storage_scheme_init( Slapi_PBlock *pb ) int crypt_pwd_storage_scheme_init( Slapi_PBlock *pb ) { - int rc; - - slapi_log_err(SLAPI_LOG_PLUGIN, plugin_name, "=> crypt_pwd_storage_scheme_init\n" ); - - crypt_init(); - rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION, - (void *) SLAPI_PLUGIN_VERSION_01 ); - rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION, - (void *)&crypt_pdesc ); - rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_ENC_FN, - (void *) crypt_pw_enc ); - rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_CMP_FN, - (void *) crypt_pw_cmp ); - rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME, - "CRYPT" ); + int rc; - slapi_log_err(SLAPI_LOG_PLUGIN, plugin_name, "<= crypt_pwd_storage_scheme_init %d\n\n", rc ); - return( rc ); + slapi_log_err(SLAPI_LOG_PLUGIN, plugin_name, "=> crypt_pwd_storage_scheme_init\n" ); + + rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION, + (void *) SLAPI_PLUGIN_VERSION_01 ); + rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION, + (void *)&crypt_pdesc ); + rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_START_FN, (void*)&crypt_start); + rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_CLOSE_FN, (void*)&crypt_close); + rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_ENC_FN, + (void *) crypt_pw_enc ); + rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_CMP_FN, + (void *) crypt_pw_cmp ); + rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME, + "CRYPT" ); + + slapi_log_err(SLAPI_LOG_PLUGIN, plugin_name, "<= crypt_pwd_storage_scheme_init %d\n\n", rc ); + return( rc ); } int diff --git a/ldap/servers/plugins/pwdstorage/pwdstorage.h b/ldap/servers/plugins/pwdstorage/pwdstorage.h index 27e708d..d48b634 100644 --- a/ldap/servers/plugins/pwdstorage/pwdstorage.h +++ b/ldap/servers/plugins/pwdstorage/pwdstorage.h @@ -76,7 +76,8 @@ char * sha512_pw_enc( const char *pwd ); char * salted_sha512_pw_enc( const char *pwd ); int clear_pw_cmp( const char *userpwd, const char *dbpwd ); char *clear_pw_enc( const char *pwd ); -void crypt_init(void); +int crypt_start(Slapi_PBlock *pb); +int crypt_close(Slapi_PBlock *pb); int crypt_pw_cmp( const char *userpwd, const char *dbpwd ); char *crypt_pw_enc( const char *pwd ); int ns_mta_md5_pw_cmp( const char *userpwd, const char *dbpwd ); diff --git a/ldap/servers/plugins/replication/cl5_api.c b/ldap/servers/plugins/replication/cl5_api.c index b41a3dc..5cf95a0 100644 --- a/ldap/servers/plugins/replication/cl5_api.c +++ b/ldap/servers/plugins/replication/cl5_api.c @@ -238,7 +238,7 @@ typedef struct cl5desc typedef void (*VFP)(void *); /***** Global Variables *****/ -static CL5Desc s_cl5Desc; +static CL5Desc s_cl5Desc = {0}; /***** Forward Declarations *****/ @@ -427,6 +427,11 @@ void cl5Cleanup () PR_DestroyLock (cl5_diskfull_lock); cl5_diskfull_lock = NULL; } + if (s_cl5Desc.clLock != NULL) + { + PR_DestroyLock(s_cl5Desc.clLock); + s_cl5Desc.clLock = NULL; + } memset (&s_cl5Desc, 0, sizeof (s_cl5Desc)); } diff --git a/ldap/servers/plugins/retrocl/retrocl_trim.c b/ldap/servers/plugins/retrocl/retrocl_trim.c index b2b9de9..1258c70 100644 --- a/ldap/servers/plugins/retrocl/retrocl_trim.c +++ b/ldap/servers/plugins/retrocl/retrocl_trim.c @@ -481,5 +481,7 @@ void retrocl_stop_trimming(void) slapi_eq_cancel(retrocl_trim_ctx); retrocl_trim_ctx = NULL; } + PR_DestroyLock(ts.ts_s_trim_mutex); + ts.ts_s_trim_mutex = NULL; } diff --git a/ldap/servers/slapd/back-ldbm/cleanup.c b/ldap/servers/slapd/back-ldbm/cleanup.c index 45d1d0d..1c18d26 100644 --- a/ldap/servers/slapd/back-ldbm/cleanup.c +++ b/ldap/servers/slapd/back-ldbm/cleanup.c @@ -44,16 +44,18 @@ int ldbm_back_cleanup( Slapi_PBlock *pb ) PR_Unlock (be->be_state_lock); return 0; } - + dblayer_terminate( li ); /* JCM I tried adding this to tidy up memory on shutdown. */ /* JCM But, the result was very messy. */ -/* JCM objset_delete(&li->li_instance_set); */ + objset_delete(&(li->li_instance_set)); be->be_state = BE_STATE_CLEANED; PR_Unlock (be->be_state_lock); + ldbm_config_destroy(li); + return 0; } diff --git a/ldap/servers/slapd/back-ldbm/close.c b/ldap/servers/slapd/back-ldbm/close.c index 06075ed..73e6d56 100644 --- a/ldap/servers/slapd/back-ldbm/close.c +++ b/ldap/servers/slapd/back-ldbm/close.c @@ -32,6 +32,9 @@ int ldbm_back_close( Slapi_PBlock *pb ) /* close down all the ldbm instances */ dblayer_close( li, DBLAYER_NORMAL_MODE ); + /* Close all the entry caches for this instance */ + ldbm_instance_stopall_caches(li); + slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_close", "ldbm backend done syncing\n"); return 0; } diff --git a/ldap/servers/slapd/back-ldbm/instance.c b/ldap/servers/slapd/back-ldbm/instance.c index 315f5b6..8474854 100644 --- a/ldap/servers/slapd/back-ldbm/instance.c +++ b/ldap/servers/slapd/back-ldbm/instance.c @@ -266,34 +266,17 @@ ldbm_instance_start(backend *be) /* Stops a backend instance */ -int -ldbm_instance_stop(backend *be) +void +ldbm_instance_stop_cache(backend *be) { - int rc; ldbm_instance *inst = (ldbm_instance *)be->be_instance_info; - PR_Lock (be->be_state_lock); - - if (be->be_state != BE_STATE_STARTED) { - slapi_log_err(SLAPI_LOG_WARNING, - "ldbm_instance_stop", "Backend %s is in the wrong state - %d\n", - inst ? inst->inst_name : "", be->be_state); - PR_Unlock (be->be_state_lock); - return 0; - } - - rc = dblayer_instance_close(be); - - be->be_state = BE_STATE_STOPPED; - PR_Unlock (be->be_state_lock); - cache_destroy_please(&inst->inst_cache, CACHE_TYPE_ENTRY); if (entryrdn_get_switch()) { /* subtree-rename: on */ cache_destroy_please(&inst->inst_dncache, CACHE_TYPE_DN); } - - return rc; } + static void ldbm_instance_set_flags(ldbm_instance *inst) { @@ -333,7 +316,7 @@ ldbm_instance_startall(struct ldbminfo *li) /* Walks down the set of instances, stopping each one. */ -int ldbm_instance_stopall(struct ldbminfo *li) +int ldbm_instance_stopall_caches(struct ldbminfo *li) { Object *inst_obj; ldbm_instance *inst; @@ -341,7 +324,7 @@ int ldbm_instance_stopall(struct ldbminfo *li) inst_obj = objset_first_obj(li->li_instance_set); while (inst_obj != NULL) { inst = (ldbm_instance *) object_get_data(inst_obj); - ldbm_instance_stop(inst->inst_be); + ldbm_instance_stop_cache(inst->inst_be); inst_obj = objset_next_obj(li->li_instance_set, inst_obj); } @@ -395,14 +378,13 @@ ldbm_instance_destructor(void **arg) PR_DestroyLock(inst->inst_config_mutex); slapi_ch_free_string(&inst->inst_dir_name); slapi_ch_free_string(&inst->inst_parent_dir_name); - PR_DestroyMonitor(inst->inst_db_mutex); - PR_DestroyLock(inst->inst_handle_list_mutex); + /* These are removed in dblayer_terminate */ + /* PR_DestroyMonitor(inst->inst_db_mutex); */ + /* PR_DestroyLock(inst->inst_handle_list_mutex); */ PR_DestroyLock(inst->inst_nextid_mutex); PR_DestroyCondVar(inst->inst_indexer_cv); attrinfo_deletetree(inst); - if (inst->inst_dataversion) { - slapi_ch_free((void **)&inst->inst_dataversion); - } + slapi_ch_free((void **)&inst->inst_dataversion); /* cache has already been destroyed */ slapi_ch_free((void **)&inst); diff --git a/ldap/servers/slapd/back-ldbm/ldbm_config.c b/ldap/servers/slapd/back-ldbm/ldbm_config.c index cc570d4..686b232 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_config.c +++ b/ldap/servers/slapd/back-ldbm/ldbm_config.c @@ -2242,3 +2242,15 @@ void replace_ldbm_config_value(char *conftype, char *val, struct ldbminfo *li) slapi_mods_done(&smods); pblock_done(&pb); } + +/* Dispose of an ldbminfo struct for good */ +void +ldbm_config_destroy(struct ldbminfo *li) { + if (li->li_attrs_to_exclude_from_export != NULL) { + charray_free( li->li_attrs_to_exclude_from_export ); + } + slapi_ch_free((void **) &(li->li_new_directory)); + slapi_ch_free((void **) &(li->li_directory)); + /* Finally free the ldbminfo */ + slapi_ch_free((void **)&li); +} diff --git a/ldap/servers/slapd/back-ldbm/ldbm_config.h b/ldap/servers/slapd/back-ldbm/ldbm_config.h index e5fe9da..f481937 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_config.h +++ b/ldap/servers/slapd/back-ldbm/ldbm_config.h @@ -155,6 +155,7 @@ int ldbm_instance_config_add_index_entry(ldbm_instance *inst, Slapi_Entry *e, in int ldbm_instance_index_config_enable_index(ldbm_instance *inst, Slapi_Entry* e); int ldbm_instance_create_default_user_indexes(ldbm_instance *inst); +void ldbm_config_destroy(struct ldbminfo *li); #endif /* _LDBM_CONFIG_H_ */ diff --git a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h index b435b5a..86ef5cb 100644 --- a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h +++ b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h @@ -319,9 +319,9 @@ void index_free_prefix (char*); int ldbm_instance_create(backend *be, char *name); int ldbm_instance_create_default_indexes(backend *be); int ldbm_instance_start(backend *be); -int ldbm_instance_stop(backend *be); +void ldbm_instance_stop_cache(backend *be); int ldbm_instance_startall(struct ldbminfo *li); -int ldbm_instance_stopall(struct ldbminfo *li); +int ldbm_instance_stopall_caches(struct ldbminfo *li); ldbm_instance *ldbm_instance_find_by_name(struct ldbminfo *li, char *name); int ldbm_instance_destroy(ldbm_instance *inst); diff --git a/ldap/servers/slapd/backend_manager.c b/ldap/servers/slapd/backend_manager.c index c7ba5c2..d7e62f2 100644 --- a/ldap/servers/slapd/backend_manager.c +++ b/ldap/servers/slapd/backend_manager.c @@ -100,10 +100,10 @@ be_plgfn_unwillingtoperform(Slapi_PBlock *pb) /* JCM - Seems rather DSE specific... why's it here?... Should be in fedse.c... */ Slapi_Backend * -be_new_internal(struct dse *pdse, const char *type, const char *name) +be_new_internal(struct dse *pdse, const char *type, const char *name, struct slapdplugin *plugininfo) { Slapi_Backend *be= slapi_be_new(type, name, 1 /* Private */, 0 /* Do Not Log Changes */); - be->be_database = (struct slapdplugin *) slapi_ch_calloc( 1, sizeof(struct slapdplugin) ); + be->be_database = plugininfo; be->be_database->plg_private= (void*)pdse; be->be_database->plg_bind= &dse_bind; be->be_database->plg_unbind= &dse_unbind; @@ -283,44 +283,20 @@ slapi_be_select_by_instance_name( const char *name ) return NULL; } -/* void -be_cleanupall() -{ - int i; - Slapi_PBlock pb; - - for ( i = 0; i < maxbackends; i++ ) - { - if ( backends[i] && - backends[i]->be_cleanup != NULL && - (backends[i]->be_state == BE_STATE_STOPPED || - backends[i]->be_state == BE_STATE_DELETED)) - { - slapi_pblock_set( &pb, SLAPI_PLUGIN, backends[i]->be_database ); - slapi_pblock_set( &pb, SLAPI_BACKEND, backends[i] ); - - (*backends[i]->be_cleanup)( &pb ); - } - } -}*/ - void be_cleanupall() { int i; - Slapi_PBlock pb; + Slapi_PBlock pb = {0}; - for ( i = 0; i < maxbackends; i++ ) + for ( i = 0; i < maxbackends; i++ ) { - if (backends[i] && - backends[i]->be_cleanup != NULL && - (backends[i]->be_state == BE_STATE_STOPPED || - backends[i]->be_state == BE_STATE_DELETED)) - { - slapi_pblock_set( &pb, SLAPI_PLUGIN, backends[i]->be_database ); - slapi_pblock_set( &pb, SLAPI_BACKEND, backends[i] ); - - (*backends[i]->be_cleanup)( &pb ); + if (backends[i] && (backends[i]->be_state == BE_STATE_STOPPED || backends[i]->be_state == BE_STATE_DELETED)) { + if (backends[i]->be_cleanup != NULL) { + slapi_pblock_set( &pb, SLAPI_PLUGIN, backends[i]->be_database ); + slapi_pblock_set( &pb, SLAPI_BACKEND, backends[i] ); + (*backends[i]->be_cleanup)( &pb ); + } slapi_be_free(&backends[i]); } } diff --git a/ldap/servers/slapd/daemon.c b/ldap/servers/slapd/daemon.c index 1ea5a84..4e1dc5e 100644 --- a/ldap/servers/slapd/daemon.c +++ b/ldap/servers/slapd/daemon.c @@ -764,7 +764,6 @@ handle_listeners(Connection_Table *ct) static void convert_pbe_des_to_aes(void) { - Slapi_PBlock *pb = NULL; Slapi_Entry **entries = NULL; struct slapdplugin *plugin = NULL; char **attrs = NULL; @@ -816,20 +815,20 @@ convert_pbe_des_to_aes(void) for (i = 0; attrs && attrs[i]; i++){ char *filter = PR_smprintf("%s=*", attrs[i]); - pb = slapi_pblock_new(); - slapi_search_internal_set_pb(pb, "cn=config", + Slapi_PBlock pb = {0}; + slapi_search_internal_set_pb(&pb, "cn=config", LDAP_SCOPE_SUBTREE, filter, NULL, 0, NULL, NULL, (void *)plugin_get_default_component_id(), SLAPI_OP_FLAG_IGNORE_UNINDEXED); - slapi_search_internal_pb(pb); - slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries); + slapi_search_internal_pb(&pb); + slapi_pblock_get(&pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries); for (ii = 0; entries && entries[ii]; ii++){ if((val = slapi_entry_attr_get_charptr(entries[ii], attrs[i]))){ if(strlen(val) >= 5 && strncmp(val,"{DES}", 5) == 0){ /* * We have a DES encoded password, convert it to AES */ - Slapi_PBlock *mod_pb = NULL; + Slapi_PBlock mod_pb = {0}; Slapi_Value *sval = NULL; LDAPMod mod_replace; LDAPMod *mods[2]; @@ -866,12 +865,11 @@ convert_pbe_des_to_aes(void) mods[0] = &mod_replace; mods[1] = 0; - mod_pb = slapi_pblock_new(); - slapi_modify_internal_set_pb(mod_pb, slapi_entry_get_dn(entries[ii]), + slapi_modify_internal_set_pb(&mod_pb, slapi_entry_get_dn(entries[ii]), mods, 0, 0, (void *)plugin_get_default_component_id(), 0); - slapi_modify_internal_pb(mod_pb); + slapi_modify_internal_pb(&mod_pb); - slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &result); + slapi_pblock_get(&mod_pb, SLAPI_PLUGIN_INTOP_RESULT, &result); if (LDAP_SUCCESS != result) { slapi_log_err(SLAPI_LOG_ERR, "convert_pbe_des_to_aes", "Failed to convert password for (%s) error (%d)\n", @@ -885,14 +883,13 @@ convert_pbe_des_to_aes(void) } slapi_ch_free_string(&passwd); slapi_value_free(&sval); - slapi_pblock_destroy(mod_pb); + pblock_done(&mod_pb); } slapi_ch_free_string(&val); } } - slapi_free_search_results_internal(pb); - slapi_pblock_destroy(pb); - pb = NULL; + slapi_free_search_results_internal(&pb); + pblock_done(&pb); slapi_ch_free_string(&filter); } if (!converted_des_passwd){ @@ -1176,7 +1173,7 @@ void slapd_daemon( daemon_ports_t *ports ) for (size_t ii = 0; ii < listeners; ++ii) { listener_idxs[ii].ct = the_connection_table; /* to pass to handle_new_connection */ ns_add_io_job(tp, listener_idxs[ii].listenfd, NS_JOB_ACCEPT|NS_JOB_PERSIST|NS_JOB_PRESERVE_FD, - ns_handle_new_connection, &listener_idxs[ii], &listener_idxs[ii].ns_job); + ns_handle_new_connection, &listener_idxs[ii], &(listener_idxs[ii].ns_job)); } } @@ -1280,11 +1277,11 @@ void slapd_daemon( daemon_ports_t *ports ) #endif } - /* Might compete with housecleaning thread, but so far so good */ - be_flushall(); - op_thread_cleanup(); - housekeeping_stop(); /* Run this after op_thread_cleanup() logged sth */ - disk_monitoring_stop(); + /* Might compete with housecleaning thread, but so far so good */ + be_flushall(); + op_thread_cleanup(); + housekeeping_stop(); /* Run this after op_thread_cleanup() logged sth */ + disk_monitoring_stop(); threads = g_get_active_threadcnt(); if ( threads > 0 ) { @@ -2828,18 +2825,25 @@ ns_set_shutdown(struct ns_job_t *job) { /* Is there a way to make this a bit more atomic? */ /* I think NS protects this by only executing one signal job at a time */ + PRStatus shutdown_status = PR_SUCCESS; if (g_get_shutdown() == 0) { g_set_shutdown(SLAPI_SHUTDOWN_SIGNAL); + /* Signal all the worker threads to stop */ + ns_thrpool_shutdown(ns_job_get_tp(job)); + /* Stop all the long running jobs */ - for (size_t i = 0; i < listeners; ++i) { - ns_job_done(listener_idxs[i].ns_job); + /* Please see https://firstyear.fedorapeople.org/nunc-stans/md_docs_job-safety.html */ + /* tldr is shutdown needs to run first to allow job_done on an ARMED job */ + for (size_t i = 0; i < listeners; i++) { + shutdown_status = ns_job_done(listener_idxs[i].ns_job); + if (shutdown_status != PR_SUCCESS) { + slapi_log_err(SLAPI_LOG_CRIT, "ns_set_shutdown", "Failed to shutdown listener idx %"PRIu64" !\n", i); + } + PR_ASSERT(shutdown_status == PR_SUCCESS); listener_idxs[i].ns_job = NULL; } - - /* Signal all the worker threads to stop */ - ns_thrpool_shutdown(ns_job_get_tp(job)); } } #endif diff --git a/ldap/servers/slapd/defbackend.c b/ldap/servers/slapd/defbackend.c index 9a9bc98..6fd74a3 100644 --- a/ldap/servers/slapd/defbackend.c +++ b/ldap/servers/slapd/defbackend.c @@ -77,10 +77,9 @@ defbackend_init( void ) */ defbackend_plugin.plg_type = SLAPI_PLUGIN_DATABASE; defbackend_backend->be_database = &defbackend_plugin; - if (( rc = slapi_pblock_set( &pb, SLAPI_PLUGIN, &defbackend_plugin )) - != 0 ) { - errmsg = "slapi_pblock_set SLAPI_PLUGIN failed"; - goto cleanup_and_return; + if (( rc = slapi_pblock_set( &pb, SLAPI_PLUGIN, &defbackend_plugin )) != 0 ) { + errmsg = "slapi_pblock_set SLAPI_PLUGIN failed"; + goto cleanup_and_return; } /* default backend is managed as if it would */ diff --git a/ldap/servers/slapd/fedse.c b/ldap/servers/slapd/fedse.c index d64e7c6..13a3c74 100644 --- a/ldap/servers/slapd/fedse.c +++ b/ldap/servers/slapd/fedse.c @@ -48,6 +48,8 @@ extern char ** getEnabledCiphers(void); extern int getSSLVersionInfo(int *ssl2, int *ssl3, int *tls1); extern int getSSLVersionRange(char **min, char **max); +static struct slapdplugin fedse_plugin = {0}; + /* Note: These DNs are no need to be normalized */ static const char *internal_entries[] = { @@ -1846,7 +1848,7 @@ setup_internal_backends(char *configdir) dse_register_callback(pfedse,SLAPI_OPERATION_ADD,DSE_FLAG_PREOP,&saslmapping,LDAP_SCOPE_SUBTREE,"(objectclass=nsSaslMapping)",sasl_map_config_add,NULL, NULL); dse_register_callback(pfedse,SLAPI_OPERATION_ADD,DSE_FLAG_PREOP,&plugins,LDAP_SCOPE_SUBTREE,"(objectclass=nsSlapdPlugin)",check_plugin_path,NULL, NULL); - be = be_new_internal(pfedse, "DSE", DSE_BACKEND); + be = be_new_internal(pfedse, "DSE", DSE_BACKEND, &fedse_plugin); be_addsuffix(be,&root); be_addsuffix(be,&monitor); be_addsuffix(be,&config); diff --git a/ldap/servers/slapd/pblock.c b/ldap/servers/slapd/pblock.c index 52b8cf5..1c35148 100644 --- a/ldap/servers/slapd/pblock.c +++ b/ldap/servers/slapd/pblock.c @@ -3480,6 +3480,10 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value ) /* password storage scheme (kexcoff) */ case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME: + if (pblock->pb_plugin->plg_pwdstorageschemename != NULL) { + /* Free the old name. */ + slapi_ch_free_string(&pblock->pb_plugin->plg_pwdstorageschemename); + } pblock->pb_plugin->plg_pwdstorageschemename = slapi_ch_strdup((char *)value); break; case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_USER_PWD: diff --git a/ldap/servers/slapd/plugin.c b/ldap/servers/slapd/plugin.c index 7744aa6..0416ff8 100644 --- a/ldap/servers/slapd/plugin.c +++ b/ldap/servers/slapd/plugin.c @@ -112,6 +112,8 @@ add_plugin_to_list(struct slapdplugin **list, struct slapdplugin *plugin) struct slapdplugin *last = NULL; int plugin_added = 0; + slapi_log_err(SLAPI_LOG_TRACE, "add_plugin_to_list", "Adding %s \n", plugin->plg_name ); + /* Insert the plugin into list based off of precedence. */ for ( tmp = list; *tmp; tmp = &(*tmp)->plg_next ) { @@ -219,8 +221,7 @@ new_plugin_entry(entry_and_plugin_t **ep, Slapi_Entry *e, struct slapdplugin *pl entry_and_plugin_t *oldep = 0; entry_and_plugin_t *iterep = *ep; - entry_and_plugin_t *newep = - (entry_and_plugin_t*)slapi_ch_calloc(1,sizeof(entry_and_plugin_t)); + entry_and_plugin_t *newep = (entry_and_plugin_t*)slapi_ch_calloc(1,sizeof(entry_and_plugin_t)); newep->e = e; newep->plugin = plugin; @@ -232,10 +233,11 @@ new_plugin_entry(entry_and_plugin_t **ep, Slapi_Entry *e, struct slapdplugin *pl newep->next = 0; - if(oldep) + if(oldep) { oldep->next = newep; - else + } else { *ep = newep; + } } static void @@ -2764,21 +2766,21 @@ plugin_add_descriptive_attributes( Slapi_Entry *e, struct slapdplugin *plugin ) static void plugin_free(struct slapdplugin *plugin) { - slapi_log_err(SLAPI_LOG_TRACE, "plugin_free", "Freeing %s \n", plugin->plg_name ); - charray_free(plugin->plg_argv); - slapi_ch_free_string(&plugin->plg_libpath); - slapi_ch_free_string(&plugin->plg_initfunc); - slapi_ch_free_string(&plugin->plg_name); - slapi_ch_free_string(&plugin->plg_dn); - if (plugin->plg_type == SLAPI_PLUGIN_PWD_STORAGE_SCHEME) { - slapi_ch_free_string(&plugin->plg_pwdstorageschemename); - } - release_componentid(plugin->plg_identity); - slapi_counter_destroy(&plugin->plg_op_counter); - if (!plugin->plg_group) { - plugin_config_cleanup(&plugin->plg_conf); + slapi_log_err(SLAPI_LOG_TRACE, "plugin_free", "Freeing %s \n", plugin->plg_name ); + charray_free(plugin->plg_argv); + slapi_ch_free_string(&plugin->plg_libpath); + slapi_ch_free_string(&plugin->plg_initfunc); + slapi_ch_free_string(&plugin->plg_name); + slapi_ch_free_string(&plugin->plg_dn); + if (plugin->plg_type == SLAPI_PLUGIN_PWD_STORAGE_SCHEME || plugin->plg_type == SLAPI_PLUGIN_REVER_PWD_STORAGE_SCHEME ) { + slapi_ch_free_string(&plugin->plg_pwdstorageschemename); } - slapi_ch_free((void**)&plugin); + release_componentid(plugin->plg_identity); + slapi_counter_destroy(&plugin->plg_op_counter); + if (!plugin->plg_group) { + plugin_config_cleanup(&plugin->plg_conf); + } + slapi_ch_free((void**)&plugin); } /*********************************** @@ -3125,18 +3127,16 @@ plugin_setup(Slapi_Entry *plugin_entry, struct slapi_componentid *group, add_plugin_entry_dn(dn_copy); } - if (add_entry) - { - /* make a copy of the plugin entry for our own use because it will - be freed later by the caller */ - Slapi_Entry *e_copy = slapi_entry_dup(plugin_entry); - /* new_plugin_entry(&plugin_entries, plugin_entry, plugin); */ - new_plugin_entry(&dep_plugin_entries, e_copy, plugin); - } + /* make a copy of the plugin entry for our own use because it will + be freed later by the caller */ + Slapi_Entry *e_copy = slapi_entry_dup(plugin_entry); + /* new_plugin_entry(&plugin_entries, plugin_entry, plugin); */ + new_plugin_entry(&dep_plugin_entries, e_copy, plugin); PLUGIN_CLEANUP: - if (status) + if (status) { plugin_free(plugin); + } slapi_ch_free((void **)&configdir); return status; diff --git a/ldap/servers/slapd/proto-slap.h b/ldap/servers/slapd/proto-slap.h index d2841eb..fdb4bf0 100644 --- a/ldap/servers/slapd/proto-slap.h +++ b/ldap/servers/slapd/proto-slap.h @@ -192,7 +192,7 @@ void global_backend_lock_unlock(void); /* * backend_manager.c */ -Slapi_Backend *be_new_internal(struct dse *pdse, const char *type, const char *name); +Slapi_Backend *be_new_internal(struct dse *pdse, const char *type, const char *name, struct slapdplugin *plugininfo); void be_replace_dse_internal(Slapi_Backend *be, struct dse *pdse); int fedse_create_startOK(char *filename, char *startokfilename, const char *configdir); void be_cleanupall(void); diff --git a/ldap/servers/slapd/schema.c b/ldap/servers/slapd/schema.c index dca0f06..c65cdba 100644 --- a/ldap/servers/slapd/schema.c +++ b/ldap/servers/slapd/schema.c @@ -26,6 +26,8 @@ #include /* openldap schema parser */ #endif +static struct slapdplugin schema_plugin = {0}; + typedef struct sizedbuffer { char *buffer; @@ -5317,8 +5319,9 @@ init_schema_dse_ext(char *schemadir, Slapi_Backend *be, load_schema_dse, (void *)&schema_flags, NULL); } slapi_ch_free_string(&userschematmpfile); - if (NULL == schemadir) + if (NULL == schemadir) { slapi_ch_free_string(&myschemadir); /* allocated in this function */ + } if(rc) { @@ -5375,10 +5378,11 @@ init_schema_dse_ext(char *schemadir, Slapi_Backend *be, if (rc && !(schema_flags & DSE_SCHEMA_NO_BACKEND)) { /* make sure the schema is normalized */ - if (schema_flags & DSE_SCHEMA_LOCKED) + if (schema_flags & DSE_SCHEMA_LOCKED) { normalize_oc_nolock(); - else + } else { normalize_oc(); + } /* register callbacks */ dse_register_callback(*local_pschemadse, SLAPI_OPERATION_SEARCH, @@ -5400,7 +5404,7 @@ init_schema_dse_ext(char *schemadir, Slapi_Backend *be, } if (NULL == be) { /* first time */ /* add as a backend */ - be = be_new_internal(*local_pschemadse, "DSE", DSE_SCHEMA); + be = be_new_internal(*local_pschemadse, "DSE", DSE_SCHEMA, &schema_plugin); be_addsuffix(be, &schema); } else { /* schema file reload */ struct slapdplugin *backend_plugin = NULL; diff --git a/ldap/servers/slapd/uuid.c b/ldap/servers/slapd/uuid.c index 08ca7b3..9b1b561 100644 --- a/ldap/servers/slapd/uuid.c +++ b/ldap/servers/slapd/uuid.c @@ -606,10 +606,11 @@ static int write_state_to_file(void) /* write_state_to_entry -- stores state to state file */ static int write_state_to_entry(PRBool newState) { - if (newState) - return add_state_entry (); - else - return modify_state_entry (); + if (newState) { + return add_state_entry (); + } else { + return modify_state_entry (); + } } /* add_state_entry -- add state entry to the dit */ diff --git a/ldap/servers/slapd/valueset.c b/ldap/servers/slapd/valueset.c index d8188fc..8a824ac 100644 --- a/ldap/servers/slapd/valueset.c +++ b/ldap/servers/slapd/valueset.c @@ -604,10 +604,11 @@ slapi_valueset_set_valueset(Slapi_ValueSet *vs1, const Slapi_ValueSet *vs2) void slapi_valueset_join_attr_valueset(const Slapi_Attr *a, Slapi_ValueSet *vs1, const Slapi_ValueSet *vs2) { - if (slapi_valueset_isempty(vs1)) - valueset_set_valueset(vs1,vs2); - else - slapi_valueset_add_attr_valuearray_ext (a, vs1, vs2->va, vs2->num, 0, NULL); + if (slapi_valueset_isempty(vs1)) { + valueset_set_valueset(vs1,vs2); + } else { + slapi_valueset_add_attr_valuearray_ext (a, vs1, vs2->va, vs2->num, 0, NULL); + } } int @@ -721,9 +722,10 @@ valueset_remove_value(const Slapi_Attr *a, Slapi_ValueSet *vs, const Slapi_Value } else { if(!valuearray_isempty(vs->va)) { - r= valuearray_remove_value(a, vs->va, v); - if (r) + r = valuearray_remove_value(a, vs->va, v); + if (r) { vs->num--; + } } } PR_ASSERT((vs->sorted == NULL) || (vs->num < VALUESET_ARRAY_SORT_THRESHOLD) || ((vs->num >= VALUESET_ARRAY_SORT_THRESHOLD) && (vs->sorted[0] < vs->num))); diff --git a/ldap/servers/slapd/vattr.c b/ldap/servers/slapd/vattr.c index 9e2d4f5..34665de 100644 --- a/ldap/servers/slapd/vattr.c +++ b/ldap/servers/slapd/vattr.c @@ -117,7 +117,8 @@ void vattr_init() /* Called on server shutdown, free all structures, inform service providers that we're going down etc */ void vattr_cleanup() { - vattr_map_destroy(); + /* We need to free and remove anything that was inserted first */ + vattr_map_destroy(); } /* The public interface functions start here */ @@ -1842,9 +1843,23 @@ static int vattr_map_create(void) return 0; } +void vattr_map_entry_free(vattr_map_entry *vae) { + slapi_ch_free((void **)&(vae->sp_list)); + slapi_ch_free_string(&(vae->type_name)); + slapi_ch_free((void **)&vae); +} + +static PRIntn +vattr_he_cleanup_fn(PLHashEntry *he, PRIntn index, void *arg) { + vattr_map_entry_free((vattr_map_entry *)he->value); + he->value = NULL; + return HT_ENUMERATE_NEXT; +} + static void vattr_map_destroy(void) { if (the_map) { + PL_HashTableEnumerateEntries(the_map->hashtable, vattr_he_cleanup_fn, NULL); if (the_map->hashtable) { PL_HashTableDestroy(the_map->hashtable); } @@ -1904,19 +1919,13 @@ static int vattr_map_lookup(const char *type_to_find, vattr_map_entry **result) /* Insert an entry into the attribute map */ int vattr_map_insert(vattr_map_entry *vae) { - char *copy_of_type_name = NULL; PR_ASSERT(the_map); - copy_of_type_name = slapi_ch_strdup(vae->type_name); - if (NULL == copy_of_type_name) { - slapd_nasty(sourcefile,6,0); - return ENOMEM; - } /* Get the writer lock */ slapi_rwlock_wrlock(the_map->lock); /* Insert the thing */ /* It's illegal to call this function if the entry is already there */ - PR_ASSERT(NULL == PL_HashTableLookupConst(the_map->hashtable,(void*)copy_of_type_name)); - PL_HashTableAdd(the_map->hashtable,(void*)copy_of_type_name,(void*)vae); + PR_ASSERT(NULL == PL_HashTableLookupConst(the_map->hashtable,(void*)vae->type_name)); + PL_HashTableAdd(the_map->hashtable,(void*)vae->type_name,(void*)vae); /* Unlock and we're done */ slapi_rwlock_unlock(the_map->lock); return 0; -- 1.8.3.1