Loadable Module Functions

Collaboration diagram for Loadable Module Functions:

Data Structures
struct	switch_loadable_module_interface
	The abstraction of a loadable module. More...

Macros
#define	SWITCH_ADD_API(api_int, int_name, descript, funcptr, syntax_string)
#define	SWITCH_ADD_JSON_API(json_api_int, int_name, descript, funcptr, syntax_string)
#define	SWITCH_ADD_CHAT(chat_int, int_name, funcptr)
#define	SWITCH_ADD_APP(app_int, int_name, short_descript, long_descript, funcptr, syntax_string, app_flags)
#define	SWITCH_ADD_CHAT_APP(app_int, int_name, short_descript, long_descript, funcptr, syntax_string, app_flags)
#define	SWITCH_ADD_DIALPLAN(dp_int, int_name, funcptr)
#define	SWITCH_ADD_LIMIT(limit_int, int_name, incrptr, releaseptr, usageptr, resetptr, statusptr, interval_resetptr)
#define	SWITCH_ADD_CODEC(codec_int, int_name)

Functions
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_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...
char *	switch_parse_codec_buf (char *buf, uint32_t *interval, uint32_t *rate, uint32_t *bit, uint32_t *channels, char **modname)
switch_dialplan_interface_t *	switch_loadable_module_get_dialplan_interface (const char *name)
	Retrieve the dialplan interface by it's registered name. 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_timer_interface_t *	switch_loadable_module_get_timer_interface (const char *name)
	Retrieve the timer interface by it's registered name. More...
switch_application_interface_t *	switch_loadable_module_get_application_interface (const char *name)
	Retrieve the application interface by it's registered name. More...
switch_chat_application_interface_t *	switch_loadable_module_get_chat_application_interface (const char *name)
	Retrieve the chat application interface by it's registered name. More...
switch_status_t	switch_core_execute_chat_app (switch_event_t *message, const char *app, const char *data)
switch_api_interface_t *	switch_loadable_module_get_api_interface (const char *name)
	Retrieve the API interface by it's registered name. More...
switch_json_api_interface_t *	switch_loadable_module_get_json_api_interface (const char *name)
	Retrieve the JSON API 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_speech_interface_t *	switch_loadable_module_get_speech_interface (const char *name)
	Retrieve the speech interface by it's registered name. More...
switch_asr_interface_t *	switch_loadable_module_get_asr_interface (const char *name)
	Retrieve the asr interface by it's registered name. More...
switch_directory_interface_t *	switch_loadable_module_get_directory_interface (const char *name)
	Retrieve the directory interface by it's registered name. More...
switch_chat_interface_t *	switch_loadable_module_get_chat_interface (const char *name)
	Retrieve the chat 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...
switch_limit_interface_t *	switch_loadable_module_get_limit_interface (const char *name)
	Retrieve the limit interface by it's registered name. More...
int	switch_loadable_module_get_codecs (const switch_codec_implementation_t **array, int arraylen)
	Retrieve the list of loaded codecs into an array. More...
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_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_MOD_DECLARE (switch_status_t) switch_module_load(switch_loadable_module_interface_t **module_interface
	Load a module. More...
uint32_t	switch_core_codec_next_id (void)
static int	switch_check_interval (uint32_t rate, uint32_t ptime)
static void	switch_core_codec_add_implementation (switch_memory_pool_t *pool, switch_codec_interface_t *codec_interface, const switch_codec_type_t codec_type, switch_payload_t ianacode, const char *iananame, char *fmtp, uint32_t samples_per_second, uint32_t actual_samples_per_second, int bits_per_second, int microseconds_per_packet, uint32_t samples_per_packet, uint32_t decoded_bytes_per_packet, uint32_t encoded_bytes_per_packet, uint8_t number_of_channels, int codec_frames_per_packet, switch_core_codec_init_func_t init, switch_core_codec_encode_func_t encode, switch_core_codec_decode_func_t decode, switch_core_codec_destroy_func_t destroy)

Variables
char *	filename

Detailed Description

Macro Definition Documentation

#define SWITCH_ADD_API	(		api_int,
			int_name,
			descript,
			funcptr,
			syntax_string
	)

Value:

for (;;) { \
        api_int = (switch_api_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_API_INTERFACE); \
        api_int->interface_name = int_name; \
        api_int->desc = descript; \
        api_int->function = funcptr; \
        api_int->syntax = syntax_string; \
        break; \
        }

Definition at line 340 of file switch_loadable_module.h.

#define SWITCH_ADD_APP	(		app_int,
			int_name,
			short_descript,
			long_descript,
			funcptr,
			syntax_string,
			app_flags
	)

Value:

for (;;) { \
        app_int = (switch_application_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_APPLICATION_INTERFACE); \
        app_int->interface_name = int_name; \
        app_int->application_function = funcptr; \
        app_int->short_desc = short_descript; \
        app_int->long_desc = long_descript; \
        app_int->syntax = syntax_string; \
        app_int->flags = app_flags; \
        break; \
        }

Definition at line 368 of file switch_loadable_module.h.

#define SWITCH_ADD_CHAT	(		chat_int,
			int_name,
			funcptr
	)

Value:

for (;;) { \
        chat_int = (switch_chat_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_CHAT_INTERFACE); \
        chat_int->chat_send = funcptr; \
        chat_int->interface_name = int_name; \
        break; \
        }

Definition at line 360 of file switch_loadable_module.h.

#define SWITCH_ADD_CHAT_APP	(		app_int,
			int_name,
			short_descript,
			long_descript,
			funcptr,
			syntax_string,
			app_flags
	)

Value:

for (;;) { \
        app_int = (switch_chat_application_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_CHAT_APPLICATION_INTERFACE); \
        app_int->interface_name = int_name; \
        app_int->chat_application_function = funcptr; \
        app_int->short_desc = short_descript; \
        app_int->long_desc = long_descript; \
        app_int->syntax = syntax_string; \
        app_int->flags = app_flags; \
        break; \
        }

Definition at line 380 of file switch_loadable_module.h.

#define SWITCH_ADD_CODEC	(		codec_int,
			int_name
	)

Value:

for (;;) { \
                codec_int = (switch_codec_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_CODEC_INTERFACE); \
                codec_int->modname = switch_core_strdup(pool, (*module_interface)->module_name);        \
                codec_int->interface_name = switch_core_strdup(pool, int_name); \
                codec_int->codec_id = switch_core_codec_next_id();                              \
                break;                                                                                                                  \
        }

Definition at line 415 of file switch_loadable_module.h.

Referenced by mod_g711_load(), and SWITCH_MODULE_LOAD_FUNCTION().

#define SWITCH_ADD_DIALPLAN	(		dp_int,
			int_name,
			funcptr
	)

Value:

for (;;) { \
        dp_int = (switch_dialplan_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_DIALPLAN_INTERFACE); \
        dp_int->hunt_function = funcptr; \
        dp_int->interface_name = int_name; \
        break; \
        }

Definition at line 392 of file switch_loadable_module.h.

#define SWITCH_ADD_JSON_API	(		json_api_int,
			int_name,
			descript,
			funcptr,
			syntax_string
	)

Value:

for (;;) { \
        json_api_int = (switch_json_api_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_JSON_API_INTERFACE); \
        json_api_int->interface_name = int_name; \
        json_api_int->desc = descript; \
        json_api_int->function = funcptr; \
        json_api_int->syntax = syntax_string; \
        break; \
        }

Definition at line 350 of file switch_loadable_module.h.

#define SWITCH_ADD_LIMIT	(		limit_int,
			int_name,
			incrptr,
			releaseptr,
			usageptr,
			resetptr,
			statusptr,
			interval_resetptr
	)

Value:

for (;;) { \
        limit_int = (switch_limit_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_LIMIT_INTERFACE); \
        limit_int->incr = incrptr; \
        limit_int->release = releaseptr; \
        limit_int->usage = usageptr; \
        limit_int->reset = resetptr; \
        limit_int->interval_reset = interval_resetptr; \
        limit_int->status = statusptr; \
        limit_int->interface_name = int_name; \
        break; \
        }

Definition at line 400 of file switch_loadable_module.h.

Function Documentation

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.

Parameters

cmd	the name of the API command to execute
arg	the optional arguement to the command
session	an optional session
stream	stream for output

Returns

the status returned by the API call

Definition at line 2520 of file switch_loadable_module.c.

References switch_api_interface::function, switch_assert, switch_event_add_header_string(), SWITCH_EVENT_API, switch_event_create, switch_event_fire, switch_loadable_module_get_api_interface(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_strip_whitespace(), and UNPROTECT_INTERFACE.

Referenced by api_hook(), do_api_on(), API::execute(), API::executeString(), record_callback(), switch_channel_expand_variables_check(), switch_console_execute(), switch_event_expand_headers_check(), switch_ivr_record_file(), switch_nat_republish(), and switch_nat_status().

{
        switch_api_interface_t *api;
        switch_status_t status;
        char *arg_used;
        char *cmd_used;

        switch_assert(stream != NULL);
        switch_assert(stream->data != NULL);
        switch_assert(stream->write_function != NULL);

        if (strcasecmp(cmd, "console_complete")) {
                cmd_used = switch_strip_whitespace(cmd);
                arg_used = switch_strip_whitespace(arg);
        } else {
                cmd_used = (char *) cmd;
                arg_used = (char *) arg;
        }
                        

        if (!stream->param_event) {
                switch_event_create(&stream->param_event, SWITCH_EVENT_API);
        }

        if (stream->param_event) {
                if (cmd_used && *cmd_used) {
                        switch_event_add_header_string(stream->param_event, SWITCH_STACK_BOTTOM, "API-Command", cmd_used);
                }
                if (arg_used && *arg_used) {
                        switch_event_add_header_string(stream->param_event, SWITCH_STACK_BOTTOM, "API-Command-Argument", arg_used);
                }
        }


        if (cmd_used && (api = switch_loadable_module_get_api_interface(cmd_used)) != 0) {
                if ((status = api->function(arg_used, session, stream)) != SWITCH_STATUS_SUCCESS) {
                        stream->write_function(stream, "COMMAND RETURNED ERROR!\n");
                }
                UNPROTECT_INTERFACE(api);
        } else {
                status = SWITCH_STATUS_FALSE;
                stream->write_function(stream, "INVALID COMMAND!\n");
        }

        if (stream->param_event) {
                switch_event_fire(&stream->param_event);
        }

        if (cmd_used != cmd) {
                switch_safe_free(cmd_used);
        }
        
        if (arg_used != arg) {
                switch_safe_free(arg_used);
        }

        return status;
}

static int switch_check_interval ( uint32_t  rate, uint32_t  ptime  )

inlinestatic

Definition at line 424 of file switch_loadable_module.h.

References SWITCH_RECOMMENDED_BUFFER_SIZE.

Referenced by switch_core_codec_add_implementation().

{
        uint32_t max_ms = 0, ptime_div = 0;

        switch (rate) {
        case 22050:
        case 11025:
                if (ptime < 120)
                        return 1;
                break;
        case 48000:
                max_ms = 40;
                ptime_div = 2;
                break;
        case 44100:
                max_ms = 40;
                ptime_div = 2;
                break;
        case 32000:
        case 24000:
        case 16000:
                max_ms = 60;
                ptime_div = 2;
                break;
        case 12000:
                max_ms = 100;
                ptime_div = 2;
                break;
        case 8000:
                max_ms = 120;
                ptime_div = 2;
                break;
        }

        if (max_ms && ptime_div && (ptime <= max_ms && (ptime % ptime_div) == 0) && ((rate / 1000) * ptime) < SWITCH_RECOMMENDED_BUFFER_SIZE) {
                return 1;
        }

        return 0;
}

static void switch_core_codec_add_implementation ( switch_memory_pool_t *  pool, switch_codec_interface_t *  codec_interface, const switch_codec_type_t  codec_type, switch_payload_t  ianacode, const char *  iananame, char *  fmtp, uint32_t  samples_per_second, uint32_t  actual_samples_per_second, int  bits_per_second, int  microseconds_per_packet, uint32_t  samples_per_packet, uint32_t  decoded_bytes_per_packet, uint32_t  encoded_bytes_per_packet, uint8_t  number_of_channels, int  codec_frames_per_packet, switch_core_codec_init_func_t  init, switch_core_codec_encode_func_t  encode, switch_core_codec_decode_func_t  decode, switch_core_codec_destroy_func_t  destroy  )

inlinestatic

Parameters

codec_type	enumeration defining the type of the codec
ianacode	the IANA code number
iananame	the IANA code name
fmtp	default fmtp to send (can be overridden by the init function)
samples_per_second	samples transferred per second
actual_samples_per_second	actual samples transferred per second for those who are not moron g722 RFC writers
bits_per_second	bits transferred per second
microseconds_per_packet	number of microseconds that denote one frame
samples_per_packet	number of samples that denote one frame
decoded_bytes_per_packet	number of bytes that denote one frame decompressed
encoded_bytes_per_packet	number of bytes that denote one frame compressed
number_of_channels	number of channels represented
codec_frames_per_packet	number of frames to send in one network packet
init	function to initialize a codec handle using this implementation
encode	function to encode raw data into encoded data
decode	function to decode encoded data into raw data
destroy	deinitalize a codec handle using this implementation

Definition at line 465 of file switch_loadable_module.h.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, switch_codec_implementation::codec_frames_per_packet, switch_codec_implementation::codec_id, switch_codec_interface::codec_id, switch_codec_implementation::codec_type, switch_codec_implementation::decode, switch_codec_implementation::decoded_bytes_per_packet, switch_codec_implementation::destroy, switch_codec_implementation::encode, switch_codec_implementation::encoded_bytes_per_packet, switch_codec_implementation::fmtp, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec_implementation::impl_id, switch_codec_interface::implementations, switch_codec_implementation::init, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::modname, switch_codec_interface::modname, switch_codec_implementation::next, switch_codec_implementation::number_of_channels, switch_codec_implementation::samples_per_packet, switch_codec_implementation::samples_per_second, SWITCH_CHANNEL_LOG, switch_check_interval(), SWITCH_CODEC_TYPE_VIDEO, switch_core_alloc, switch_core_codec_next_id(), switch_core_strdup, SWITCH_LOG_CRIT, switch_log_printf(), and SWITCH_RECOMMENDED_BUFFER_SIZE.

Referenced by mod_g711_load(), and SWITCH_MODULE_LOAD_FUNCTION().

{

        if (decoded_bytes_per_packet > SWITCH_RECOMMENDED_BUFFER_SIZE) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Rejected codec name: %s rate: %u ptime: %d channels %d not enough buffer space %u > %d\n",
                                                  iananame, actual_samples_per_second, microseconds_per_packet / 1000, number_of_channels, decoded_bytes_per_packet, SWITCH_RECOMMENDED_BUFFER_SIZE);
        } else if (codec_type == SWITCH_CODEC_TYPE_VIDEO || switch_check_interval(actual_samples_per_second, microseconds_per_packet / 1000)) {
                switch_codec_implementation_t *impl = (switch_codec_implementation_t *) switch_core_alloc(pool, sizeof(*impl));
                impl->codec_type = codec_type;
                impl->ianacode = ianacode;
                impl->iananame = switch_core_strdup(pool, iananame);
                impl->fmtp = switch_core_strdup(pool, fmtp);
                impl->samples_per_second = samples_per_second;
                impl->actual_samples_per_second = actual_samples_per_second;
                impl->bits_per_second = bits_per_second;
                impl->microseconds_per_packet = microseconds_per_packet;
                impl->samples_per_packet = samples_per_packet;
                impl->decoded_bytes_per_packet = decoded_bytes_per_packet;
                impl->encoded_bytes_per_packet = encoded_bytes_per_packet;
                impl->number_of_channels = number_of_channels;
                impl->codec_frames_per_packet = codec_frames_per_packet;
                impl->init = init;
                impl->encode = encode;
                impl->decode = decode;
                impl->destroy = destroy;
                impl->codec_id = codec_interface->codec_id;
                impl->next = codec_interface->implementations;
                impl->impl_id = switch_core_codec_next_id();
                impl->modname = codec_interface->modname;
                codec_interface->implementations = impl;
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Rejected codec name: %s rate: %u ptime: %d channels: %d\n",
                                                  iananame, actual_samples_per_second, microseconds_per_packet / 1000, number_of_channels);
        }
}

uint32_t switch_core_codec_next_id

(

void

)

Definition at line 41 of file switch_core_codec.c.

References CODEC_ID.

Referenced by switch_core_codec_add_implementation(), and switch_core_codec_add_video_implementation().

{
        return CODEC_ID++;
}

switch_status_t switch_core_execute_chat_app	(	switch_event_t *	message,
		const char *	app,
		const char *	data
	)

Definition at line 820 of file switch_loadable_module.c.

References switch_chat_application_interface::chat_application_function, EF_NO_CHAT_EXEC, SWITCH_CHANNEL_LOG, switch_event_expand_headers, switch_goto_status, switch_loadable_module_get_chat_application_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, and UNPROTECT_INTERFACE.

Referenced by Event::chat_execute().

{
        switch_chat_application_interface_t *cai;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        char *expanded;

        if (!(cai = switch_loadable_module_get_chat_application_interface(app)) || !cai->chat_application_function) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid chat application interface [%s]!\n", app);
                return SWITCH_STATUS_FALSE;
        }

        if (switch_test_flag(message, EF_NO_CHAT_EXEC)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Message is not allowed to execute apps\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (data && !strcmp(data, "__undef")) {
                data = NULL;
        }

        expanded = switch_event_expand_headers(message, data);
        
        status = cai->chat_application_function(message, expanded);

        if (expanded != data) {
                free(expanded);
        }

 end:

        UNPROTECT_INTERFACE(cai);

        return status;

}

switch_status_t switch_json_api_execute	(	cJSON *	json,
		switch_core_session_t *	session,
		cJSON **	retval
	)

Execute a registered JSON API command.

Parameters

json	the name of the JSON API command to execute
arg	the optional arguement to the command
session	an optional session
stream	stream for output

Returns

the status returned by the API call

Definition at line 2579 of file switch_loadable_module.c.

References cJSON_AddItemToObject(), cJSON_CreateNull(), cJSON_CreateString(), cJSON_GetObjectItem(), switch_json_api_interface::function, switch_assert, switch_loadable_module_get_json_api_interface(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and UNPROTECT_INTERFACE.

{
        switch_json_api_interface_t *json_api;
        switch_status_t status;
        cJSON *function, *json_reply = NULL;

        switch_assert(json);

        function = cJSON_GetObjectItem(json, "command");

        if (function && function->valuestring 
                && cJSON_GetObjectItem(json, "data") && (json_api = switch_loadable_module_get_json_api_interface(function->valuestring)) != 0) {
                if ((status = json_api->function(json, session, &json_reply)) != SWITCH_STATUS_SUCCESS) {
                        cJSON_AddItemToObject(json, "status", cJSON_CreateString("error"));
                        cJSON_AddItemToObject(json, "message", cJSON_CreateString("The command returned an error"));
                } else {
                        cJSON_AddItemToObject(json, "status", cJSON_CreateString("success"));
                }
                
                if (!json_reply) {
                        json_reply = cJSON_CreateNull();
                }

                if (retval) {
                        *retval = json_reply;
                } else {
                        cJSON_AddItemToObject(json, "response", json_reply);
                }
                
                UNPROTECT_INTERFACE(json_api);
        } else {
                status = SWITCH_STATUS_FALSE;
                cJSON_AddItemToObject(json, "status", cJSON_CreateString("error"));
                cJSON_AddItemToObject(json, "message", cJSON_CreateString("Invalid request or non-existant command"));
                cJSON_AddItemToObject(json, "response", cJSON_CreateNull());
        }

        return status;
}

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)

Parameters

filename	the name of the modules source file
switch_module_load	the function to call when the module is loaded
switch_module_runtime	a function requested to be started in it's own thread once loaded
switch_module_shutdown	the function to call when the system is shutdown
runtime	start the runtime thread or not

Returns

the resulting status

Note

only use this function if you are making a module that in turn gateways module loading to another technology

Definition at line 1727 of file switch_loadable_module.c.

References switch_loadable_module::filename, switch_loadable_module::module_interface, switch_loadable_module_interface::module_name, switch_loadable_module::perm, switch_loadable_module::pool, pool, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_launch_thread(), switch_core_new_memory_pool, switch_core_strdup, switch_loadable_module_exec(), switch_loadable_module_process(), SWITCH_LOG_CONSOLE, SWITCH_LOG_CRIT, switch_log_printf(), switch_loadable_module::switch_module_load, switch_loadable_module::switch_module_runtime, switch_loadable_module::switch_module_shutdown, SWITCH_STATUS_GENERR, SWITCH_STATUS_NOUNLOAD, SWITCH_STATUS_SUCCESS, and switch_loadable_module::thread.

{
        switch_loadable_module_t *module = NULL;
        switch_module_load_t load_func_ptr = NULL;
        int loading = 1;
        const char *err = NULL;
        switch_loadable_module_interface_t *module_interface = NULL;
        switch_memory_pool_t *pool;


        if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
                abort();
        }

        if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Couldn't allocate memory\n");
                abort();
        }



        while (loading) {
                switch_status_t status;
                load_func_ptr = (switch_module_load_t) switch_module_load;

                if (load_func_ptr == NULL) {
                        err = "Cannot Load";
                        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 = 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) {
                switch_core_destroy_memory_pool(&pool);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error Loading module %s\n**%s**\n", filename, err);
                return SWITCH_STATUS_GENERR;
        }

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

        if (switch_module_shutdown) {
                module->switch_module_shutdown = switch_module_shutdown;
        }
        if (switch_module_runtime) {
                module->switch_module_runtime = switch_module_runtime;
        }
        if (runtime && module->switch_module_runtime) {
                module->thread = switch_core_launch_thread(switch_loadable_module_exec, module, module->pool);
        }
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Successfully Loaded [%s]\n", module_interface->module_name);
        return switch_loadable_module_process((char *) module->filename, module);
}

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.

Parameters

the	directory to look for modules in
memory	pool
callback	function to call for each module found
user	data argument to pass to the callback function

Returns

the resulting status

Definition at line 1671 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::pool, switch_dir_close(), switch_dir_next_file(), switch_dir_open(), switch_mprintf(), switch_safe_free, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

Referenced by switch_console_list_available_modules().

{
        switch_dir_t *dir = NULL;
        switch_status_t status;
        char buffer[256];
        const char *fname;
        const char *fname_ext;
        char *fname_base;

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

        if ((status = switch_dir_open(&dir, dir_path, loadable_modules.pool)) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        while((fname = switch_dir_next_file(dir, buffer, sizeof(buffer)))) {
                if ((fname_ext = strrchr(fname, '.'))) {
                        if (!strcmp(fname_ext, ext)) {
                                if (!(fname_base = switch_mprintf("%.*s", (int)(fname_ext-fname), fname))) {
                                        status = SWITCH_STATUS_GENERR;
                                        goto end;
                                }
                                callback(user_data, fname_base);
                                switch_safe_free(fname_base)
                        }
                }
        }


  end:
        switch_dir_close(dir);
        return status;
}

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.

Parameters

callback	function to call for each module found
user	data argument to pass to the callback function

Returns

the resulting status

Definition at line 1709 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_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_console_list_loaded_modules().

{
        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;

                callback(user_data, module->module_interface->module_name);
        }
        switch_mutex_unlock(loadable_modules.mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_loadable_module_exists

(

const char *

mod

)

Check if a module is loaded.

Parameters

mod	the module name

Returns

the status

Definition at line 1610 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::module_hash, switch_loadable_module_container::mutex, switch_core_hash_find(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

{
        switch_status_t status;

        if (zstr(mod)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(loadable_modules.mutex);
        if (switch_core_hash_find(loadable_modules.module_hash, mod)) {
                status = SWITCH_STATUS_SUCCESS;
        } else {
                status = SWITCH_STATUS_FALSE;
        }
        switch_mutex_unlock(loadable_modules.mutex);

        return status;
}

switch_api_interface_t* switch_loadable_module_get_api_interface

(

const char *

name

)

Retrieve the API interface by it's registered name.

Parameters

name	the name of the API

Returns

the desired API interface

Referenced by switch_api_execute().

switch_application_interface_t* switch_loadable_module_get_application_interface

(

const char *

name

)

Retrieve the application interface by it's registered name.

Parameters

name	the name of the application

Returns

the desired application interface

Referenced by collect_thread_run(), switch_core_session_execute_application_get_flags(), switch_core_session_get_app_flags(), switch_ivr_menu_execute(), and switch_ivr_phrase_macro_event().

switch_asr_interface_t* switch_loadable_module_get_asr_interface

(

const char *

name

)

Retrieve the asr interface by it's registered name.

Parameters

name	the name of the asr interface

Returns

the desired asr interface

Referenced by switch_core_asr_open().

switch_chat_application_interface_t* switch_loadable_module_get_chat_application_interface

(

const char *

name

)

Retrieve the chat application interface by it's registered name.

Parameters

name	the name of the chat application

Returns

the desired chat application interface

Referenced by switch_core_execute_chat_app().

switch_chat_interface_t* switch_loadable_module_get_chat_interface

(

const char *

name

)

Retrieve the chat interface by it's registered name.

Parameters

name	the name of the chat interface

Returns

the desired chat interface

Referenced by do_chat_send().

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.

Parameters

name	the name of the codec

Returns

the desired codec interface

Definition at line 2148 of file switch_loadable_module.c.

References switch_loadable_module_container::codec_hash, switch_codec_node_s::interface_name, loadable_modules, switch_loadable_module_container::mutex, switch_codec_node_s::next, PROTECT_INTERFACE, switch_codec_node_s::ptr, switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_codec_init_with_bitrate(), switch_core_codec_parse_fmtp(), and switch_loadable_module_get_codecs_sorted().

{
        switch_codec_interface_t *codec = NULL;
        switch_codec_node_t *node, *head;

        switch_mutex_lock(loadable_modules.mutex);
        
        if ((head = switch_core_hash_find(loadable_modules.codec_hash, name))) {
                if (modname) {
                        for (node = head; node; node = node->next) {
                                if (!strcasecmp(node->interface_name, modname)) {
                                        codec = (switch_codec_interface_t *) node->ptr;
                                        break;
                                }
                        }
                } else {
                        codec = (switch_codec_interface_t *) head->ptr;
                }
        }

        switch_mutex_unlock(loadable_modules.mutex);

        if (codec) {
                PROTECT_INTERFACE(codec);
        }

        return codec;
}

int switch_loadable_module_get_codecs	(	const switch_codec_implementation_t **	array,
		int	arraylen
	)

Retrieve the list of loaded codecs into an array.

Parameters

array	the array to populate
arraylen	the max size in elements of the array

Returns

the number of elements added to the array

Definition at line 2296 of file switch_loadable_module.c.

References switch_loadable_module_container::codec_hash, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec_interface::implementations, loadable_modules, switch_codec_implementation::microseconds_per_packet, switch_loadable_module_container::mutex, switch_codec_node_s::next, switch_codec_implementation::next, switch_codec_node_s::ptr, switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_default_ptime(), switch_loadable_module_sort_codecs(), switch_mutex_lock(), switch_mutex_unlock(), and switch_safe_free.

Referenced by switch_core_media_set_r_sdp_codec_string().

{
        switch_hash_index_t *hi;
        void *val;
        switch_codec_interface_t *codec_interface;
        int i = 0;
        const switch_codec_implementation_t *imp;
        switch_codec_node_t *node, *head;

        switch_mutex_lock(loadable_modules.mutex);
        for (hi = switch_core_hash_first(loadable_modules.codec_hash); hi; hi = switch_core_hash_next(&hi)) {
                switch_core_hash_this(hi, NULL, NULL, &val);
                head = (switch_codec_node_t *) val;
                
                for (node = head; node; node = node->next) {
                        codec_interface = (switch_codec_interface_t *) node->ptr;

                        /* Look for the default ptime of the codec because it's the safest choice */
                        for (imp = codec_interface->implementations; imp; imp = imp->next) {
                                uint32_t default_ptime = switch_default_ptime(imp->iananame, imp->ianacode);
                                
                                if (imp->microseconds_per_packet / 1000 == (int)default_ptime) {
                                        array[i++] = imp;
                                        goto found;
                                }
                        }
                        /* oh well we will use what we have */
                        array[i++] = codec_interface->implementations;
                }

        found:
                        
                if (i > arraylen) {
                        break;
                }
                
        }
        switch_safe_free(hi);

        switch_mutex_unlock(loadable_modules.mutex);

        switch_loadable_module_sort_codecs(array, i);

        return i;

}

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.

Parameters

array	the array to populate
arraylen	the max size in elements of the array
prefs	the array of preferred codec names
preflen	the size in elements of the prefs

Returns

the number of elements added to the array

Note

this function only considers codecs that are listed in the "prefs" array and ignores the rest.

Definition at line 2386 of file switch_loadable_module.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, buf, switch_codec_implementation::codec_type, switch_codec_implementation::ianacode, switch_codec_implementation::iananame, switch_codec_interface::implementations, loadable_modules, switch_codec_implementation::microseconds_per_packet, switch_loadable_module_container::mutex, switch_codec_implementation::next, switch_codec_implementation::number_of_channels, switch_codec_implementation::samples_per_second, SWITCH_CODEC_TYPE_VIDEO, switch_copy_string(), switch_default_ptime(), switch_default_rate(), switch_loadable_module_get_codec_interface(), switch_loadable_module_sort_codecs(), switch_mutex_lock(), switch_mutex_unlock(), switch_parse_codec_buf(), and UNPROTECT_INTERFACE.

Referenced by switch_core_media_negotiate_sdp(), switch_core_media_prepare_codecs(), switch_core_media_recover_session(), and switch_core_media_set_r_sdp_codec_string().

{
        int x, i = 0, j = 0;
        switch_codec_interface_t *codec_interface;
        const switch_codec_implementation_t *imp;

        switch_mutex_lock(loadable_modules.mutex);

        for (x = 0; x < preflen; x++) {
                char *name, buf[256], jbuf[256], *modname = NULL;
                uint32_t interval = 0, rate = 0, bit = 0, channels = 1;

                switch_copy_string(buf, prefs[x], sizeof(buf));
                name = switch_parse_codec_buf(buf, &interval, &rate, &bit, &channels, &modname);

                for(j = 0; j < x; j++) {
                        char *jname, *jmodname = NULL;
                        uint32_t jinterval = 0, jrate = 0, jbit = 0, jchannels = 1;
                        uint32_t ointerval = interval, orate = rate, ochannels = channels;

                        if (ointerval == 0) {
                                ointerval = switch_default_ptime(name, 0);
                        }
                        
                        if (orate == 0) {
                                orate = switch_default_rate(name, 0);
                        }

                        if (ochannels == 0) {
                                ochannels = 1;
                        }
                        
                        switch_copy_string(jbuf, prefs[j], sizeof(jbuf));
                        jname = switch_parse_codec_buf(jbuf, &jinterval, &jrate, &jbit, &jchannels, &jmodname);

                        if (jinterval == 0) {
                                jinterval = switch_default_ptime(jname, 0);
                        }

                        if (jrate == 0) {
                                jrate = switch_default_rate(jname, 0);
                        }

                        if (jchannels == 0) {
                                jchannels = 1;
                        }

                        if (!strcasecmp(name, jname) && ointerval == jinterval && orate == jrate && ochannels == jchannels) {
                                goto next_x;
                        }
                }

                if ((codec_interface = switch_loadable_module_get_codec_interface(name, modname)) != 0) {
                        /* If no specific codec interval is requested opt for the default above all else because lots of stuff assumes it */
                        for (imp = codec_interface->implementations; imp; imp = imp->next) {
                                uint32_t default_ptime = switch_default_ptime(imp->iananame, imp->ianacode);
                                uint32_t default_rate = switch_default_rate(imp->iananame, imp->ianacode);
                                
                                if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
                                        uint32_t crate = !strcasecmp(imp->iananame, "g722") ? imp->samples_per_second : imp->actual_samples_per_second;

                                        if ((!interval && (uint32_t) (imp->microseconds_per_packet / 1000) != default_ptime) ||
                                                (interval && (uint32_t) (imp->microseconds_per_packet / 1000) != interval)) {
                                                continue;
                                        }
                                        
                                        if (((!rate && crate != default_rate) || (rate && (uint32_t) imp->actual_samples_per_second != rate))) {
                                                continue;
                                        }

                                        if (bit && (uint32_t) imp->bits_per_second != bit) {
                                                continue;
                                        }

                                        if (channels && imp->number_of_channels != channels) {
                                                continue;
                                        }
                                }


                                array[i++] = imp;
                                goto found;

                        }

                        /* Either looking for a specific interval or there was no interval specified and there wasn't one at the default ptime available */
                        for (imp = codec_interface->implementations; imp; imp = imp->next) {
                                if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
                                        uint32_t crate = !strcasecmp(imp->iananame, "g722") ? imp->samples_per_second : imp->actual_samples_per_second;

                                        if (interval && (uint32_t) (imp->microseconds_per_packet / 1000) != interval) {
                                                continue;
                                        }

                                        if (rate && (uint32_t) crate != rate) {
                                                continue;
                                        }

                                        if (bit && (uint32_t) imp->bits_per_second != bit) {
                                                continue;
                                        }

                                        if (channels && imp->number_of_channels != channels) {
                                                continue;
                                        }                                       
                                }

                                array[i++] = imp;
                                goto found;

                        }

                  found:

                        UNPROTECT_INTERFACE(codec_interface);

                        if (i > arraylen) {
                                break;
                        }

                }

        next_x:

                continue;
        }

        switch_mutex_unlock(loadable_modules.mutex);

        switch_loadable_module_sort_codecs(array, i);

        return i;
}

switch_dialplan_interface_t* switch_loadable_module_get_dialplan_interface

(

const char *

name

)

Retrieve the dialplan interface by it's registered name.

Parameters

name	the name of the dialplan

Returns

the desired dialplan interface

Referenced by switch_core_session_execute_exten(), and switch_core_standard_on_routing().

switch_directory_interface_t* switch_loadable_module_get_directory_interface

(

const char *

name

)

Retrieve the directory interface by it's registered name.

Parameters

name	the name of the directory interface

Returns

the desired directory interface

Referenced by switch_core_directory_open().

switch_endpoint_interface_t* switch_loadable_module_get_endpoint_interface

(

const char *

name

)

Retrieve the endpoint interface by it's registered name.

Parameters

name	the name of the endpoint

Returns

the desired endpoint interface

Definition at line 2106 of file switch_loadable_module.c.

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

Referenced by recover_callback(), switch_core_session_outgoing_channel(), and switch_core_session_request_by_name().

{
        switch_endpoint_interface_t *ptr;

        switch_mutex_lock(loadable_modules.mutex);
        ptr = switch_core_hash_find(loadable_modules.endpoint_hash, name);
        if (ptr) {
                PROTECT_INTERFACE(ptr);
        }
        switch_mutex_unlock(loadable_modules.mutex);


        return ptr;
}

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.

Parameters

name	the name of the file format

Returns

the desired file format interface

Definition at line 2121 of file switch_loadable_module.c.

References switch_loadable_module_container::file_hash, switch_file_node_s::interface_name, loadable_modules, switch_loadable_module_container::mutex, switch_file_node_s::next, PROTECT_INTERFACE, switch_file_node_s::ptr, switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_perform_file_open().

{
        switch_file_interface_t *i = NULL;
        switch_file_node_t *node, *head;

        switch_mutex_lock(loadable_modules.mutex);

        if ((head = switch_core_hash_find(loadable_modules.file_hash, name))) {
                if (modname) {
                        for (node = head; node; node = node->next) {
                                if (!strcasecmp(node->interface_name, modname)) {
                                        i = (switch_file_interface_t *) node->ptr;
                                        break;
                                }
                        }
                } else {
                        i = (switch_file_interface_t *) head->ptr;
                }
        }

        switch_mutex_unlock(loadable_modules.mutex);
        
        if (i) PROTECT_INTERFACE(i);

        return i;
}

switch_json_api_interface_t* switch_loadable_module_get_json_api_interface

(

const char *

name

)

Retrieve the JSON API interface by it's registered name.

Parameters

name	the name of the API

Returns

the desired API interface

Referenced by switch_json_api_execute().

switch_limit_interface_t* switch_loadable_module_get_limit_interface

(

const char *

name

)

Retrieve the limit interface by it's registered name.

Parameters

name	the name of the limit interface

Returns

the desired limit interface

Referenced by get_backend().

switch_management_interface_t* switch_loadable_module_get_management_interface

(

const char *

relative_oid

)

Retrieve the management interface by it's registered name.

Parameters

relative_oid

the relative oid of the management interface

Returns

the desired management interface

Definition at line 2204 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::management_hash, switch_loadable_module_container::mutex, and switch_core_hash_find_locked().

Referenced by switch_core_management_exec().

{
        return switch_core_hash_find_locked(loadable_modules.management_hash, relative_oid, loadable_modules.mutex);
}

switch_say_interface_t* switch_loadable_module_get_say_interface

(

const char *

name

)

Retrieve the say interface by it's registered name.

Parameters

name	the name of the say interface

Returns

the desired say interface

Definition at line 2199 of file switch_loadable_module.c.

References loadable_modules, switch_loadable_module_container::mutex, switch_loadable_module_container::say_hash, and switch_core_hash_find_locked().

Referenced by switch_ivr_phrase_macro_event(), switch_ivr_say(), and switch_ivr_say_string().

{
        return switch_core_hash_find_locked(loadable_modules.say_hash, name, loadable_modules.mutex);
}

switch_speech_interface_t* switch_loadable_module_get_speech_interface

(

const char *

name

)

Retrieve the speech interface by it's registered name.

Parameters

name	the name of the speech interface

Returns

the desired speech interface

Referenced by switch_core_speech_open().

switch_timer_interface_t* switch_loadable_module_get_timer_interface

(

const char *

name

)

Retrieve the timer interface by it's registered name.

Parameters

name	the name of the timer

Returns

the desired timer interface

Referenced by switch_core_timer_init().

switch_status_t switch_loadable_module_init

(

switch_bool_t

autoload

)

Initilize the module backend and load all the modules.

Returns

SWITCH_STATUS_SUCCESS when complete

Definition at line 1821 of file switch_loadable_module.c.

References switch_loadable_module_container::api_hash, switch_loadable_module_container::application_hash, switch_loadable_module_container::asr_hash, switch_loadable_module_container::chat_application_hash, chat_globals, switch_loadable_module_container::chat_hash, chat_thread_start(), switch_loadable_module_container::codec_hash, switch_loadable_module_container::dialplan_hash, switch_loadable_module_container::directory_hash, switch_loadable_module_container::endpoint_hash, switch_loadable_module_container::file_hash, switch_loadable_module_container::json_api_hash, switch_loadable_module_container::limit_hash, loadable_modules, switch_loadable_module_container::management_hash, memset(), switch_directories::mod_dir, switch_loadable_module_container::module_hash, switch_loadable_module_container::mutex, switch_xml::next, switch_loadable_module_container::pool, switch_loadable_module_container::say_hash, switch_loadable_module_container::secondary_recover_hash, switch_loadable_module_container::speech_hash, SWITCH_CHANNEL_LOG, switch_core_hash_init, switch_core_hash_init_nocase, switch_core_new_memory_pool, SWITCH_FALSE, SWITCH_GLOBAL_dirs, switch_loadable_module_load_module(), switch_loadable_module_load_module_ex(), switch_loadable_module_runtime(), SWITCH_LOG_CONSOLE, SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_true(), switch_xml_attr_soft(), switch_xml_child(), switch_xml_free(), switch_xml_open_cfg(), switch_loadable_module_container::timer_hash, and zstr.

Referenced by fs_loadable_module_init(), main(), and switch_core_init_and_modload().

{

        apr_finfo_t finfo = { 0 };
        apr_dir_t *module_dir_handle = NULL;
        apr_int32_t finfo_flags = APR_FINFO_DIRENT | APR_FINFO_TYPE | APR_FINFO_NAME;
        char *cf = "modules.conf";
        char *pcf = "post_load_modules.conf";
        switch_xml_t cfg, xml;
        unsigned char all = 0;
        unsigned int count = 0;
        const char *err;


#ifdef WIN32
        const char *ext = ".dll";
        const char *EXT = ".DLL";
#elif defined (MACOSX) || defined (DARWIN)
        const char *ext = ".dylib";
        const char *EXT = ".DYLIB";
#else
        const char *ext = ".so";
        const char *EXT = ".SO";
#endif

        memset(&loadable_modules, 0, sizeof(loadable_modules));
        switch_core_new_memory_pool(&loadable_modules.pool);


#ifdef WIN32
        switch_loadable_module_path_init();
#endif

        switch_core_hash_init(&loadable_modules.module_hash);
        switch_core_hash_init_nocase(&loadable_modules.endpoint_hash);
        switch_core_hash_init_nocase(&loadable_modules.codec_hash);
        switch_core_hash_init_nocase(&loadable_modules.timer_hash);
        switch_core_hash_init_nocase(&loadable_modules.application_hash);
        switch_core_hash_init_nocase(&loadable_modules.chat_application_hash);
        switch_core_hash_init_nocase(&loadable_modules.api_hash);
        switch_core_hash_init_nocase(&loadable_modules.json_api_hash);
        switch_core_hash_init(&loadable_modules.file_hash);
        switch_core_hash_init_nocase(&loadable_modules.speech_hash);
        switch_core_hash_init_nocase(&loadable_modules.asr_hash);
        switch_core_hash_init_nocase(&loadable_modules.directory_hash);
        switch_core_hash_init_nocase(&loadable_modules.chat_hash);
        switch_core_hash_init_nocase(&loadable_modules.say_hash);
        switch_core_hash_init_nocase(&loadable_modules.management_hash);
        switch_core_hash_init_nocase(&loadable_modules.limit_hash);
        switch_core_hash_init_nocase(&loadable_modules.dialplan_hash);
        switch_core_hash_init(&loadable_modules.secondary_recover_hash);
        switch_mutex_init(&loadable_modules.mutex, SWITCH_MUTEX_NESTED, loadable_modules.pool);

        if (!autoload) return SWITCH_STATUS_SUCCESS;

        switch_loadable_module_load_module("", "CORE_SOFTTIMER_MODULE", SWITCH_FALSE, &err);
        switch_loadable_module_load_module("", "CORE_PCM_MODULE", SWITCH_FALSE, &err);
        switch_loadable_module_load_module("", "CORE_SPEEX_MODULE", SWITCH_FALSE, &err);
#ifdef SWITCH_HAVE_YUV
#ifdef SWITCH_HAVE_VPX
        switch_loadable_module_load_module("", "CORE_VPX_MODULE", SWITCH_FALSE, &err);
#endif
#endif

        if ((xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
                switch_xml_t mods, ld;
                if ((mods = switch_xml_child(cfg, "modules"))) {
                        for (ld = switch_xml_child(mods, "load"); ld; ld = ld->next) {
                                switch_bool_t global = SWITCH_FALSE;
                                const char *val = switch_xml_attr_soft(ld, "module");
                                const char *path = switch_xml_attr_soft(ld, "path");
                                const char *critical = switch_xml_attr_soft(ld, "critical");
                                const char *sglobal = switch_xml_attr_soft(ld, "global");
                                if (zstr(val) || (strchr(val, '.') && !strstr(val, ext) && !strstr(val, EXT))) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Invalid extension for %s\n", val);
                                        continue;
                                }
                                global = switch_true(sglobal);
                                
                                if (path && zstr(path)) {
                                        path = SWITCH_GLOBAL_dirs.mod_dir;
                                }
                                if (switch_loadable_module_load_module_ex((char *) path, (char *) val, SWITCH_FALSE, global, &err) == SWITCH_STATUS_GENERR) {
                                        if (critical && switch_true(critical)) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load critical module '%s', abort()\n", val);
                                                abort();
                                        }
                                }
                                count++;
                        }
                }
                switch_xml_free(xml);

        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "open of %s failed\n", cf);
        }

        if ((xml = switch_xml_open_cfg(pcf, &cfg, NULL))) {
                switch_xml_t mods, ld;

                if ((mods = switch_xml_child(cfg, "modules"))) {
                        for (ld = switch_xml_child(mods, "load"); ld; ld = ld->next) {
                                switch_bool_t global = SWITCH_FALSE;
                                const char *val = switch_xml_attr_soft(ld, "module");
                                const char *path = switch_xml_attr_soft(ld, "path");
                                const char *sglobal = switch_xml_attr_soft(ld, "global");
                                if (zstr(val) || (strchr(val, '.') && !strstr(val, ext) && !strstr(val, EXT))) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Invalid extension for %s\n", val);
                                        continue;
                                }
                                global = switch_true(sglobal);

                                if (path && zstr(path)) {
                                        path = SWITCH_GLOBAL_dirs.mod_dir;
                                }
                                switch_loadable_module_load_module_ex((char *) path, (char *) val, SWITCH_FALSE, global, &err);
                                count++;
                        }
                }
                switch_xml_free(xml);

        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "open of %s failed\n", pcf);
        }

        if (!count) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "No modules loaded, assuming 'load all'\n");
                all = 1;
        }

        if (all) {
                if (apr_dir_open(&module_dir_handle, SWITCH_GLOBAL_dirs.mod_dir, loadable_modules.pool) != APR_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can't open directory: %s\n", SWITCH_GLOBAL_dirs.mod_dir);
                        return SWITCH_STATUS_GENERR;
                }

                while (apr_dir_read(&finfo, finfo_flags, module_dir_handle) == APR_SUCCESS) {
                        const char *fname = finfo.fname;

                        if (finfo.filetype != APR_REG) {
                                continue;
                        }

                        if (!fname) {
                                fname = finfo.name;
                        }

                        if (!fname) {
                                continue;
                        }

                        if (zstr(fname) || (!strstr(fname, ext) && !strstr(fname, EXT))) {
                                continue;
                        }

                        switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) fname, SWITCH_FALSE, &err);
                }
                apr_dir_close(module_dir_handle);
        }

        switch_loadable_module_runtime();

        memset(&chat_globals, 0, sizeof(chat_globals));
        chat_globals.running = 1;
        chat_globals.pool = loadable_modules.pool;
        switch_mutex_init(&chat_globals.mutex, SWITCH_MUTEX_NESTED, chat_globals.pool);

        chat_thread_start(1);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_loadable_module_load_module	(	char *	dir,
		char *	fname,
		switch_bool_t	runtime,
		const char **	err
	)

Load a module.

Parameters

dir	the directory where the module resides
fname	the file name of the module
runtime	option to start the runtime thread if it exists
err	pointer to error message

Returns

the status

Definition at line 1545 of file switch_loadable_module.c.

References SWITCH_FALSE, and switch_loadable_module_load_module_ex().

Referenced by main(), and switch_loadable_module_init().

{
        return switch_loadable_module_load_module_ex(dir, fname, runtime, SWITCH_FALSE, err);
}

void switch_loadable_module_shutdown

(

void

)

Shutdown the module backend and call the shutdown routine in all loaded modules.

Definition at line 2044 of file switch_loadable_module.c.

References switch_loadable_module_container::api_hash, switch_loadable_module_container::application_hash, switch_loadable_module_container::asr_hash, switch_loadable_module_container::chat_application_hash, chat_globals, switch_loadable_module_container::chat_hash, switch_loadable_module_container::codec_hash, switch_loadable_module_container::dialplan_hash, switch_loadable_module_container::directory_hash, do_shutdown(), switch_loadable_module_container::endpoint_hash, switch_loadable_module_container::file_hash, switch_loadable_module_container::json_api_hash, switch_loadable_module_container::limit_hash, loadable_modules, switch_loadable_module_container::management_hash, switch_loadable_module_container::module_hash, switch_loadable_module::perm, switch_loadable_module_container::pool, switch_loadable_module_container::say_hash, switch_loadable_module_container::speech_hash, switch_core_destroy_memory_pool, switch_core_hash_destroy(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), SWITCH_FALSE, switch_queue_push(), switch_thread_join(), SWITCH_TRUE, switch_yield, and switch_loadable_module_container::timer_hash.

Referenced by fs_loadable_module_shutdown(), and switch_core_destroy().

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

        if (!loadable_modules.module_hash) {
                return;
        }

        chat_globals.running = 0;

        for (i = 0; i < chat_globals.msg_queue_len; i++) {      
                switch_queue_push(chat_globals.msg_queue[i], NULL);
        }

        for (i = 0; i < chat_globals.msg_queue_len; i++) {
                switch_status_t st;
                switch_thread_join(&st, chat_globals.msg_queue_thread[i]);
        }


        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->perm) {
                        do_shutdown(module, SWITCH_TRUE, SWITCH_FALSE, SWITCH_FALSE, NULL);
                }
        }

        switch_yield(1000000);

        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->perm) {
                        do_shutdown(module, SWITCH_FALSE, SWITCH_TRUE, SWITCH_FALSE, NULL);
                }
        }

        switch_core_hash_destroy(&loadable_modules.module_hash);
        switch_core_hash_destroy(&loadable_modules.endpoint_hash);
        switch_core_hash_destroy(&loadable_modules.codec_hash);
        switch_core_hash_destroy(&loadable_modules.timer_hash);
        switch_core_hash_destroy(&loadable_modules.application_hash);
        switch_core_hash_destroy(&loadable_modules.chat_application_hash);
        switch_core_hash_destroy(&loadable_modules.api_hash);
        switch_core_hash_destroy(&loadable_modules.json_api_hash);
        switch_core_hash_destroy(&loadable_modules.file_hash);
        switch_core_hash_destroy(&loadable_modules.speech_hash);
        switch_core_hash_destroy(&loadable_modules.asr_hash);
        switch_core_hash_destroy(&loadable_modules.directory_hash);
        switch_core_hash_destroy(&loadable_modules.chat_hash);
        switch_core_hash_destroy(&loadable_modules.say_hash);
        switch_core_hash_destroy(&loadable_modules.management_hash);
        switch_core_hash_destroy(&loadable_modules.limit_hash);
        switch_core_hash_destroy(&loadable_modules.dialplan_hash);

        switch_core_destroy_memory_pool(&loadable_modules.pool);
}

switch_status_t switch_loadable_module_unload_module	(	char *	dir,
		char *	fname,
		switch_bool_t	force,
		const char **	err
	)

Unoad a module.

Parameters

dir	the directory where the module resides
fname	the file name of the module
err	pointer to error message

Returns

the status

Definition at line 1629 of file switch_loadable_module.c.

References do_shutdown(), loadable_modules, switch_loadable_module_container::module_hash, switch_loadable_module_container::mutex, switch_loadable_module::perm, SWITCH_CHANNEL_LOG, switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_insert_locked(), SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_NOUNLOAD, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

{
        switch_loadable_module_t *module = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (force) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Spin the barrel and pull the trigger.......!\n");
        }

        switch_mutex_lock(loadable_modules.mutex);
        if ((module = switch_core_hash_find(loadable_modules.module_hash, fname))) {
                if (module->perm) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Module is not unloadable.\n");
                        *err = "Module is not unloadable";
                        status = SWITCH_STATUS_NOUNLOAD;
                        goto unlock;
                } else {
                        /* Prevent anything from using the module while it's shutting down */
                        switch_core_hash_delete(loadable_modules.module_hash, fname);
                        switch_mutex_unlock(loadable_modules.mutex);
                        if ((status = do_shutdown(module, SWITCH_TRUE, SWITCH_TRUE, !force, err)) != SWITCH_STATUS_SUCCESS) {
                                /* Something went wrong in the module's shutdown function, add it again */
                                switch_core_hash_insert_locked(loadable_modules.module_hash, fname, module, loadable_modules.mutex);
                        }
                        goto end;
                }
        } else {
                *err = "No such module!";
                status = SWITCH_STATUS_FALSE;
        }
unlock:
        switch_mutex_unlock(loadable_modules.mutex);
  end:
        if (force) {
                switch_yield(1000000);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "PHEW!\n");
        }

        return status;

}

SWITCH_MOD_DECLARE

(

switch_status_t

)

Load a module.

Shutdown a module.

Parameters

module_interface	a pointer to a pointer to aim at your module's local interface
filename	the path to the module's dll or so file

Returns

SWITCH_STATUS_SUCCESS on a successful load

SWITCH_STATUS_SUCCESS on a successful shutdown

char* switch_parse_codec_buf	(	char *	buf,
		uint32_t *	interval,
		uint32_t *	rate,
		uint32_t *	bit,
		uint32_t *	channels,
		char **	modname
	)

Definition at line 2343 of file switch_loadable_module.c.

References buf, cur, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, and switch_log_printf().

Referenced by switch_loadable_module_get_codecs_sorted().

{
        char *cur, *next = NULL, *name, *p;

        name = next = cur = buf;

        *channels = 1;

        for (;;) {
                if (!next) {
                        break;
                }

                if ((p = strchr(next, '@'))) {
                        *p++ = '\0';
                }
                next = p;

                if (cur != name) {
                        if (strchr(cur, 'i')) {
                                *interval = atoi(cur);
                        } else if ((strchr(cur, 'k') || strchr(cur, 'h'))) {
                                *rate = atoi(cur);
                        } else if (strchr(cur, 'b')) {
                                *bit = atoi(cur);
                        } else if (strchr(cur, 'c')) {
                                *channels = atoi(cur);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Bad syntax for codec string. Missing qualifier [h|k|i|b|c] for part [%s]!\n", cur);
                        }
                }
                cur = next;
        }
        
        if ((p = strchr(name, '.'))) {
                *p++ = '\0';
                *modname = name;
                name = p;
        }

        return name;
}

Variable Documentation

char* filename

Definition at line 331 of file switch_loadable_module.h.

Referenced by core_event_handler(), and switch_simple_email().