Author: anthm
Date: Thu May 3 12:28:23 2007
New Revision: 5078
Modified:
freeswitch/trunk/src/include/switch_core.h
freeswitch/trunk/src/include/switch_loadable_module.h
freeswitch/trunk/src/include/switch_types.h
freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c
freeswitch/trunk/src/mod/endpoints/mod_sofia/sofia_glue.c
freeswitch/trunk/src/switch_core_hash.c
freeswitch/trunk/src/switch_event.c
freeswitch/trunk/src/switch_loadable_module.c
Log:
general improvements
Modified: freeswitch/trunk/src/include/switch_core.h
==============================================================================
--- freeswitch/trunk/src/include/switch_core.h (original)
+++ freeswitch/trunk/src/include/switch_core.h Thu May 3 12:28:23 2007
@@ -819,6 +819,17 @@
SWITCH_DECLARE(switch_status_t) switch_core_hash_insert(switch_hash_t * hash, const char *key, const void *data);
/*!
+ \brief Insert data into a hash
+ \param hash the hash to add data to
+ \param key the name of the key to add the data to
+ \param data the data to add
+ \param mutex optional mutex to lock
+ \return SWITCH_STATUS_SUCCESS if the data is added
+ \note the string key must be a constant or a dynamic string
+*/
+SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_locked(switch_hash_t * hash, const char *key, const void *data, switch_mutex_t *mutex);
+
+/*!
\brief Insert data into a hash with dynamicly allocated key name
\param hash the hash to add data to
\param key the name of the key to add the data to
@@ -828,6 +839,16 @@
SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_dup(switch_hash_t * hash, const char *key, const void *data);
/*!
+ \brief Insert data into a hash with dynamicly allocated key name
+ \param hash the hash to add data to
+ \param key the name of the key to add the data to
+ \param data the data to add
+ \param mutex optional mutex to lock
+ \return SWITCH_STATUS_SUCCESS if the data is added
+*/
+SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_dup_locked(switch_hash_t * hash, const char *key, const void *data, switch_mutex_t *mutex);
+
+/*!
\brief Delete data from a hash based on desired key
\param hash the hash to delete from
\param key the key from which to delete the data
@@ -836,12 +857,32 @@
SWITCH_DECLARE(switch_status_t) switch_core_hash_delete(switch_hash_t * hash, const char *key);
/*!
+ \brief Delete data from a hash based on desired key
+ \param hash the hash to delete from
+ \param key the key from which to delete the data
+ \param mutex optional mutex to lock
+ \return SWITCH_STATUS_SUCCESS if the data is deleted
+*/
+SWITCH_DECLARE(switch_status_t) switch_core_hash_delete_locked(switch_hash_t * hash, const char *key, switch_mutex_t *mutex);
+
+/*!
\brief Retrieve data from a given hash
\param hash the hash to retrieve from
\param key the key to retrieve
\return a pointer to the data held in the key
*/
SWITCH_DECLARE(void *) switch_core_hash_find(switch_hash_t * hash, const char *key);
+
+
+/*!
+ \brief Retrieve data from a given hash
+ \param hash the hash to retrieve from
+ \param key the key to retrieve
+ \param mutex optional mutex to lock
+ \return a pointer to the data held in the key
+*/
+SWITCH_DECLARE(void *) switch_core_hash_find_locked(switch_hash_t * hash, const char *key, switch_mutex_t *mutex);
+
///\}
///\defgroup timer Timer Functions
Modified: freeswitch/trunk/src/include/switch_loadable_module.h
==============================================================================
--- freeswitch/trunk/src/include/switch_loadable_module.h (original)
+++ freeswitch/trunk/src/include/switch_loadable_module.h Thu May 3 12:28:23 2007
@@ -228,15 +228,24 @@
*/
SWITCH_DECLARE(switch_status_t) switch_api_execute(char *cmd, char *arg, switch_core_session_t *session, switch_stream_handle_t *stream);
-
-
/*!
\brief Load a module
\param dir the directory where the module resides
\param fname the file name of the module
+ \param runtime option to start the runtime thread if it exists
+ \param err pointer to error message
+ \return the status
+*/
+SWITCH_DECLARE(switch_status_t) switch_loadable_module_load_module(char *dir, char *fname, switch_bool_t runtime, const char **err);
+
+/*!
+ \brief Unoad a module
+ \param dir the directory where the module resides
+ \param fname the file name of the module
+ \param err pointer to error message
\return the status
*/
-SWITCH_DECLARE(switch_status_t) switch_loadable_module_load_module(char *dir, char *fname, switch_bool_t runtime);
+SWITCH_DECLARE(switch_status_t) switch_loadable_module_unload_module(char *dir, char *fname, const char **err);
/* Prototypes of module interface functions */
Modified: freeswitch/trunk/src/include/switch_types.h
==============================================================================
--- freeswitch/trunk/src/include/switch_types.h (original)
+++ freeswitch/trunk/src/include/switch_types.h Thu May 3 12:28:23 2007
@@ -420,6 +420,7 @@
SWITCH_STATUS_MORE_DATA - Need More Data
SWITCH_STATUS_NOTFOUND - Not Found
SWITCH_STATUS_UNLOAD - Unload
+ SWITCH_STATUS_NOUNLOAD - Never Unload
</pre>
*/
typedef enum {
@@ -438,7 +439,8 @@
SWITCH_STATUS_SOCKERR,
SWITCH_STATUS_MORE_DATA,
SWITCH_STATUS_NOTFOUND,
- SWITCH_STATUS_UNLOAD
+ SWITCH_STATUS_UNLOAD,
+ SWITCH_STATUS_NOUNLOAD
} switch_status_t;
@@ -816,6 +818,7 @@
SWITCH_EVENT_NOTALK - Not Talking Detected
SWITCH_EVENT_SESSION_CRASH - Session Crashed
SWITCH_EVENT_MODULE_LOAD - Module was loaded
+ SWITCH_EVENT_MODULE_UNLOAD - Module was unloaded
SWITCH_EVENT_DTMF - DTMF was sent
SWITCH_EVENT_MESSAGE - A Basic Message
SWITCH_EVENT_PRESENCE_IN - Presence in
@@ -863,6 +866,7 @@
SWITCH_EVENT_NOTALK,
SWITCH_EVENT_SESSION_CRASH,
SWITCH_EVENT_MODULE_LOAD,
+ SWITCH_EVENT_MODULE_UNLOAD,
SWITCH_EVENT_DTMF,
SWITCH_EVENT_MESSAGE,
SWITCH_EVENT_PRESENCE_IN,
Modified: freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c Thu May 3 12:28:23 2007
@@ -46,6 +46,7 @@
static switch_api_interface_t pause_api_interface;
static switch_api_interface_t transfer_api_interface;
static switch_api_interface_t load_api_interface;
+static switch_api_interface_t unload_api_interface;
static switch_api_interface_t reload_api_interface;
static switch_api_interface_t kill_api_interface;
static switch_api_interface_t originate_api_interface;
@@ -150,6 +151,7 @@
static switch_status_t load_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
{
+ const char *err;
if (session) {
return SWITCH_STATUS_FALSE;
@@ -160,10 +162,32 @@
return SWITCH_STATUS_SUCCESS;
}
- if (switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) mod, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
+ if (switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) mod, SWITCH_TRUE, &err) == SWITCH_STATUS_SUCCESS) {
stream->write_function(stream, "OK\n");
} else {
- stream->write_function(stream, "ERROR\n");
+ stream->write_function(stream, "ERROR [%s]\n", err);
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t unload_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
+{
+ const char *err;
+
+ if (session) {
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if (switch_strlen_zero(mod)) {
+ stream->write_function(stream, "USAGE: %s\n", unload_api_interface.syntax);
+ return SWITCH_STATUS_SUCCESS;
+ }
+
+ if (switch_loadable_module_unload_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) mod, &err) == SWITCH_STATUS_SUCCESS) {
+ stream->write_function(stream, "OK\n");
+ } else {
+ stream->write_function(stream, "ERROR [%s]\n", err);
}
return SWITCH_STATUS_SUCCESS;
@@ -1221,12 +1245,20 @@
/*.next */ &transfer_api_interface
};
+static switch_api_interface_t unload_api_interface = {
+ /*.interface_name */ "unload",
+ /*.desc */ "Unoad Module",
+ /*.function */ unload_function,
+ /*.syntax */ "<mod_name>",
+ /*.next */ &load_api_interface
+};
+
static switch_api_interface_t reload_api_interface = {
/*.interface_name */ "reloadxml",
/*.desc */ "Reload XML",
/*.function */ reload_function,
/*.syntax */ "",
- /*.next */ &load_api_interface,
+ /*.next */ &unload_api_interface,
};
@@ -1263,7 +1295,7 @@
*module_interface = &mod_commands_module_interface;
/* indicate that the module should continue to be loaded */
- return SWITCH_STATUS_SUCCESS;
+ return SWITCH_STATUS_NOUNLOAD;
}
/* For Emacs:
Modified: freeswitch/trunk/src/mod/endpoints/mod_sofia/sofia_glue.c
==============================================================================
--- freeswitch/trunk/src/mod/endpoints/mod_sofia/sofia_glue.c (original)
+++ freeswitch/trunk/src/mod/endpoints/mod_sofia/sofia_glue.c Thu May 3 12:28:23 2007
@@ -1565,11 +1565,14 @@
#endif
#ifdef SWITCH_HAVE_ODBC
- return profile->master_odbc ? 1 : 0;
-#else
- return 1;
+ if (profile->odbc_dsn) {
+ return profile->master_odbc ? 1 : 0;
+ }
#endif
+ return profile->master_db ? 1: 0;
+
+
}
void sofia_glue_sql_close(sofia_profile_t *profile)
Modified: freeswitch/trunk/src/switch_core_hash.c
==============================================================================
--- freeswitch/trunk/src/switch_core_hash.c (original)
+++ freeswitch/trunk/src/switch_core_hash.c Thu May 3 12:28:23 2007
@@ -57,19 +57,83 @@
return SWITCH_STATUS_SUCCESS;
}
+SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_dup_locked(switch_hash_t * hash, const char *key, const void *data, switch_mutex_t *mutex)
+{
+ if (mutex) {
+ switch_mutex_lock(mutex);
+ }
+
+ apr_hash_set(hash, switch_core_strdup(apr_hash_pool_get(hash), key), APR_HASH_KEY_STRING, data);
+
+ if (mutex) {
+ switch_mutex_unlock(mutex);
+ }
+
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
SWITCH_DECLARE(switch_status_t) switch_core_hash_insert(switch_hash_t * hash, const char *key, const void *data)
{
apr_hash_set(hash, key, APR_HASH_KEY_STRING, data);
return SWITCH_STATUS_SUCCESS;
}
+SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_locked(switch_hash_t * hash, const char *key, const void *data, switch_mutex_t *mutex)
+{
+ if (mutex) {
+ switch_mutex_lock(mutex);
+ }
+
+ apr_hash_set(hash, key, APR_HASH_KEY_STRING, data);
+
+ if (mutex) {
+ switch_mutex_unlock(mutex);
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
SWITCH_DECLARE(switch_status_t) switch_core_hash_delete(switch_hash_t * hash, const char *key)
{
apr_hash_set(hash, key, APR_HASH_KEY_STRING, NULL);
return SWITCH_STATUS_SUCCESS;
}
+SWITCH_DECLARE(switch_status_t) switch_core_hash_delete_locked(switch_hash_t * hash, const char *key, switch_mutex_t *mutex)
+{
+ if (mutex) {
+ switch_mutex_lock(mutex);
+ }
+
+ apr_hash_set(hash, key, APR_HASH_KEY_STRING, NULL);
+
+ if (mutex) {
+ switch_mutex_unlock(mutex);
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+
SWITCH_DECLARE(void *) switch_core_hash_find(switch_hash_t * hash, const char *key)
{
return apr_hash_get(hash, key, APR_HASH_KEY_STRING);
}
+
+SWITCH_DECLARE(void *) switch_core_hash_find_locked(switch_hash_t * hash, const char *key, switch_mutex_t *mutex)
+{
+ void *val;
+
+ if (mutex) {
+ switch_mutex_lock(mutex);
+ }
+
+ val = apr_hash_get(hash, key, APR_HASH_KEY_STRING);
+
+ if (mutex) {
+ switch_mutex_unlock(mutex);
+ }
+
+ return val;
+}
Modified: freeswitch/trunk/src/switch_event.c
==============================================================================
--- freeswitch/trunk/src/switch_event.c (original)
+++ freeswitch/trunk/src/switch_event.c Thu May 3 12:28:23 2007
@@ -121,6 +121,7 @@
"NOTALK",
"SESSION_CRASH",
"MODULE_LOAD",
+ "MODULE_UNLOAD",
"DTMF",
"MESSAGE",
"PRESENCE_IN",
Modified: freeswitch/trunk/src/switch_loadable_module.c
==============================================================================
--- freeswitch/trunk/src/switch_loadable_module.c (original)
+++ freeswitch/trunk/src/switch_loadable_module.c Thu May 3 12:28:23 2007
@@ -41,12 +41,15 @@
#include <apr_file_io.h>
struct switch_loadable_module {
+ char *key;
char *filename;
+ int perm;
const switch_loadable_module_interface_t *module_interface;
void *lib;
switch_module_load_t switch_module_load;
switch_module_runtime_t switch_module_runtime;
switch_module_shutdown_t switch_module_shutdown;
+ switch_memory_pool_t *pool;
};
struct switch_loadable_module_container {
@@ -64,10 +67,12 @@
switch_hash_t *chat_hash;
switch_hash_t *say_hash;
switch_hash_t *management_hash;
+ switch_mutex_t *mutex;
switch_memory_pool_t *pool;
};
static struct switch_loadable_module_container loadable_modules;
+static void do_shutdown(switch_loadable_module_t *module);
static void *switch_loadable_module_exec(switch_thread_t * thread, void *obj)
{
@@ -102,6 +107,7 @@
void *val;
switch_loadable_module_t *module;
+ switch_mutex_lock(loadable_modules.mutex);
for (hi = switch_hash_first(loadable_modules.pool, loadable_modules.module_hash); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, NULL, NULL, &val);
module = (switch_loadable_module_t *) val;
@@ -111,12 +117,16 @@
switch_core_launch_thread(switch_loadable_module_exec, module, loadable_modules.pool);
}
}
+ switch_mutex_unlock(loadable_modules.mutex);
}
static switch_status_t switch_loadable_module_process(char *key, switch_loadable_module_t *new_module)
{
switch_event_t *event;
+ new_module->key = switch_core_strdup(new_module->pool, key);
+
+ switch_mutex_lock(loadable_modules.mutex);
switch_core_hash_insert(loadable_modules.module_hash, key, new_module);
if (new_module->module_interface->endpoint_interface) {
@@ -380,11 +390,252 @@
}
}
+ switch_mutex_unlock(loadable_modules.mutex);
+ return SWITCH_STATUS_SUCCESS;
+
+}
+
+
+static switch_status_t switch_loadable_module_unprocess(switch_loadable_module_t *old_module)
+{
+ switch_event_t *event;
+
+ switch_mutex_lock(loadable_modules.mutex);
+ switch_core_hash_delete(loadable_modules.module_hash, old_module->key);
+
+ if (old_module->module_interface->endpoint_interface) {
+ const switch_endpoint_interface_t *ptr;
+ for (ptr = old_module->module_interface->endpoint_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Endpoint '%s'\n", ptr->interface_name);
+ switch_core_hash_delete(loadable_modules.endpoint_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->codec_interface) {
+ const switch_codec_implementation_t *impl;
+ const switch_codec_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->codec_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ unsigned load_interface = 1;
+ for (impl = ptr->implementations; impl; impl = impl->next) {
+ if (!impl->iananame) {
+ load_interface = 0;
+ break;
+ }
+ }
+ if (load_interface) {
+ for (impl = ptr->implementations; impl; impl = impl->next) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
+ "Deleting Codec '%s' (%s) %dhz %dms\n",
+ impl->iananame, ptr->interface_name, impl->samples_per_second, impl->microseconds_per_frame / 1000);
+ if (switch_core_hash_find(loadable_modules.codec_hash, impl->iananame)) {
+ switch_core_hash_delete(loadable_modules.codec_hash, impl->iananame);
+ }
+ }
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "codec");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ }
+ }
+ }
+ }
+
+ if (old_module->module_interface->dialplan_interface) {
+ const switch_dialplan_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->dialplan_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Dialplan '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "dialplan");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.dialplan_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->timer_interface) {
+ const switch_timer_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->timer_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Timer '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "timer");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.timer_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->application_interface) {
+ const switch_application_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->application_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Application '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "application");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "description", "%s", switch_str_nil(ptr->short_desc));
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "syntax", "%s", switch_str_nil(ptr->syntax));
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.application_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->api_interface) {
+ const switch_api_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->api_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting API Function '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "api");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "description", "%s", switch_str_nil(ptr->desc));
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "syntax", "%s", switch_str_nil(ptr->syntax));
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.api_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->file_interface) {
+ const switch_file_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->file_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ int i;
+ for (i = 0; ptr->extens[i]; i++) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting File Format '%s'\n", ptr->extens[i]);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "file");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->extens[i]);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.file_hash, ptr->extens[i]);
+ }
+ }
+ }
+ }
+
+ if (old_module->module_interface->speech_interface) {
+ const switch_speech_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->speech_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Speech interface '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "speech");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.speech_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->asr_interface) {
+ const switch_asr_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->asr_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Asr interface '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "asr");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.asr_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->directory_interface) {
+ const switch_directory_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->directory_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Directory interface '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "directory");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.directory_hash, ptr->interface_name);
+ }
+ }
+ }
+
+
+ if (old_module->module_interface->chat_interface) {
+ const switch_chat_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->chat_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Chat interface '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "chat");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.chat_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->say_interface) {
+ const switch_say_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->say_interface; ptr; ptr = ptr->next) {
+ if (ptr->interface_name) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Say interface '%s'\n", ptr->interface_name);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "say");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->interface_name);
+ switch_event_fire(&event);
+ }
+ switch_core_hash_delete(loadable_modules.say_hash, ptr->interface_name);
+ }
+ }
+ }
+
+ if (old_module->module_interface->management_interface) {
+ const switch_management_interface_t *ptr;
+
+ for (ptr = old_module->module_interface->management_interface; ptr; ptr = ptr->next) {
+ if (ptr->relative_oid) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
+ "Deleting Management interface '%s' OID[%s.%s]\n", old_module->key, FREESWITCH_OID_PREFIX, ptr->relative_oid);
+ switch_core_hash_delete(loadable_modules.management_hash, ptr->relative_oid);
+ if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "type", "management");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "name", "%s", ptr->relative_oid);
+ switch_event_fire(&event);
+ }
+ }
+ }
+ }
+ switch_mutex_unlock(loadable_modules.mutex);
return SWITCH_STATUS_SUCCESS;
}
+
static switch_status_t switch_loadable_module_load_file(char *filename, switch_loadable_module_t **new_module)
{
switch_loadable_module_t *module = NULL;
@@ -398,12 +649,18 @@
const char *err = NULL;
switch_loadable_module_interface_t *module_interface = NULL;
char derr[512] = "";
+ switch_memory_pool_t *pool;
assert(filename != NULL);
*new_module = NULL;
status = switch_dso_load(&dso, filename, loadable_modules.pool);
+ if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
+ abort();
+ }
+
while (loading) {
if (status != APR_SUCCESS) {
switch_dso_error(dso, derr, sizeof(derr));
@@ -419,26 +676,37 @@
break;
}
- if (load_func_ptr(&module_interface, filename) != SWITCH_STATUS_SUCCESS) {
+ status = load_func_ptr(&module_interface, filename);
+
+ if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_NOUNLOAD) {
err = "Module load routine returned an error";
module_interface = NULL;
break;
}
- if ((module = switch_core_permanent_alloc(sizeof(switch_loadable_module_t))) == 0) {
+ if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
err = "Could not allocate memory\n";
- break;
+ abort();
}
+ if (status == SWITCH_STATUS_NOUNLOAD) {
+ module->perm++;
+ }
+
loading = 0;
}
+
if (err) {
+ if (pool) {
+ switch_core_destroy_memory_pool(&pool);
+ }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Loading module %s\n**%s**\n", filename, err);
return SWITCH_STATUS_GENERR;
}
- module->filename = switch_core_permanent_strdup(filename);
+ module->pool = pool;
+ module->filename = switch_core_strdup(module->pool, filename);
module->module_interface = module_interface;
module->switch_module_load = load_func_ptr;
@@ -456,7 +724,7 @@
}
-SWITCH_DECLARE(switch_status_t) switch_loadable_module_load_module(char *dir, char *fname, switch_bool_t runtime)
+SWITCH_DECLARE(switch_status_t) switch_loadable_module_load_module(char *dir, char *fname, switch_bool_t runtime, const char **err)
{
switch_size_t len = 0;
char *path;
@@ -495,18 +763,82 @@
}
}
+ switch_mutex_lock(loadable_modules.mutex);
if (switch_core_hash_find(loadable_modules.module_hash, file)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Module %s Already Loaded!\n", file);
- return SWITCH_STATUS_FALSE;
- }
-
- if ((status = switch_loadable_module_load_file(path, &new_module) == SWITCH_STATUS_SUCCESS)) {
+ *err = "Module already loadedn\n";
+ status = SWITCH_STATUS_FALSE;
+ } else if ((status = switch_loadable_module_load_file(path, &new_module) == SWITCH_STATUS_SUCCESS)) {
if ((status = switch_loadable_module_process((char *) file, new_module)) == SWITCH_STATUS_SUCCESS && runtime) {
if (new_module->switch_module_runtime) {
- switch_core_launch_thread(switch_loadable_module_exec, new_module, loadable_modules.pool);
+ switch_core_launch_thread(switch_loadable_module_exec, new_module, new_module->pool);
}
}
}
+ switch_mutex_unlock(loadable_modules.mutex);
+
+ return status;
+
+}
+
+
+
+SWITCH_DECLARE(switch_status_t) switch_loadable_module_unload_module(char *dir, char *fname, const char **err)
+{
+ switch_size_t len = 0;
+ char *path = NULL;
+ char *file = NULL;
+ switch_loadable_module_t *module = NULL;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+#ifdef WIN32
+ const char *ext = ".dll";
+#elif defined (MACOSX) || defined (DARWIN)
+ const char *ext = ".dylib";
+#else
+ const char *ext = ".so";
+#endif
+
+
+ if (!(file = strdup(fname))) {
+ abort();
+ }
+
+ if (*file == '/') {
+ path = strdup(file);
+ } else {
+ if (strchr(file, '.')) {
+ len = strlen(dir);
+ len += strlen(file);
+ len += 4;
+ path = (char *) switch_core_alloc(loadable_modules.pool, len);
+ snprintf(path, len, "%s%s%s", dir, SWITCH_PATH_SEPARATOR, file);
+ } else {
+ len = strlen(dir);
+ len += strlen(file);
+ len += 8;
+ path = (char *) malloc(len);
+ snprintf(path, len, "%s%s%s%s", dir, SWITCH_PATH_SEPARATOR, file, ext);
+ }
+ }
+
+
+ switch_mutex_lock(loadable_modules.mutex);
+ if ((module = switch_core_hash_find(loadable_modules.module_hash, file))) {
+ if (module->perm) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Module is not unloadable.\n");
+ *err = "Module is not unloadable";
+ status = SWITCH_STATUS_NOUNLOAD;
+ } else {
+ do_shutdown(module);
+ }
+ } else {
+ status = SWITCH_STATUS_FALSE;
+ }
+ switch_mutex_unlock(loadable_modules.mutex);
+
+ switch_safe_free(file);
+ switch_safe_free(path);
return status;
@@ -522,40 +854,58 @@
int loading = 1;
const char *err = NULL;
switch_loadable_module_interface_t *module_interface = NULL;
+ switch_memory_pool_t *pool;
- if ((module = switch_core_permanent_alloc(sizeof(switch_loadable_module_t))) == 0) {
+
+ if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
+ abort();
+ }
+
+ if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Couldn't allocate memory\n");
- return SWITCH_STATUS_GENERR;
+ abort();
}
+
+
while (loading) {
load_func_ptr = (switch_module_load_t) switch_module_load;
+ switch_status_t status;
if (load_func_ptr == NULL) {
err = "Cannot Load";
break;
}
- if (load_func_ptr(&module_interface, filename) != SWITCH_STATUS_SUCCESS) {
+ status = load_func_ptr(&module_interface, filename);
+
+ if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_NOUNLOAD) {
err = "Module load routine returned an error";
module_interface = NULL;
break;
}
- if ((module = switch_core_permanent_alloc(sizeof(switch_loadable_module_t))) == 0) {
+ if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
err = "Could not allocate memory\n";
- break;
+ abort();
+ }
+
+ if (status == SWITCH_STATUS_NOUNLOAD) {
+ module->perm++;
}
loading = 0;
}
if (err) {
+ switch_core_destroy_memory_pool(&pool);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error Loading module %s\n**%s**\n", filename, err);
return SWITCH_STATUS_GENERR;
}
- module->filename = switch_core_permanent_strdup(filename);
+ module->pool = pool;
+ module->filename = switch_core_strdup(module->pool, filename);
module->module_interface = module_interface;
module->switch_module_load = load_func_ptr;
@@ -566,7 +916,7 @@
module->switch_module_runtime = switch_module_runtime;
}
if (module->switch_module_runtime) {
- switch_core_launch_thread(switch_loadable_module_exec, module, loadable_modules.pool);
+ switch_core_launch_thread(switch_loadable_module_exec, module, module->pool);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Successfully Loaded [%s]\n", module_interface->module_name);
return switch_loadable_module_process((char *) module->filename, module);
@@ -599,6 +949,8 @@
switch_xml_t cfg, xml;
unsigned char all = 0;
unsigned int count = 0;
+ const char *err;
+
#ifdef WIN32
const char *ext = ".dll";
@@ -633,10 +985,10 @@
switch_core_hash_init(&loadable_modules.say_hash, loadable_modules.pool);
switch_core_hash_init(&loadable_modules.management_hash, loadable_modules.pool);
switch_core_hash_init(&loadable_modules.dialplan_hash, loadable_modules.pool);
+ switch_mutex_init(&loadable_modules.mutex, SWITCH_MUTEX_NESTED, loadable_modules.pool);
if ((xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
switch_xml_t mods, ld;
-
if ((mods = switch_xml_child(cfg, "modules"))) {
for (ld = switch_xml_child(mods, "load"); ld; ld = ld->next) {
const char *val = switch_xml_attr_soft(ld, "module");
@@ -644,7 +996,7 @@
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Invalid extension for %s\n", val);
continue;
}
- switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) val, SWITCH_FALSE);
+ switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) val, SWITCH_FALSE, &err);
count++;
}
}
@@ -664,7 +1016,7 @@
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Invalid extension for %s\n", val);
continue;
}
- switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) val, SWITCH_FALSE);
+ switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) val, SWITCH_FALSE, &err);
count++;
}
}
@@ -687,6 +1039,7 @@
while (apr_dir_read(&finfo, finfo_flags, module_dir_handle) == APR_SUCCESS) {
const char *fname = finfo.fname;
+ const char *err;
if (finfo.filetype != APR_REG) {
continue;
@@ -704,7 +1057,7 @@
continue;
}
- switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) fname, SWITCH_FALSE);
+ switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) fname, SWITCH_FALSE, &err);
}
apr_dir_close(module_dir_handle);
}
@@ -714,35 +1067,58 @@
return SWITCH_STATUS_SUCCESS;
}
+static void do_shutdown(switch_loadable_module_t *module)
+{
+ assert(module != NULL);
+
+ switch_loadable_module_unprocess(module);
+
+ if (module->switch_module_shutdown) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping: %s\n", module->module_interface->module_name);
+ if (module->switch_module_shutdown() == SWITCH_STATUS_UNLOAD) {
+ switch_memory_pool_t *pool;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s unloaded.\n", module->module_interface->module_name);
+ switch_dso_unload(module->lib);
+ module->lib = NULL;
+ if ((pool = module->pool)) {
+ module = NULL;
+ switch_core_destroy_memory_pool(&pool);
+ }
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s shutdown.\n", module->module_interface->module_name);
+ }
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s has no shutdown routine\n", module->module_interface->module_name);
+ }
+
+
+ switch_core_hash_delete_locked(loadable_modules.module_hash, module->key, loadable_modules.mutex);
+
+}
+
SWITCH_DECLARE(void) switch_loadable_module_shutdown(void)
{
switch_hash_index_t *hi;
void *val;
switch_loadable_module_t *module;
-
+
for (hi = switch_hash_first(loadable_modules.pool, loadable_modules.module_hash); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, NULL, NULL, &val);
module = (switch_loadable_module_t *) val;
-
- if (module->switch_module_shutdown) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping: %s\n", module->module_interface->module_name);
- if (module->switch_module_shutdown() == SWITCH_STATUS_UNLOAD) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s unloaded.\n", module->module_interface->module_name);
- switch_dso_unload(module->lib);
- module->lib = NULL;
- } else {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s shutdown.\n", module->module_interface->module_name);
- }
- } else {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s has no shutdown routine\n", module->module_interface->module_name);
- }
+ do_shutdown(module);
}
}
SWITCH_DECLARE(switch_endpoint_interface_t *) switch_loadable_module_get_endpoint_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.endpoint_hash, name);
+ switch_endpoint_interface_t *ptr;
+
+ switch_mutex_lock(loadable_modules.mutex);
+ ptr = switch_core_hash_find(loadable_modules.endpoint_hash, name);
+ switch_mutex_unlock(loadable_modules.mutex);
+
+ return ptr;
}
SWITCH_DECLARE(switch_codec_interface_t *) switch_loadable_module_get_codec_interface(char *name)
@@ -751,6 +1127,7 @@
switch_codec_interface_t *codec;
switch_size_t x;
+ switch_mutex_lock(loadable_modules.mutex);
if (!(codec = switch_core_hash_find(loadable_modules.codec_hash, name))) {
for (x = 0; x < strlen(name); x++) {
altname[x] = (char) toupper((int) name[x]);
@@ -762,62 +1139,63 @@
codec = switch_core_hash_find(loadable_modules.codec_hash, altname);
}
}
+ switch_mutex_unlock(loadable_modules.mutex);
return codec;
}
SWITCH_DECLARE(switch_dialplan_interface_t *) switch_loadable_module_get_dialplan_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.dialplan_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.dialplan_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_timer_interface_t *) switch_loadable_module_get_timer_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.timer_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.timer_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_application_interface_t *) switch_loadable_module_get_application_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.application_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.application_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_api_interface_t *) switch_loadable_module_get_api_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.api_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.api_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_file_interface_t *) switch_loadable_module_get_file_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.file_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.file_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_speech_interface_t *) switch_loadable_module_get_speech_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.speech_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.speech_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_asr_interface_t *) switch_loadable_module_get_asr_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.asr_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.asr_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_directory_interface_t *) switch_loadable_module_get_directory_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.directory_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.directory_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_chat_interface_t *) switch_loadable_module_get_chat_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.chat_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.chat_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_say_interface_t *) switch_loadable_module_get_say_interface(char *name)
{
- return switch_core_hash_find(loadable_modules.say_hash, name);
+ return switch_core_hash_find_locked(loadable_modules.say_hash, name, loadable_modules.mutex);
}
SWITCH_DECLARE(switch_management_interface_t *) switch_loadable_module_get_management_interface(char *relative_oid)
{
- return switch_core_hash_find(loadable_modules.management_hash, relative_oid);
+ return switch_core_hash_find_locked(loadable_modules.management_hash, relative_oid, loadable_modules.mutex);
}
SWITCH_DECLARE(int) switch_loadable_module_get_codecs(switch_memory_pool_t *pool, const switch_codec_implementation_t **array, int arraylen)
@@ -828,6 +1206,7 @@
int i = 0;
const switch_codec_implementation_t *imp;
+ switch_mutex_lock(loadable_modules.mutex);
for (hi = switch_hash_first(pool, loadable_modules.codec_hash); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, NULL, NULL, &val);
codec_interface = (switch_codec_interface_t *) val;
@@ -848,6 +1227,8 @@
}
}
+ switch_mutex_unlock(loadable_modules.mutex);
+
return i;
}
@@ -858,6 +1239,8 @@
switch_codec_interface_t *codec_interface;
const switch_codec_implementation_t *imp;
+ switch_mutex_lock(loadable_modules.mutex);
+
for (x = 0; x < preflen; x++) {
char *cur, *last = NULL, *next = NULL, *name, *p, buf[256];
uint32_t interval = 0, rate = 0;
@@ -930,6 +1313,9 @@
}
}
+ switch_mutex_unlock(loadable_modules.mutex);
+
+
return i;
}