switch_loadable_module.c File Reference

#include <switch.h>
#include <apr_strings.h>
#include <apr_env.h>
#include <apr_file_io.h>

Include dependency graph for switch_loadable_module.c:

Go to the source code of this file.

Data Structures
struct	switch_file_node_s
struct	switch_codec_node_s
struct	switch_loadable_module
struct	switch_loadable_module_container
struct	switch_say_file_handle

Macros
#define	CHAT_MAX_MSG_QUEUE   101
#define	CHAT_QUEUE_SIZE   5000
#define	HASH_FUNC(_kind_)
#define	ALLOC_INTERFACE(_TYPE_)

Typedefs
typedef struct switch_file_node_s	switch_file_node_t
typedef struct switch_codec_node_s	switch_codec_node_t

Functions
static switch_status_t	do_shutdown (switch_loadable_module_t *module, switch_bool_t shutdown, switch_bool_t unload, switch_bool_t fail_if_busy, const char **err)
static switch_status_t	switch_loadable_module_load_module_ex (char *dir, char *fname, switch_bool_t runtime, switch_bool_t global, const char **err)
static void *SWITCH_THREAD_FUNC	switch_loadable_module_exec (switch_thread_t *thread, void *obj)
static void	switch_loadable_module_runtime (void)
static switch_status_t	switch_loadable_module_process (char *key, switch_loadable_module_t *new_module)
static switch_status_t	do_chat_send (switch_event_t *message_event)
static switch_status_t	chat_process_event (switch_event_t **eventp)
void *SWITCH_THREAD_FUNC	chat_thread_run (switch_thread_t *thread, void *obj)
static void	chat_thread_start (int idx)
static void	chat_queue_message (switch_event_t **eventp)
switch_status_t	switch_core_execute_chat_app (switch_event_t *message, const char *app, const char *data)
switch_status_t	switch_core_chat_send_args (const char *dest_proto, const char *proto, const char *from, const char *to, const char *subject, const char *body, const char *type, const char *hint, switch_bool_t blocking)
switch_status_t	switch_core_chat_send (const char *dest_proto, switch_event_t *message_event)
switch_status_t	switch_core_chat_deliver (const char *dest_proto, switch_event_t **message_event)
static switch_status_t	switch_loadable_module_unprocess (switch_loadable_module_t *old_module)
static switch_status_t	switch_loadable_module_load_file (char *path, char *filename, switch_bool_t global, switch_loadable_module_t **new_module)
switch_status_t	switch_loadable_module_load_module (char *dir, char *fname, switch_bool_t runtime, const char **err)
	Load a module. More...
switch_status_t	switch_loadable_module_exists (const char *mod)
	Check if a module is loaded. More...
switch_status_t	switch_loadable_module_unload_module (char *dir, char *fname, switch_bool_t force, const char **err)
	Unoad a module. More...
switch_status_t	switch_loadable_module_enumerate_available (const char *dir_path, switch_modulename_callback_func_t callback, void *user_data)
	Enumerates a list of all modules discovered in a directory. More...
switch_status_t	switch_loadable_module_enumerate_loaded (switch_modulename_callback_func_t callback, void *user_data)
	Enumerates a list of all currently loaded modules. More...
switch_status_t	switch_loadable_module_build_dynamic (char *filename, switch_module_load_t switch_module_load, switch_module_runtime_t switch_module_runtime, switch_module_shutdown_t switch_module_shutdown, switch_bool_t runtime)
	build a dynamic module object and register it (for use in double embeded modules) More...
switch_status_t	switch_loadable_module_init (switch_bool_t autoload)
	Initilize the module backend and load all the modules. More...
void	switch_loadable_module_shutdown (void)
	Shutdown the module backend and call the shutdown routine in all loaded modules. More...
switch_endpoint_interface_t *	switch_loadable_module_get_endpoint_interface (const char *name)
	Retrieve the endpoint interface by it's registered name. More...
switch_file_interface_t *	switch_loadable_module_get_file_interface (const char *name, const char *modname)
	Retrieve the file format interface by it's registered name. More...
switch_codec_interface_t *	switch_loadable_module_get_codec_interface (const char *name, const char *modname)
	Retrieve the codec interface by it's registered name. More...
switch_say_interface_t *	switch_loadable_module_get_say_interface (const char *name)
	Retrieve the say interface by it's registered name. More...
switch_management_interface_t *	switch_loadable_module_get_management_interface (const char *relative_oid)
	Retrieve the management interface by it's registered name. More...
static void	do_swap (const switch_codec_implementation_t **array, int a, int b)
static void	switch_loadable_module_sort_codecs (const switch_codec_implementation_t **array, int arraylen)
int	switch_loadable_module_get_codecs (const switch_codec_implementation_t **array, int arraylen)
	Retrieve the list of loaded codecs into an array. More...
char *	switch_parse_codec_buf (char *buf, uint32_t *interval, uint32_t *rate, uint32_t *bit, uint32_t *channels, char **modname)
int	switch_loadable_module_get_codecs_sorted (const switch_codec_implementation_t **array, int arraylen, char **prefs, int preflen)
	Retrieve the list of loaded codecs into an array based on another array showing the sorted order. More...
switch_status_t	switch_api_execute (const char *cmd, const char *arg, switch_core_session_t *session, switch_stream_handle_t *stream)
	Execute a registered API command. More...
switch_status_t	switch_json_api_execute (cJSON *json, switch_core_session_t *session, cJSON **retval)
	Execute a registered JSON API command. More...
switch_loadable_module_interface_t *	switch_loadable_module_create_module_interface (switch_memory_pool_t *pool, const char *name)
void *	switch_loadable_module_create_interface (switch_loadable_module_interface_t *mod, switch_module_interface_name_t iname)
char *	switch_say_file_handle_get_variable (switch_say_file_handle_t *sh, const char *var)
char *	switch_say_file_handle_get_path (switch_say_file_handle_t *sh)
char *	switch_say_file_handle_detach_path (switch_say_file_handle_t *sh)
void	switch_say_file_handle_destroy (switch_say_file_handle_t **sh)
switch_status_t	switch_say_file_handle_create (switch_say_file_handle_t **sh, const char *ext, switch_event_t **var_event)
void	switch_say_file (switch_say_file_handle_t *sh, const char *fmt,...)
switch_core_recover_callback_t	switch_core_get_secondary_recover_callback (const char *key)
switch_status_t	switch_core_register_secondary_recover_callback (const char *key, switch_core_recover_callback_t cb)
void	switch_core_unregister_secondary_recover_callback (const char *key)

Variables
static struct switch_loadable_module_container	loadable_modules
struct {
switch_queue_t *   msg_queue [CHAT_MAX_MSG_QUEUE]
switch_thread_t *   msg_queue_thread [CHAT_MAX_MSG_QUEUE]
int   msg_queue_len
switch_mutex_t *   mutex
switch_memory_pool_t *   pool
int   running
}	chat_globals
static int	IDX = 0

Macro Definition Documentation

#define ALLOC_INTERFACE

(

_TYPE_

)

Value:

{                                                                       \
                switch_##_TYPE_##_interface_t *i, *ptr;                                                 \
                i = switch_core_alloc(mod->pool, sizeof(switch_##_TYPE_##_interface_t)); \
		switch_assert(i != NULL);                                                                                             \
                for (ptr = mod->_TYPE_##_interface; ptr && ptr->next; ptr = ptr->next); \
		if (ptr) {                                                                                                            \
                        ptr->next = i;                                                                                          \
                } else {                                                                                                                \
                        mod->_TYPE_##_interface = i;                                                            \
                }                                                                                                                               \
		switch_thread_rwlock_create(&i->rwlock, mod->pool);                           \
		switch_mutex_init(&i->reflock, SWITCH_MUTEX_NESTED, mod->pool);       \
                i->parent = mod;                                                                                                \
		return i; }

Definition at line 2634 of file switch_loadable_module.c.

Referenced by switch_loadable_module_create_interface().

#define CHAT_MAX_MSG_QUEUE   101

Definition at line 589 of file switch_loadable_module.c.

Referenced by chat_queue_message(), and chat_thread_start().

#define CHAT_QUEUE_SIZE   5000

Definition at line 590 of file switch_loadable_module.c.

Referenced by chat_thread_start().

#define HASH_FUNC

(

_kind_

)

Value:

SWITCH_DECLARE(switch_##_kind_##_interface_t *) switch_loadable_module_get_##_kind_##_interface(const char *name)       \
        {                                                                                                                                       \
                switch_##_kind_##_interface_t *i = NULL;                                                                \
                if (loadable_modules._kind_##_hash && (i = switch_core_hash_find_locked(loadable_modules._kind_##_hash, name, loadable_modules.mutex))) {       \
                        PROTECT_INTERFACE(i);                                                                           \
                }                                                                                                                               \
                return i;                                                                                                               \
        }

Definition at line 2177 of file switch_loadable_module.c.

Typedef Documentation

typedef struct switch_codec_node_s switch_codec_node_t

typedef struct switch_file_node_s switch_file_node_t

Function Documentation

static switch_status_t chat_process_event ( switch_event_t **  eventp )

static

Definition at line 713 of file switch_loadable_module.c.

References do_chat_send(), switch_assert, and switch_event_destroy().

Referenced by chat_queue_message(), chat_thread_run(), and switch_core_chat_send_args().

{
        switch_event_t *event;
        switch_status_t status;

        switch_assert(eventp);

        event = *eventp;
        *eventp = NULL;

        status = do_chat_send(event);
        switch_event_destroy(&event);

        return status;
}

static void chat_queue_message ( switch_event_t **  eventp )

static

Definition at line 784 of file switch_loadable_module.c.

References chat_globals, CHAT_MAX_MSG_QUEUE, chat_process_event(), chat_thread_start(), IDX, switch_assert, switch_mutex_lock(), switch_mutex_unlock(), switch_queue_push(), switch_queue_trypush(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_chat_deliver(), switch_core_chat_send(), and switch_core_chat_send_args().

{
        int idx = 0;
        switch_event_t *event;

        switch_assert(eventp);

        event = *eventp;
        *eventp = NULL;
        
        if (chat_globals.running == 0) {
                chat_process_event(&event);
                return;
        }

 again:

        switch_mutex_lock(chat_globals.mutex);
        idx = IDX;
        IDX++; 
        if (IDX >= chat_globals.msg_queue_len) IDX = 0;
        switch_mutex_unlock(chat_globals.mutex);
        
        chat_thread_start(idx);

        if (switch_queue_trypush(chat_globals.msg_queue[idx], event) != SWITCH_STATUS_SUCCESS) {
                if (chat_globals.msg_queue_len < CHAT_MAX_MSG_QUEUE) {
                        chat_thread_start(idx + 1);
                        goto again;
                } else {
                        switch_queue_push(chat_globals.msg_queue[idx], event);
                }
        }
}

void* SWITCH_THREAD_FUNC chat_thread_run	(	switch_thread_t *	thread,
		void *	obj
	)

Definition at line 730 of file switch_loadable_module.c.

References chat_process_event(), SWITCH_CHANNEL_LOG, switch_cond_next(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_queue_pop(), and SWITCH_STATUS_SUCCESS.

Referenced by chat_thread_start().

{
        void *pop;
        switch_queue_t *q = (switch_queue_t *) obj;

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Chat Thread Started\n");


        while(switch_queue_pop(q, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                switch_event_t *event = (switch_event_t *) pop;
                chat_process_event(&event);
                switch_cond_next();
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Chat Thread Ended\n");

        return NULL;    
}

static void chat_thread_start ( int  idx )

static

Definition at line 750 of file switch_loadable_module.c.

References chat_globals, CHAT_MAX_MSG_QUEUE, CHAT_QUEUE_SIZE, chat_thread_run(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_create(), switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), and switch_threadattr_stacksize_set().

Referenced by chat_queue_message(), and switch_loadable_module_init().

{

        if (idx >= CHAT_MAX_MSG_QUEUE || (idx < chat_globals.msg_queue_len && chat_globals.msg_queue_thread[idx])) {
                return;
        }

        switch_mutex_lock(chat_globals.mutex);
        
        if (idx >= chat_globals.msg_queue_len) {
                int i;
                chat_globals.msg_queue_len = idx + 1;

                for (i = 0; i < chat_globals.msg_queue_len; i++) {
                        if (!chat_globals.msg_queue[i]) {
                                switch_threadattr_t *thd_attr = NULL;

                                switch_queue_create(&chat_globals.msg_queue[i], CHAT_QUEUE_SIZE, chat_globals.pool);

                                switch_threadattr_create(&thd_attr, chat_globals.pool);
                                switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                                switch_thread_create(&chat_globals.msg_queue_thread[i], 
                                                                         thd_attr, 
                                                                         chat_thread_run, 
                                                                         chat_globals.msg_queue[i], 
                                                                         chat_globals.pool);
                        }
                }
        }

        switch_mutex_unlock(chat_globals.mutex);
}

static switch_status_t do_chat_send ( switch_event_t *  message_event )

static

Definition at line 604 of file switch_loadable_module.c.

References switch_loadable_module_container::chat_hash, switch_chat_interface::chat_send, switch_chat_interface::interface_name, loadable_modules, switch_loadable_module_container::mutex, SWITCH_CHANNEL_LOG, switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_event_add_header_string(), switch_event_dup(), switch_event_fire, switch_event_get_header, switch_loadable_module_get_chat_interface(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_stristr(), switch_true(), and UNPROTECT_INTERFACE.

Referenced by chat_process_event().

{
        switch_chat_interface_t *ci;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_hash_index_t *hi;
        switch_event_t *dup = NULL;
        const void *var;
        void *val;
        const char *proto;
        const char *replying;
        const char *dest_proto;
        int do_skip = 0;

        /*

        const char *from; 
        const char *to;
        const char *subject;
        const char *body;
        const char *type;
        const char *hint;
        */              

        dest_proto = switch_event_get_header(message_event, "dest_proto");

        if (!dest_proto) {
                return SWITCH_STATUS_FALSE;
        }

        /*

        from = switch_event_get_header(message_event, "from");
        to = switch_event_get_header(message_event, "to");
        subject = switch_event_get_header(message_event, "subject");
        body = switch_event_get_body(message_event);
        type = switch_event_get_header(message_event, "type");
        hint = switch_event_get_header(message_event, "hint");
        */

        if (!(proto = switch_event_get_header(message_event, "proto"))) {
                proto = "global";
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "proto", proto);
        }

        replying = switch_event_get_header(message_event, "replying");

        if (!switch_true(replying) && !switch_stristr("global", proto) && !switch_true(switch_event_get_header(message_event, "skip_global_process"))) {
                switch_mutex_lock(loadable_modules.mutex);
                for (hi = switch_core_hash_first(loadable_modules.chat_hash); hi; hi = switch_core_hash_next(&hi)) {
                        switch_core_hash_this(hi, &var, NULL, &val);
                        
                        if ((ci = (switch_chat_interface_t *) val)) {
                                if (ci->chat_send && !strncasecmp(ci->interface_name, "GLOBAL_", 7)) {
                                        status = ci->chat_send(message_event);
                                        
                                        if (status == SWITCH_STATUS_SUCCESS) {
                                                if (switch_true(switch_event_get_header(message_event, "final_delivery"))) {
                                                        /* The event was handled by an extension in the chatplan, 
                                                         * so the event will be duplicated, modified and queued again, 
                                                         * but it won't be processed by the chatplan again.
                                                         * So this copy of the event can be destroyed by the caller.
                                                         */ 
                                                        do_skip = 1;
                                                }
                                        } else if (status == SWITCH_STATUS_BREAK) {
                                                /* The event went through the chatplan, but no extension matched
                                                 * to handle the sms messsage. It'll be attempted to be delivered
                                                 * directly, and unless that works the sms delivery will have failed.
                                                 */
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Chat Interface Error [%s]!\n", dest_proto);
                                                break;
                                        }
                                }
                        }
                }
                switch_safe_free(hi);
                switch_mutex_unlock(loadable_modules.mutex);
        }
        

        if (!do_skip && !switch_stristr("GLOBAL", dest_proto)) {
                if ((ci = switch_loadable_module_get_chat_interface(dest_proto)) && ci->chat_send) {
                        status = ci->chat_send(message_event);
                        UNPROTECT_INTERFACE(ci);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid chat interface [%s]!\n", dest_proto);
                        status = SWITCH_STATUS_FALSE;
                }
        }


        switch_event_dup(&dup, message_event);

        if ( switch_true(switch_event_get_header(message_event, "blocking")) ) {
                if (status == SWITCH_STATUS_SUCCESS) {
                        switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "Delivery-Failure", "false");
                } else {
                        switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "Delivery-Failure", "true");
                }
        } else {
                switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "Nonblocking-Delivery", "true");
        }

        switch_event_fire(&dup);
        return status;
}

static switch_status_t do_shutdown ( switch_loadable_module_t *  module, switch_bool_t  shutdown, switch_bool_t  unload, switch_bool_t  fail_if_busy, const char **  err  )

static

Definition at line 1993 of file switch_loadable_module.c.

References switch_loadable_module::lib, switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_loadable_module::pool, pool, switch_loadable_module_interface::rwlock, SCF_VG, switch_loadable_module::shutting_down, switch_loadable_module::status, switch_assert, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, switch_core_flags(), switch_dso_destroy(), switch_loadable_module_unprocess(), SWITCH_LOG_CONSOLE, switch_log_printf(), SWITCH_LOG_WARNING, switch_loadable_module::switch_module_shutdown, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOUNLOAD, SWITCH_STATUS_SUCCESS, switch_thread_join(), switch_thread_rwlock_trywrlock(), switch_thread_rwlock_unlock(), SWITCH_TRUE, and switch_loadable_module::thread.

Referenced by switch_loadable_module_shutdown(), and switch_loadable_module_unload_module().

{
        int32_t flags = switch_core_flags();
        switch_assert(module != NULL);

        if (fail_if_busy && module->module_interface->rwlock && switch_thread_rwlock_trywrlock(module->module_interface->rwlock) != SWITCH_STATUS_SUCCESS) {
                if (err) {
                        *err = "Module in use.";
                }
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Module %s is in use, cannot unload.\n", module->module_interface->module_name);
                return SWITCH_STATUS_FALSE;
        }

        module->shutting_down = SWITCH_TRUE;

        if (shutdown) {
                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);
                        module->status = module->switch_module_shutdown();
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s has no shutdown routine\n", module->module_interface->module_name);
                }
        }

        if (fail_if_busy && module->module_interface->rwlock) {
                switch_thread_rwlock_unlock(module->module_interface->rwlock);
        }

        if (unload && module->status != SWITCH_STATUS_NOUNLOAD && !(flags & SCF_VG)) {
                switch_memory_pool_t *pool;
                switch_status_t st;

                if (module->thread) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s stopping runtime thread.\n", module->module_interface->module_name);
                        switch_thread_join(&st, module->thread);
                }

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s unloaded.\n", module->module_interface->module_name);
                switch_dso_destroy(&module->lib);
                if ((pool = module->pool)) {
                        module = NULL;
                        switch_core_destroy_memory_pool(&pool);
                }
        }

        return SWITCH_STATUS_SUCCESS;

}

static void do_swap ( const switch_codec_implementation_t **  array, int  a, int  b  )

static

Definition at line 2223 of file switch_loadable_module.c.

Referenced by switch_loadable_module_sort_codecs().

{
        const switch_codec_implementation_t *tmp = array[b];
        array[b] = array[a];
        array[a] = tmp;
}

switch_core_recover_callback_t switch_core_get_secondary_recover_callback

(

const char *

key

)

Definition at line 2802 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::mutex, switch_loadable_module_container::secondary_recover_hash, switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by recover_callback().

{
        switch_core_recover_callback_t cb;

        switch_mutex_lock(loadable_modules.mutex);
        cb = (switch_core_recover_callback_t) (intptr_t) switch_core_hash_find(loadable_modules.secondary_recover_hash, key);
        switch_mutex_unlock(loadable_modules.mutex);

        return cb;
}

switch_status_t switch_core_register_secondary_recover_callback	(	const char *	key,
		switch_core_recover_callback_t	cb
	)

Definition at line 2814 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::mutex, switch_loadable_module_container::secondary_recover_hash, switch_assert, switch_core_hash_find(), switch_core_hash_insert, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_assert(cb);

        switch_mutex_lock(loadable_modules.mutex);
        if (switch_core_hash_find(loadable_modules.secondary_recover_hash, key)) {
                status = SWITCH_STATUS_FALSE;
        } else {
                switch_core_hash_insert(loadable_modules.secondary_recover_hash, key, (void *)(intptr_t) cb);
        }
        switch_mutex_unlock(loadable_modules.mutex);

        return status;
}

void switch_core_unregister_secondary_recover_callback

(

const char *

key

)

Definition at line 2832 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::mutex, switch_loadable_module_container::secondary_recover_hash, switch_core_hash_delete(), switch_mutex_lock(), and switch_mutex_unlock().

{
        switch_mutex_lock(loadable_modules.mutex);
        switch_core_hash_delete(loadable_modules.secondary_recover_hash, key);
        switch_mutex_unlock(loadable_modules.mutex);
}

static void* SWITCH_THREAD_FUNC switch_loadable_module_exec ( switch_thread_t *  thread, void *  obj  )

static

Definition at line 100 of file switch_loadable_module.c.

References switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_core_thread_session::objs, switch_core_thread_session::pool, pool, switch_loadable_module::shutting_down, switch_assert, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, SWITCH_LOG_DEBUG, SWITCH_LOG_NOTICE, switch_log_printf(), switch_loadable_module::switch_module_runtime, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TERM, and switch_thread_exit().

Referenced by switch_loadable_module_build_dynamic(), switch_loadable_module_load_module_ex(), and switch_loadable_module_runtime().

{


        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_core_thread_session_t *ts = obj;
        switch_loadable_module_t *module = ts->objs[0];
        int restarts;

        switch_assert(thread != NULL);
        switch_assert(module != NULL);

        for (restarts = 0; status != SWITCH_STATUS_TERM && !module->shutting_down; restarts++) {
                status = module->switch_module_runtime();
        }
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Thread ended for %s\n", module->module_interface->module_name);

        if (ts->pool) {
                switch_memory_pool_t *pool = ts->pool;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroying Pool for %s\n", module->module_interface->module_name);
                switch_core_destroy_memory_pool(&pool);
        }
        switch_thread_exit(thread, 0);
        return NULL;
}

static switch_status_t switch_loadable_module_load_file ( char *  path, char *  filename, switch_bool_t  global, switch_loadable_module_t **  new_module  )

static

Definition at line 1401 of file switch_loadable_module.c.

References switch_loadable_module::filename, switch_loadable_module::lib, switch_directories::lib_dir, switch_loadable_module_function_table::load, switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_loadable_module::perm, switch_loadable_module::pool, pool, switch_loadable_module_function_table::runtime, switch_loadable_module_function_table::shutdown, SMODF_GLOBAL_SYMBOLS, SWITCH_API_VERSION, switch_loadable_module_function_table::switch_api_version, switch_assert, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_set_signal_handlers(), switch_core_sprintf(), switch_core_strdup, switch_dso_data_sym(), switch_dso_destroy(), switch_dso_open(), SWITCH_GLOBAL_dirs, SWITCH_LOG_CONSOLE, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, switch_log_printf(), switch_loadable_module::switch_module_load, switch_loadable_module::switch_module_runtime, switch_loadable_module::switch_module_shutdown, switch_mprintf(), switch_safe_free, SWITCH_STATUS_GENERR, SWITCH_STATUS_NOUNLOAD, SWITCH_STATUS_SUCCESS, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_loadable_module_load_module_ex().

{
        switch_loadable_module_t *module = NULL;
        switch_dso_lib_t dso = NULL;
        apr_status_t status = SWITCH_STATUS_SUCCESS;
        switch_loadable_module_function_table_t *interface_struct_handle = NULL;
        switch_loadable_module_function_table_t *mod_interface_functions = NULL;
        char *struct_name = NULL;
        switch_module_load_t load_func_ptr = NULL;
        int loading = 1;
        switch_loadable_module_interface_t *module_interface = NULL;
        char *derr = NULL;
        const char *err = NULL;
        switch_memory_pool_t *pool = NULL;
        switch_bool_t load_global = global;

        switch_assert(path != NULL);

        switch_core_new_memory_pool(&pool);
        *new_module = NULL;

        struct_name = switch_core_sprintf(pool, "%s_module_interface", filename);

#ifdef WIN32
        dso = switch_dso_open("FreeSwitch.dll", load_global, &derr);
#elif defined (MACOSX) || defined(DARWIN)
        {
                char *lib_path = switch_mprintf("%s/libfreeswitch.dylib", SWITCH_GLOBAL_dirs.lib_dir);
                dso = switch_dso_open(lib_path, load_global, &derr);
                switch_safe_free(lib_path);
        }
#else
        dso = switch_dso_open(NULL, load_global, &derr);
#endif
        if (!derr && dso) {
                interface_struct_handle = switch_dso_data_sym(dso, struct_name, &derr);
        }

        switch_safe_free(derr);

        if (!interface_struct_handle) {
                if (dso) switch_dso_destroy(&dso);
                dso = switch_dso_open(path, load_global, &derr);
        }

        while (loading) {
                if (derr) {
                        err = derr;
                        break;
                }

                if (!interface_struct_handle) {
                        interface_struct_handle = switch_dso_data_sym(dso, struct_name, &derr);
                }

                if (derr) {
                        err = derr;
                        break;
                }

                if (interface_struct_handle && interface_struct_handle->switch_api_version != SWITCH_API_VERSION) {
                        err = "Trying to load an out of date module, please rebuild the module.";
                        break;
                }

                if (!load_global && interface_struct_handle && switch_test_flag(interface_struct_handle, SMODF_GLOBAL_SYMBOLS)) {
                        load_global = SWITCH_TRUE;
                        switch_dso_destroy(&dso);
                        interface_struct_handle = NULL;
                        dso = switch_dso_open(path, load_global, &derr);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Loading module with global namespace at request of module\n");
                        continue;
                }

                if (interface_struct_handle) {
                        mod_interface_functions = interface_struct_handle;
                        load_func_ptr = mod_interface_functions->load;
                }

                if (load_func_ptr == NULL) {
                        err = "Cannot locate symbol 'switch_module_load' please make sure this is a valid module.";
                        break;
                }

                status = load_func_ptr(&module_interface, pool);

                if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_NOUNLOAD) {
                        err = "Module load routine returned an error";
                        module_interface = NULL;
                        break;
                }

                if (!module_interface) {
                        err = "Module failed to initialize its module_interface. Is this a valid module?";
                        break;
                }

                if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
                        err = "Could not allocate memory\n";
                        abort();
                }

                if (status == SWITCH_STATUS_NOUNLOAD) {
                        module->perm++;
                }

                loading = 0;
        }


        if (err) {

                if (dso) {
                        switch_dso_destroy(&dso);
                }

                if (pool) {
                        switch_core_destroy_memory_pool(&pool);
                }
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error Loading module %s\n**%s**\n", path, err);
                switch_safe_free(derr);
                return SWITCH_STATUS_GENERR;
        }

        module->pool = pool;
        module->filename = switch_core_strdup(module->pool, path);
        module->module_interface = module_interface;
        module->switch_module_load = load_func_ptr;

        if (mod_interface_functions) {
                module->switch_module_shutdown = mod_interface_functions->shutdown;
                module->switch_module_runtime = mod_interface_functions->runtime;
        }

        module->lib = dso;

        *new_module = module;
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Successfully Loaded [%s]\n", module_interface->module_name);

        switch_core_set_signal_handlers();

        return SWITCH_STATUS_SUCCESS;

}

static switch_status_t switch_loadable_module_load_module_ex ( char *  dir, char *  fname, switch_bool_t  runtime, switch_bool_t  global, const char **  err  )

static

Definition at line 1550 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::module_hash, switch_loadable_module_container::mutex, switch_loadable_module::pool, switch_loadable_module_container::pool, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_hash_find_locked(), switch_core_launch_thread(), switch_core_strdup, switch_cut_path(), switch_is_file_path(), switch_loadable_module_exec(), switch_loadable_module_load_file(), switch_loadable_module_process(), switch_log_printf(), SWITCH_LOG_WARNING, switch_loadable_module::switch_module_runtime, SWITCH_PATH_SEPARATOR, switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_loadable_module::thread.

Referenced by switch_loadable_module_init(), and switch_loadable_module_load_module().

{
        switch_size_t len = 0;
        char *path;
        char *file, *dot;
        switch_loadable_module_t *new_module = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

#ifdef WIN32
        const char *ext = ".dll";
#else
        const char *ext = ".so";
#endif

        *err = "";

        if ((file = switch_core_strdup(loadable_modules.pool, fname)) == 0) {
                *err = "allocation error";
                return SWITCH_STATUS_FALSE;
        }

        if (switch_is_file_path(file)) {
                path = switch_core_strdup(loadable_modules.pool, file);
                file = (char *) switch_cut_path(file);
                if ((dot = strchr(file, '.'))) {
                        *dot = '\0';
                }
        } else {
                if ((dot = strchr(file, '.'))) {
                        *dot = '\0';
                }
                len = strlen(dir);
                len += strlen(file);
                len += 8;
                path = (char *) switch_core_alloc(loadable_modules.pool, len);
                switch_snprintf(path, len, "%s%s%s%s", dir, SWITCH_PATH_SEPARATOR, file, ext);
        }


        if (switch_core_hash_find_locked(loadable_modules.module_hash, file, loadable_modules.mutex)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Module %s Already Loaded!\n", file);
                *err = "Module already loaded";
                status = SWITCH_STATUS_FALSE;
        } else if ((status = switch_loadable_module_load_file(path, file, global, &new_module)) == SWITCH_STATUS_SUCCESS) {
                if ((status = switch_loadable_module_process(file, new_module)) == SWITCH_STATUS_SUCCESS && runtime) {
                        if (new_module->switch_module_runtime) {
                                new_module->thread = switch_core_launch_thread(switch_loadable_module_exec, new_module, new_module->pool);
                        }
                } else if (status != SWITCH_STATUS_SUCCESS) {
                        *err = "module load routine returned an error";
                }
        } else {
                *err = "module load file routine returned an error";
        }


        return status;

}

static switch_status_t switch_loadable_module_process ( char *  key, switch_loadable_module_t *  new_module  )

static

Definition at line 146 of file switch_loadable_module.c.

References switch_codec_implementation::actual_samples_per_second, switch_loadable_module_container::api_hash, switch_loadable_module_interface::api_interface, switch_loadable_module_container::application_hash, switch_loadable_module_interface::application_interface, switch_loadable_module_container::asr_hash, switch_loadable_module_interface::asr_interface, switch_codec_implementation::bits_per_second, switch_loadable_module_container::chat_application_hash, switch_loadable_module_interface::chat_application_interface, switch_loadable_module_container::chat_hash, switch_loadable_module_interface::chat_interface, switch_loadable_module_container::codec_hash, switch_loadable_module_interface::codec_interface, switch_codec_implementation::decoded_bytes_per_packet, switch_api_interface::desc, switch_json_api_interface::desc, switch_loadable_module_container::dialplan_hash, switch_loadable_module_interface::dialplan_interface, switch_loadable_module_container::directory_hash, switch_loadable_module_interface::directory_interface, switch_loadable_module_container::endpoint_hash, switch_loadable_module_interface::endpoint_interface, switch_file_interface::extens, switch_loadable_module_container::file_hash, switch_loadable_module_interface::file_interface, switch_loadable_module::filename, FREESWITCH_OID_PREFIX, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec_interface::implementations, switch_file_node_s::interface_name, switch_codec_node_s::interface_name, switch_endpoint_interface::interface_name, switch_timer_interface::interface_name, switch_dialplan_interface::interface_name, switch_file_interface::interface_name, switch_asr_interface::interface_name, switch_speech_interface::interface_name, switch_say_interface::interface_name, switch_chat_interface::interface_name, switch_limit_interface::interface_name, switch_directory_interface::interface_name, switch_codec_interface::interface_name, switch_application_interface::interface_name, switch_chat_application_interface::interface_name, switch_api_interface::interface_name, switch_json_api_interface::interface_name, switch_loadable_module_container::json_api_hash, switch_loadable_module_interface::json_api_interface, switch_loadable_module::key, switch_loadable_module_container::limit_hash, switch_loadable_module_interface::limit_interface, loadable_modules, switch_loadable_module_container::management_hash, switch_loadable_module_interface::management_interface, switch_codec_implementation::microseconds_per_packet, switch_loadable_module_container::module_hash, switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_loadable_module_container::mutex, switch_file_node_s::next, switch_codec_node_s::next, switch_endpoint_interface::next, switch_timer_interface::next, switch_dialplan_interface::next, switch_file_interface::next, switch_asr_interface::next, switch_speech_interface::next, switch_say_interface::next, switch_chat_interface::next, switch_management_interface::next, switch_limit_interface::next, switch_directory_interface::next, switch_codec_implementation::next, switch_codec_interface::next, switch_application_interface::next, switch_chat_application_interface::next, switch_api_interface::next, switch_json_api_interface::next, switch_loadable_module::pool, switch_file_node_s::ptr, switch_codec_node_s::ptr, switch_management_interface::relative_oid, switch_loadable_module_container::say_hash, switch_loadable_module_interface::say_interface, switch_application_interface::short_desc, switch_chat_application_interface::short_desc, switch_loadable_module_container::speech_hash, switch_loadable_module_interface::speech_interface, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_hash_find(), switch_core_hash_insert, switch_core_strdup, switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_MODULE_LOAD, SWITCH_LOG_CRIT, SWITCH_LOG_NOTICE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_application_interface::syntax, switch_chat_application_interface::syntax, switch_api_interface::syntax, switch_json_api_interface::syntax, switch_loadable_module_container::timer_hash, and switch_loadable_module_interface::timer_interface.

Referenced by switch_loadable_module_build_dynamic(), and switch_loadable_module_load_module_ex().

{
        switch_event_t *event;
        int added = 0;

        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) {
                const switch_endpoint_interface_t *ptr;
                for (ptr = new_module->module_interface->endpoint_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load endpoint interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Endpoint '%s'\n", ptr->interface_name);
                                switch_core_hash_insert(loadable_modules.endpoint_hash, ptr->interface_name, (const void *) ptr);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "endpoint");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                        }
                }
        }

        if (new_module->module_interface->codec_interface) {
                const switch_codec_implementation_t *impl;
                const switch_codec_interface_t *ptr;

                for (ptr = new_module->module_interface->codec_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load codec interface from %s due to no interface name.\n", key);
                        } else {
                                unsigned load_interface = 1;
                                switch_codec_node_t *node, *head;

                                for (impl = ptr->implementations; impl; impl = impl->next) {
                                        if (!impl->iananame) {
                                                load_interface = 0;
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
                                                                                  "Failed to load codec interface %s from %s due to no iana name in an implementation.\n", ptr->interface_name,
                                                                                  key);
                                                break;
                                        }
                                        if (impl->decoded_bytes_per_packet > SWITCH_RECOMMENDED_BUFFER_SIZE) {
                                                load_interface = 0;
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
                                                                                  "Failed to load codec interface %s from %s due to bytes per frame %d exceeding buffer size %d.\n", 
                                                                                  ptr->interface_name,
                                                                                  key, impl->decoded_bytes_per_packet, SWITCH_RECOMMENDED_BUFFER_SIZE);
                                                break;
                                        }
                                }
                                if (load_interface) {
                                        for (impl = ptr->implementations; impl; impl = impl->next) {
                                                if (impl->bits_per_second) {
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
                                                                                          "Adding Codec %s %d %s %dhz %dms %dbps\n",
                                                                                          impl->iananame, impl->ianacode,
                                                                                          ptr->interface_name, impl->actual_samples_per_second, 
                                                                                          impl->microseconds_per_packet / 1000, impl->bits_per_second);
                                                } else {
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
                                                                                          "Adding Codec %s %d %s %dhz %dms (VBR)\n",
                                                                                          impl->iananame, impl->ianacode,
                                                                                          ptr->interface_name, impl->actual_samples_per_second, impl->microseconds_per_packet / 1000);
                                                }

                                                node = switch_core_alloc(new_module->pool, sizeof(*node));
                                                node->ptr = ptr;
                                                node->interface_name = switch_core_strdup(new_module->pool, new_module->module_interface->module_name);
                                                if ((head = switch_core_hash_find(loadable_modules.codec_hash, impl->iananame))) {
                                                        node->next = head;
                                                }

                                                switch_core_hash_insert(loadable_modules.codec_hash, impl->iananame, (const void *) node);
                                        }

                                        if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "codec");
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", new_module->module_interface->module_name);
                                                switch_event_fire(&event);
                                                added++;
                                        }
                                }
                        }
                }
        }

        if (new_module->module_interface->dialplan_interface) {
                const switch_dialplan_interface_t *ptr;

                for (ptr = new_module->module_interface->dialplan_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load dialplan interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Dialplan '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "dialplan");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.dialplan_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->timer_interface) {
                const switch_timer_interface_t *ptr;

                for (ptr = new_module->module_interface->timer_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load timer interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Timer '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "timer");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.timer_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->application_interface) {
                const switch_application_interface_t *ptr;

                for (ptr = new_module->module_interface->application_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load application interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Application '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.application_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->chat_application_interface) {
                const switch_chat_application_interface_t *ptr;

                for (ptr = new_module->module_interface->chat_application_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load application interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Chat Application '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.chat_application_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->api_interface) {
                const switch_api_interface_t *ptr;

                for (ptr = new_module->module_interface->api_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load api interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding API Function '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "api");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.api_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->json_api_interface) {
                const switch_json_api_interface_t *ptr;

                for (ptr = new_module->module_interface->json_api_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load JSON api interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding JSON API Function '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "json_api");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.json_api_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->file_interface) {
                const switch_file_interface_t *ptr;

                for (ptr = new_module->module_interface->file_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load file interface from %s due to no interface name.\n", key);
                        } else if (!ptr->extens) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load file interface from %s due to no file extensions.\n", key);
                        } else {
                                int i;
                                switch_file_node_t *node, *head;

                                for (i = 0; ptr->extens[i]; i++) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding File Format '%s'\n", ptr->extens[i]);
                                        if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "file");
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->extens[i]);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", new_module->module_interface->module_name);
                                                switch_event_fire(&event);
                                                added++;
                                        }
                                        node = switch_core_alloc(new_module->pool, sizeof(*node));
                                        node->ptr = ptr;
                                        node->interface_name = switch_core_strdup(new_module->pool, new_module->module_interface->module_name);
                                        if ((head = switch_core_hash_find(loadable_modules.file_hash, ptr->extens[i]))) {
                                                node->next = head;
                                        }

                                        switch_core_hash_insert(loadable_modules.file_hash, ptr->extens[i], (const void *) node);
                                }
                        }
                }
        }

        if (new_module->module_interface->speech_interface) {
                const switch_speech_interface_t *ptr;

                for (ptr = new_module->module_interface->speech_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load speech interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Speech interface '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "speech");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.speech_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->asr_interface) {
                const switch_asr_interface_t *ptr;

                for (ptr = new_module->module_interface->asr_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load asr interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding ASR interface '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "asr");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.asr_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->directory_interface) {
                const switch_directory_interface_t *ptr;

                for (ptr = new_module->module_interface->directory_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load directory interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Directory interface '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "directory");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.directory_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->chat_interface) {
                const switch_chat_interface_t *ptr;

                for (ptr = new_module->module_interface->chat_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load chat interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Chat interface '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "chat");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.chat_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->say_interface) {
                const switch_say_interface_t *ptr;

                for (ptr = new_module->module_interface->say_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load say interface from %s due to no interface name.\n", key);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Say interface '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "say");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                        switch_event_fire(&event);
                                        added++;
                                }
                                switch_core_hash_insert(loadable_modules.say_hash, ptr->interface_name, (const void *) ptr);
                        }
                }
        }

        if (new_module->module_interface->management_interface) {
                const switch_management_interface_t *ptr;

                for (ptr = new_module->module_interface->management_interface; ptr; ptr = ptr->next) {
                        if (!ptr->relative_oid) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load management interface from %s due to no interface name.\n", key);
                        } else {
                                if (switch_core_hash_find(loadable_modules.management_hash, ptr->relative_oid)) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
                                                                          "Failed to load management interface %s. OID %s already exists\n", key, ptr->relative_oid);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
                                                                          "Adding Management interface '%s' OID[%s.%s]\n", key, FREESWITCH_OID_PREFIX, ptr->relative_oid);
                                        switch_core_hash_insert(loadable_modules.management_hash, ptr->relative_oid, (const void *) ptr);
                                        if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "management");
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->relative_oid);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                                switch_event_fire(&event);
                                                added++;
                                        }
                                }

                        }
                }
        }
        if (new_module->module_interface->limit_interface) {
                const switch_limit_interface_t *ptr;

                for (ptr = new_module->module_interface->limit_interface; ptr; ptr = ptr->next) {
                        if (!ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load limit interface from %s due to no interface name.\n", key);
                        } else {
                                if (switch_core_hash_find(loadable_modules.limit_hash, ptr->interface_name)) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
                                                                          "Failed to load limit interface %s. Name %s already exists\n", key, ptr->interface_name);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
                                                                          "Adding Limit interface '%s'\n", ptr->interface_name);
                                        switch_core_hash_insert(loadable_modules.limit_hash, ptr->interface_name, (const void *) ptr);
                                        if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "limit");
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                                                switch_event_fire(&event);
                                                added++;
                                        }
                                }

                        }
                }
        }

        if (!added) {
                if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "generic");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", new_module->key);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
                        switch_event_fire(&event);
                        added++;
                }
        }

        switch_mutex_unlock(loadable_modules.mutex);
        return SWITCH_STATUS_SUCCESS;

}

static void switch_loadable_module_runtime ( void  )

static

Definition at line 127 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::module_hash, switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_loadable_module_container::mutex, switch_loadable_module_container::pool, SWITCH_CHANNEL_LOG, switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_launch_thread(), switch_loadable_module_exec(), SWITCH_LOG_CONSOLE, switch_log_printf(), switch_loadable_module::switch_module_runtime, switch_mutex_lock(), switch_mutex_unlock(), and switch_loadable_module::thread.

Referenced by switch_loadable_module_init().

{
        switch_hash_index_t *hi;
        void *val;
        switch_loadable_module_t *module;

        switch_mutex_lock(loadable_modules.mutex);
        for (hi = switch_core_hash_first(loadable_modules.module_hash); hi; hi = switch_core_hash_next(&hi)) {
                switch_core_hash_this(hi, NULL, NULL, &val);
                module = (switch_loadable_module_t *) val;

                if (module->switch_module_runtime) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Starting runtime thread for %s\n", module->module_interface->module_name);
                        module->thread = switch_core_launch_thread(switch_loadable_module_exec, module, loadable_modules.pool);
                }
        }
        switch_mutex_unlock(loadable_modules.mutex);
}

static void switch_loadable_module_sort_codecs ( const switch_codec_implementation_t **  array, int  arraylen  )

static

Definition at line 2230 of file switch_loadable_module.c.

References do_swap(), switch_codec_implementation::microseconds_per_packet, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, and switch_log_printf().

Referenced by switch_loadable_module_get_codecs(), and switch_loadable_module_get_codecs_sorted().

{
        int i = 0, sorted_ptime = 0;

#ifdef DEBUG_CODEC_SORTING
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--BEFORE\n");
        do_print(array, arraylen);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--BEFORE\n");
#endif

        for (i = 0; i < arraylen; i++) {
                int this_ptime = array[i]->microseconds_per_packet / 1000;
                
                if (!strcasecmp(array[i]->iananame, "ilbc")) {
                        this_ptime = 20;
                }

                if (!sorted_ptime) {
                        sorted_ptime = this_ptime;
#ifdef DEBUG_CODEC_SORTING
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "sorted1 = %d\n", sorted_ptime);
#endif
                }

                if (i > 0 && strcasecmp(array[i]->iananame, array[i-1]->iananame) && this_ptime != sorted_ptime) {
                        int j;
                        int swapped = 0;

#ifdef DEBUG_CODEC_SORTING
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%d != %d\n", this_ptime, sorted_ptime);
#endif
                        for(j = i; j < arraylen; j++) {
                                int check_ptime = array[j]->microseconds_per_packet / 1000;

                                if (!strcasecmp(array[i]->iananame, "ilbc")) {
                                        check_ptime = 20;
                                }

                                if (check_ptime == sorted_ptime) {
#ifdef DEBUG_CODEC_SORTING
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "swap %d %d ptime %d\n", i, j, check_ptime);
#endif
                                        do_swap(array, i, j);
                                        swapped = 1;
                                        break;
                                }
                        }

                        if (!swapped) {
                                sorted_ptime = this_ptime;
#ifdef DEBUG_CODEC_SORTING
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "sorted2 = %d\n", sorted_ptime);
#endif
                        }
                }
        }

#ifdef DEBUG_CODEC_SORTING
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--AFTER\n");
        do_print(array, arraylen);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--AFTER\n");
#endif

}

static switch_status_t switch_loadable_module_unprocess ( switch_loadable_module_t *  old_module )

static

Definition at line 928 of file switch_loadable_module.c.

References switch_codec_implementation::actual_samples_per_second, switch_loadable_module_container::api_hash, switch_loadable_module_interface::api_interface, switch_loadable_module_container::application_hash, switch_loadable_module_interface::application_interface, switch_loadable_module_container::asr_hash, switch_loadable_module_interface::asr_interface, switch_loadable_module_container::chat_application_hash, switch_loadable_module_interface::chat_application_interface, switch_loadable_module_container::chat_hash, switch_loadable_module_interface::chat_interface, switch_loadable_module_container::codec_hash, switch_loadable_module_interface::codec_interface, switch_api_interface::desc, switch_json_api_interface::desc, switch_loadable_module_container::dialplan_hash, switch_loadable_module_interface::dialplan_interface, switch_loadable_module_container::directory_hash, switch_loadable_module_interface::directory_interface, switch_loadable_module_container::endpoint_hash, switch_loadable_module_interface::endpoint_interface, switch_file_interface::extens, switch_loadable_module_container::file_hash, switch_loadable_module_interface::file_interface, FREESWITCH_OID_PREFIX, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec_interface::implementations, switch_file_node_s::interface_name, switch_codec_node_s::interface_name, switch_endpoint_interface::interface_name, switch_timer_interface::interface_name, switch_dialplan_interface::interface_name, switch_file_interface::interface_name, switch_asr_interface::interface_name, switch_speech_interface::interface_name, switch_say_interface::interface_name, switch_chat_interface::interface_name, switch_limit_interface::interface_name, switch_directory_interface::interface_name, switch_codec_interface::interface_name, switch_application_interface::interface_name, switch_chat_application_interface::interface_name, switch_api_interface::interface_name, switch_json_api_interface::interface_name, switch_loadable_module_container::json_api_hash, switch_loadable_module_interface::json_api_interface, switch_loadable_module::key, switch_loadable_module_container::limit_hash, switch_loadable_module_interface::limit_interface, loadable_modules, switch_loadable_module_container::management_hash, switch_loadable_module_interface::management_interface, switch_codec_implementation::microseconds_per_packet, switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_loadable_module_container::mutex, switch_file_node_s::next, switch_codec_node_s::next, switch_endpoint_interface::next, switch_timer_interface::next, switch_dialplan_interface::next, switch_file_interface::next, switch_asr_interface::next, switch_speech_interface::next, switch_say_interface::next, switch_chat_interface::next, switch_management_interface::next, switch_limit_interface::next, switch_directory_interface::next, switch_codec_implementation::next, switch_codec_interface::next, switch_application_interface::next, switch_chat_application_interface::next, switch_api_interface::next, switch_json_api_interface::next, switch_management_interface::relative_oid, switch_endpoint_interface::rwlock, switch_file_interface::rwlock, switch_asr_interface::rwlock, switch_speech_interface::rwlock, switch_say_interface::rwlock, switch_chat_interface::rwlock, switch_directory_interface::rwlock, switch_application_interface::rwlock, switch_chat_application_interface::rwlock, switch_api_interface::rwlock, switch_json_api_interface::rwlock, switch_loadable_module_container::say_hash, switch_loadable_module_interface::say_interface, switch_application_interface::short_desc, switch_chat_application_interface::short_desc, switch_loadable_module_container::speech_hash, switch_loadable_module_interface::speech_interface, SWITCH_CAUSE_MANAGER_REQUEST, SWITCH_CHANNEL_LOG, switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_insert, switch_core_session_hupall_endpoint(), switch_core_session_hupall_matching_var, SWITCH_CURRENT_APPLICATION_VARIABLE, switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_MODULE_UNLOAD, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_thread_rwlock_trywrlock_timeout(), switch_thread_rwlock_unlock(), switch_application_interface::syntax, switch_chat_application_interface::syntax, switch_api_interface::syntax, switch_json_api_interface::syntax, switch_loadable_module_container::timer_hash, and switch_loadable_module_interface::timer_interface.

Referenced by do_shutdown().

{
        switch_event_t *event;
        int removed = 0;

        switch_mutex_lock(loadable_modules.mutex);

        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_core_session_hupall_endpoint(ptr, SWITCH_CAUSE_MANAGER_REQUEST);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);
                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
                                }

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Endpoint '%s'\n", ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "endpoint");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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;
                switch_codec_node_t *node, *head, *last = NULL;

                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 %d %s %dhz %dms\n",
                                                                                  impl->iananame, impl->ianacode,
                                                                                  ptr->interface_name, impl->actual_samples_per_second, impl->microseconds_per_packet / 1000);
                                                switch_core_session_hupall_matching_var("read_codec", impl->iananame, SWITCH_CAUSE_MANAGER_REQUEST);
                                                switch_core_session_hupall_matching_var("write_codec", impl->iananame, SWITCH_CAUSE_MANAGER_REQUEST);

                                                if ((head = switch_core_hash_find(loadable_modules.codec_hash, impl->iananame))) {
                                                        for(node = head; node; node = node->next) {
                                                                if (!strcmp(node->interface_name, old_module->module_interface->module_name)) {
                                                                        if (node == head) {
                                                                                if ((node = node->next)) {
                                                                                        switch_core_hash_insert(loadable_modules.codec_hash, impl->iananame, (const void *) node);
                                                                                } else {
                                                                                        switch_core_hash_delete(loadable_modules.codec_hash, impl->iananame);
                                                                                }
                                                                        } else {
                                                                                if (last) {
                                                                                        last->next = node->next;
                                                                                }
                                                                        }
                                                                        break;
                                                                }
                                                                last = node;
                                                        }
                                                }
                                        }
                                        if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "codec");
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", old_module->module_interface->module_name);
                                                switch_event_fire(&event);
                                                removed++;
                                        }
                                }
                        }
                }
        }

        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_string(event, SWITCH_STACK_BOTTOM, "type", "dialplan");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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_string(event, SWITCH_STACK_BOTTOM, "type", "timer");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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);
                                switch_core_session_hupall_matching_var(SWITCH_CURRENT_APPLICATION_VARIABLE, ptr->interface_name, SWITCH_CAUSE_MANAGER_REQUEST);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);
                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
                                }

                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                switch_core_hash_delete(loadable_modules.application_hash, ptr->interface_name);
                        }
                }
        }

        if (old_module->module_interface->chat_application_interface) {
                const switch_chat_application_interface_t *ptr;
                for (ptr = old_module->module_interface->chat_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);
                                switch_core_session_hupall_matching_var(SWITCH_CURRENT_APPLICATION_VARIABLE, ptr->interface_name, SWITCH_CAUSE_MANAGER_REQUEST);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);
                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
                                }

                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                switch_core_hash_delete(loadable_modules.chat_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);

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
                                }


                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "api");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                switch_core_hash_delete(loadable_modules.api_hash, ptr->interface_name);
                        }
                }
        }

        if (old_module->module_interface->json_api_interface) {
                const switch_json_api_interface_t *ptr;

                for (ptr = old_module->module_interface->json_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);

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
                                }


                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "api");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                switch_core_hash_delete(loadable_modules.json_api_hash, ptr->interface_name);
                        }
                }
        }

        if (old_module->module_interface->file_interface) {
                const switch_file_interface_t *ptr;
                switch_file_node_t *node, *head, *last = NULL;

                for (ptr = old_module->module_interface->file_interface; ptr; ptr = ptr->next) {
                        if (ptr->interface_name) {
                                int i;

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
                                }

                                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_string(event, SWITCH_STACK_BOTTOM, "type", "file");
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->extens[i]);
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", old_module->module_interface->module_name);
                                                switch_event_fire(&event);
                                                removed++;
                                        }

                                        if ((head = switch_core_hash_find(loadable_modules.file_hash, ptr->extens[i]))) {
                                                for(node = head; node; node = node->next) {
                                                        if (!strcmp(node->interface_name, old_module->module_interface->module_name)) {
                                                                if (node == head) {
                                                                        if ((node = node->next)) {
                                                                                switch_core_hash_insert(loadable_modules.file_hash, ptr->extens[i], (const void *) node);
                                                                        } else {
                                                                                switch_core_hash_delete(loadable_modules.file_hash, ptr->extens[i]);
                                                                        }
                                                                } else {
                                                                        if (last) {
                                                                                last->next = node->next;
                                                                        }
                                                                }
                                                                break;
                                                        }
                                                        last = node;
                                                }
                                        }
                                }
                        }
                }
        }

        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_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", 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_string(event, SWITCH_STACK_BOTTOM, "type", "speech");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", 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_string(event, SWITCH_STACK_BOTTOM, "type", "asr");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", 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_string(event, SWITCH_STACK_BOTTOM, "type", "directory");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", 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_string(event, SWITCH_STACK_BOTTOM, "type", "chat");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
                                                                  ptr->interface_name);

                                if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
                                        switch_thread_rwlock_unlock(ptr->rwlock);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", 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_string(event, SWITCH_STACK_BOTTOM, "type", "say");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                                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_string(event, SWITCH_STACK_BOTTOM, "type", "management");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->relative_oid);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                        }
                }
        }

        if (old_module->module_interface->limit_interface) {
                const switch_limit_interface_t *ptr;

                for (ptr = old_module->module_interface->limit_interface; ptr; ptr = ptr->next) {
                        if (ptr->interface_name) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
                                                                  "Deleting Limit interface '%s'\n", ptr->interface_name);
                                switch_core_hash_delete(loadable_modules.limit_hash, ptr->interface_name);
                                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "limit");
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
                                        switch_event_fire(&event);
                                        removed++;
                                }
                        }
                }
        }

        if (!removed) {
                if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "generic");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", old_module->key);
                        switch_event_fire(&event);
                        removed++;
                }
        }
        switch_mutex_unlock(loadable_modules.mutex);

        return SWITCH_STATUS_SUCCESS;

}

void switch_say_file	(	switch_say_file_handle_t *	sh,
		const char *	fmt,
			...
	)

Definition at line 2780 of file switch_loadable_module.c.

References buf, and switch_vsnprintf().

{
        char buf[256] = "";
        int ret;
        va_list ap;

        va_start(ap, fmt);
        
        if ((ret = switch_vsnprintf(buf, sizeof(buf), fmt, ap)) > 0) {
                if (!sh->cnt++) {
                        sh->stream.write_function(&sh->stream, "file_string://%s.%s", buf, sh->ext);
                } else if (strstr(buf, "://")) {
                        sh->stream.write_function(&sh->stream, "!%s", buf);
                } else {
                        sh->stream.write_function(&sh->stream, "!%s.%s", buf, sh->ext);
                }

        }
        
        va_end(ap);
}

switch_status_t switch_say_file_handle_create	(	switch_say_file_handle_t **	sh,
		const char *	ext,
		switch_event_t **	var_event
	)

Definition at line 2757 of file switch_loadable_module.c.

References memset(), switch_assert, SWITCH_STANDARD_STREAM, SWITCH_STATUS_SUCCESS, and zstr.

{
        switch_assert(sh);

        if (zstr(ext)) {
                ext = "wav";
        }

        *sh = malloc(sizeof(**sh));
        memset(*sh, 0, sizeof(**sh));

        SWITCH_STANDARD_STREAM((*sh)->stream);
        
        if (var_event) {
                (*sh)->param_event = *var_event;
                *var_event = NULL;
        }

        (*sh)->ext = strdup(ext);

        return SWITCH_STATUS_SUCCESS;
}

void switch_say_file_handle_destroy

(

switch_say_file_handle_t **

sh

)

Definition at line 2743 of file switch_loadable_module.c.

References switch_assert, switch_event_destroy(), and switch_safe_free.

{
        switch_assert(sh);
        
        switch_safe_free((*sh)->stream.data);
        switch_safe_free((*sh)->ext);

        if ((*sh)->param_event) {
                switch_event_destroy(&(*sh)->param_event);
        }
        free(*sh);
        *sh = NULL;
}

char* switch_say_file_handle_detach_path

(

switch_say_file_handle_t *

sh

)

Definition at line 2732 of file switch_loadable_module.c.

References switch_assert.

{
        char *path;
        
        switch_assert(sh);
        path = (char *) sh->stream.data;
        sh->stream.data = NULL;
        return path;
}

char* switch_say_file_handle_get_path

(

switch_say_file_handle_t *

sh

)

Definition at line 2727 of file switch_loadable_module.c.

{
        return (char *) sh->stream.data;
}

char* switch_say_file_handle_get_variable	(	switch_say_file_handle_t *	sh,
		const char *	var
	)

Definition at line 2715 of file switch_loadable_module.c.

References switch_event_get_header.

{
        char *ret = NULL;

        if (sh->param_event) {
                ret = switch_event_get_header(sh->param_event, var);
        }

        return ret;
        
}

Variable Documentation

struct { ... } chat_globals

Referenced by chat_queue_message(), chat_thread_start(), switch_loadable_module_init(), and switch_loadable_module_shutdown().

int IDX = 0

static

Definition at line 601 of file switch_loadable_module.c.

Referenced by chat_queue_message().

struct switch_loadable_module_container loadable_modules

static

Definition at line 95 of file switch_loadable_module.c.

Referenced by do_chat_send(), switch_core_get_secondary_recover_callback(), switch_core_register_secondary_recover_callback(), switch_core_unregister_secondary_recover_callback(), switch_loadable_module_enumerate_available(), switch_loadable_module_enumerate_loaded(), switch_loadable_module_exists(), switch_loadable_module_get_codec_interface(), switch_loadable_module_get_codecs(), switch_loadable_module_get_codecs_sorted(), switch_loadable_module_get_endpoint_interface(), switch_loadable_module_get_file_interface(), switch_loadable_module_get_management_interface(), switch_loadable_module_get_say_interface(), switch_loadable_module_init(), switch_loadable_module_load_module_ex(), switch_loadable_module_process(), switch_loadable_module_runtime(), switch_loadable_module_shutdown(), switch_loadable_module_unload_module(), and switch_loadable_module_unprocess().

switch_queue_t* msg_queue[CHAT_MAX_MSG_QUEUE]

Definition at line 593 of file switch_loadable_module.c.

int msg_queue_len

Definition at line 595 of file switch_loadable_module.c.

switch_thread_t* msg_queue_thread[CHAT_MAX_MSG_QUEUE]

Definition at line 594 of file switch_loadable_module.c.

switch_mutex_t* mutex

Definition at line 596 of file switch_loadable_module.c.

Referenced by careful_set(), switch_buffer_add_mutex(), switch_core_codec_destroy(), switch_core_session_unset_read_codec(), switch_core_session_unset_write_codec(), switch_ivr_enterprise_originate(), and switch_ivr_preprocess_session().

switch_memory_pool_t* pool

Definition at line 597 of file switch_loadable_module.c.

Referenced by do_shutdown(), switch_loadable_module_build_dynamic(), switch_loadable_module_create_module_interface(), switch_loadable_module_exec(), and switch_loadable_module_load_file().

int running

Definition at line 598 of file switch_loadable_module.c.