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)

Enumerations
enum	switch_loadable_module_type_t { SWITCH_LOADABLE_MODULE_TYPE_PRELOAD, SWITCH_LOADABLE_MODULE_TYPE_COMMON, SWITCH_LOADABLE_MODULE_TYPE_POSTLOAD }
	List of loadable module types. More...

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, char *fmtp)

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_database_interface_t *	switch_loadable_module_get_database_interface (const char name, const char modname)
	Retrieve the database 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, char fmtp_array[SWITCH_MAX_CODECS][MAX_FMTP_LEN], 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 (const char dir, const 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_protect (const char *mod)
	Protect module from beeing unloaded. More...

switch_status_t	switch_loadable_module_unload_module (const char dir, const 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
const char *	filename

Detailed Description

Macro Definition Documentation

◆ SWITCH_ADD_API

#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 365 of file switch_loadable_module.h.

Referenced by switch_msrp_load_apis_and_applications().

◆ SWITCH_ADD_APP

#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 393 of file switch_loadable_module.h.

Referenced by switch_msrp_load_apis_and_applications().

◆ SWITCH_ADD_CHAT

#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 385 of file switch_loadable_module.h.

◆ SWITCH_ADD_CHAT_APP

#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 405 of file switch_loadable_module.h.

◆ SWITCH_ADD_CODEC

#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 440 of file switch_loadable_module.h.

Referenced by mod_g711_load(), and SWITCH_MODULE_LOAD_FUNCTION().

◆ SWITCH_ADD_DIALPLAN

#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 417 of file switch_loadable_module.h.

◆ SWITCH_ADD_JSON_API

#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 375 of file switch_loadable_module.h.

◆ SWITCH_ADD_LIMIT

#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 425 of file switch_loadable_module.h.

Enumeration Type Documentation

◆ switch_loadable_module_type_t

enum switch_loadable_module_type_t

List of loadable module types.

Enumerator
SWITCH_LOADABLE_MODULE_TYPE_PRELOAD
SWITCH_LOADABLE_MODULE_TYPE_COMMON
SWITCH_LOADABLE_MODULE_TYPE_POSTLOAD

Definition at line 57 of file switch_loadable_module.h.

                      {
                 SWITCH_LOADABLE_MODULE_TYPE_PRELOAD,
                 SWITCH_LOADABLE_MODULE_TYPE_COMMON,
                 SWITCH_LOADABLE_MODULE_TYPE_POSTLOAD
         } switch_loadable_module_type_t;

Function Documentation

◆ switch_api_execute()

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 2933 of file switch_loadable_module.c.

References switch_stream_handle::data, switch_api_interface::function, switch_stream_handle::param_event, 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(), UNPROTECT_INTERFACE, and switch_stream_handle::write_function.

Referenced by api_hook(), do_api_on(), API::execute(), API::executeString(), record_helper_post_process(), switch_channel_expand_variables_check(), switch_console_execute(), switch_core_perform_file_open(), switch_event_expand_headers_check(), switch_ivr_parse_event(), switch_ivr_record_file_event(), 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;
 }

◆ switch_check_interval()

static int switch_check_interval	(	uint32_t	rate,
		uint32_t	ptime
	)

inlinestatic

Definition at line 449 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:
         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;
 }

◆ switch_core_codec_add_implementation()

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 487 of file switch_loadable_module.h.

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);
         }
 }

◆ switch_core_codec_next_id()

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_core_execute_chat_app()

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

Definition at line 995 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_json_api_execute()

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 2992 of file switch_loadable_module.c.

References 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_loadable_module_build_dynamic()

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 1987 of file switch_loadable_module.c.

 {
         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) {
                         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, NULL);
 }

◆ switch_loadable_module_enumerate_available()

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 1931 of file switch_loadable_module.c.

References buffer, 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_loadable_module_enumerate_loaded()

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 1969 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_loadable_module_exists()

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 1846 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_loadable_module_get_api_interface()

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_loadable_module_get_application_interface()

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_loadable_module_get_asr_interface()

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_loadable_module_get_chat_application_interface()

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_loadable_module_get_chat_interface()

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_loadable_module_get_codec_interface()

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 2547 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);
 
         PROTECT_INTERFACE(codec);
 
         return codec;
 }

◆ switch_loadable_module_get_codecs()

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 2699 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;
 
 }

◆ switch_loadable_module_get_codecs_sorted()

int switch_loadable_module_get_codecs_sorted	(	const switch_codec_implementation_t **	array,
		char	fmtp_array[SWITCH_MAX_CODECS][MAX_FMTP_LEN],
		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 2796 of file switch_loadable_module.c.

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, *fmtp = 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, &fmtp);
 
                 for(j = 0; j < x; j++) {
                         char *jname, *jmodname = NULL, *jfmtp = 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, &jfmtp);
 
                         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 &&
                                 !strcasecmp(switch_str_nil(fmtp), switch_str_nil(jfmtp))) {
                                 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;
                                         }
                                 }
 
                                 if (!zstr(fmtp)) {
                                         switch_set_string(fmtp_array[i], fmtp);
                                 }
                                 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_loadable_module_get_database_interface()

switch_database_interface_t* switch_loadable_module_get_database_interface	(	const char *	name,
		const char *	modname
	)

Retrieve the database interface by it's registered name.

Parameters

name	the name of the dsn prefix

Returns: the desired database format interface

Definition at line 2519 of file switch_loadable_module.c.

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

Referenced by _switch_cache_db_get_db_handle_dsn_ex(), and switch_database_available().

 {
         switch_database_interface_t *i = NULL;
         switch_database_node_t *node, *head;
 
         switch_mutex_lock(loadable_modules.mutex);
 
         if ((head = switch_core_hash_find(loadable_modules.database_hash, name))) {
                 if (modname) {
                         for (node = head; node; node = node->next) {
                                 if (!strcasecmp(node->interface_name, modname)) {
                                         i = (switch_database_interface_t *)node->ptr;
                                         break;
                                 }
                         }
                 }
                 else {
                         i = (switch_database_interface_t *)head->ptr;
                 }
         }
 
         switch_mutex_unlock(loadable_modules.mutex);
 
         if (i) PROTECT_INTERFACE(i);
 
         return i;
 }

◆ switch_loadable_module_get_dialplan_interface()

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_loadable_module_get_directory_interface()

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_loadable_module_get_endpoint_interface()

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 2479 of file switch_loadable_module.c.

References switch_loadable_module_container::endpoint_hash, loadable_modules, switch_loadable_module_container::mutex, PROTECT_INTERFACE, switch_file_node_s::ptr, 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);
         PROTECT_INTERFACE(ptr);
         switch_mutex_unlock(loadable_modules.mutex);
 
 
         return ptr;
 }

◆ switch_loadable_module_get_file_interface()

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 2492 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_loadable_module_get_json_api_interface()

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_loadable_module_get_limit_interface()

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_loadable_module_get_management_interface()

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 2601 of file switch_loadable_module.c.

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

Referenced by switch_core_management_exec().

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

◆ switch_loadable_module_get_say_interface()

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 2596 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_loadable_module_get_speech_interface()

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_loadable_module_get_timer_interface()

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_loadable_module_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 2080 of file switch_loadable_module.c.

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

 {
 
         fspr_finfo_t finfo = { 0 };
         fspr_dir_t *module_dir_handle = NULL;
         fspr_int32_t finfo_flags = APR_FINFO_DIRENT | APR_FINFO_TYPE | APR_FINFO_NAME;
         char *precf = "pre_load_modules.conf";
         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;
         switch_hash_t *event_hash;
         switch_hash_index_t *hi;
         void *hash_val;
         switch_event_t *event;
 
 
 #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.database_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);
         switch_thread_rwlock_create(&loadable_modules.chat_rwlock, loadable_modules.pool);
         
         if (!autoload) return SWITCH_STATUS_SUCCESS;
         
         /*
                 switch_core_sqldb_init() is not yet ready and is executed after starting modules from pre_load_modules.conf
                 Modules loading procedure generates events used by sqldb.
                 This is why we should hold those events (storing in the event_hash) not firing them until sqldb is ready.
         */
         switch_core_hash_init(&event_hash);
 
         /* 
                 Pre-load core modules.
                 Do not pre-load modules which may use databases,
                 use appropriate section.
         */
         switch_loadable_module_load_module_ex("", "CORE_SOFTTIMER_MODULE", SWITCH_FALSE, SWITCH_FALSE, &err, SWITCH_LOADABLE_MODULE_TYPE_COMMON, event_hash);
         switch_loadable_module_load_module_ex("", "CORE_PCM_MODULE", SWITCH_FALSE, SWITCH_FALSE, &err, SWITCH_LOADABLE_MODULE_TYPE_COMMON, event_hash);
         switch_loadable_module_load_module_ex("", "CORE_SPEEX_MODULE", SWITCH_FALSE, SWITCH_FALSE, &err, SWITCH_LOADABLE_MODULE_TYPE_COMMON, event_hash);
 
         /*
                 Loading pre-load modules.
                 Database modules must be loaded here.
         */
         if ((xml = switch_xml_open_cfg(precf, &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_LOADABLE_MODULE_TYPE_PRELOAD, event_hash) == 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);
                                                 switch_core_hash_destroy(&event_hash);
 
                                                 abort();
                                         }
                                 }
                                 count++;
                         }
                 }
                 switch_xml_free(xml);
 
         }
         else {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "open of %s failed\n", precf);
         }
 
         if (switch_core_sqldb_init(&err) != SWITCH_STATUS_SUCCESS)
         {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Loading modules interrupted. [Error: %s]\n", err);
                 switch_core_hash_destroy(&event_hash);
                 return SWITCH_STATUS_GENERR;
         }
 
         /* sqldb is ready. Fire holding events! */
         for (hi = switch_core_hash_first(event_hash); hi; hi = switch_core_hash_next(&hi)) {
                 switch_core_hash_this(hi, NULL, NULL, &hash_val);
                 event = (switch_event_t *)hash_val;
                 switch_event_fire(&event);
         }
 
         switch_core_hash_destroy(&event_hash);
 
         /*
                 To perevent locking.
                 Core modules which may use databases should be pre-loaded here
                 (databases are loaded already).
         */
 #ifdef SWITCH_HAVE_YUV
 #ifdef SWITCH_HAVE_VPX
         switch_loadable_module_load_module("", "CORE_VPX_MODULE", SWITCH_FALSE, &err);
 #endif
 #endif
 
         /* Loading common modules */
         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(path, val, SWITCH_FALSE, global, &err, SWITCH_LOADABLE_MODULE_TYPE_COMMON, NULL) == 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(path, val, SWITCH_FALSE, global, &err, SWITCH_LOADABLE_MODULE_TYPE_POSTLOAD, NULL);
                                 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 (fspr_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 (fspr_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(SWITCH_GLOBAL_dirs.mod_dir, fname, SWITCH_FALSE, &err);
                 }
                 fspr_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_loadable_module_load_module()

switch_status_t switch_loadable_module_load_module	(	const char *	dir,
		const 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 1779 of file switch_loadable_module.c.

References SWITCH_FALSE, switch_loadable_module_load_module_ex(), and SWITCH_LOADABLE_MODULE_TYPE_COMMON.

Referenced by main(), and switch_loadable_module_init().

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

◆ switch_loadable_module_protect()

switch_status_t switch_loadable_module_protect ( const char * mod )

Protect module from beeing unloaded.

Parameters

mod	the module name

Returns: the status

Definition at line 1865 of file switch_loadable_module.c.

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

Referenced by _switch_cache_db_get_db_handle().

 {
         switch_loadable_module_t *module = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         if (zstr(mod)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         switch_mutex_lock(loadable_modules.mutex);
         if ((module = switch_core_hash_find(loadable_modules.module_hash, mod))) {
                 if (!module->perm) {
                         module->perm++;
                 }
                 status = SWITCH_STATUS_SUCCESS;
         }
         else {
                 status = SWITCH_STATUS_FALSE;
         }
         switch_mutex_unlock(loadable_modules.mutex);
 
         return status;
 }

◆ switch_loadable_module_shutdown()

void switch_loadable_module_shutdown ( void )

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

Definition at line 2386 of file switch_loadable_module.c.

Referenced by fs_loadable_module_shutdown(), and switch_core_destroy().

 {
         switch_hash_index_t *hi;
         void *val;
         const void *key;
         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->type != SWITCH_LOADABLE_MODULE_TYPE_PRELOAD && !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;) {
                 switch_core_hash_this(hi, &key, NULL, &val);
                 module = (switch_loadable_module_t *)val;
 
                 hi = switch_core_hash_next(&hi);
 
                 if (module->type != SWITCH_LOADABLE_MODULE_TYPE_PRELOAD && !module->perm) {
                         if (do_shutdown(module, SWITCH_FALSE, SWITCH_TRUE, SWITCH_FALSE, NULL) == SWITCH_STATUS_SUCCESS)
                         {
                                 switch_core_hash_delete(loadable_modules.module_hash, key);
                         }
                 }
         }
 
         switch_core_sqldb_destroy();
 
         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);
                 if ((module = (switch_loadable_module_t *)val)) {
                         if (module->type == SWITCH_LOADABLE_MODULE_TYPE_PRELOAD && !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);
                 if ((module = (switch_loadable_module_t *)val)) {
                         if (module->type == SWITCH_LOADABLE_MODULE_TYPE_PRELOAD && !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.database_hash);
         switch_core_hash_destroy(&loadable_modules.dialplan_hash);
         switch_core_hash_destroy(&loadable_modules.secondary_recover_hash);
 
         switch_core_destroy_memory_pool(&loadable_modules.pool);
 }

◆ switch_loadable_module_unload_module()

switch_status_t switch_loadable_module_unload_module	(	const char *	dir,
		const 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 1889 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_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

◆ switch_parse_codec_buf()

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

Definition at line 2746 of file switch_loadable_module.c.

References buf, cur, name, switch_file_node_s::next, 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;
         }
 
         if ((p = strchr(name, '~'))) {
                 *p++ = '\0';
                 if (fmtp) {
                         *fmtp = p;
                 }
         }
 
         return name;
 }

Variable Documentation

◆ filename

const char* filename

Definition at line 356 of file switch_loadable_module.h.

Referenced by core_event_handler(), switch_simple_email(), and SWITCH_STANDARD_APP().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ SWITCH_ADD_API

◆ SWITCH_ADD_APP

◆ SWITCH_ADD_CHAT

◆ SWITCH_ADD_CHAT_APP

◆ SWITCH_ADD_CODEC

◆ SWITCH_ADD_DIALPLAN

◆ SWITCH_ADD_JSON_API

◆ SWITCH_ADD_LIMIT

Enumeration Type Documentation

◆ switch_loadable_module_type_t

Function Documentation

◆ switch_api_execute()

◆ switch_check_interval()

◆ switch_core_codec_add_implementation()

◆ switch_core_codec_next_id()

◆ switch_core_execute_chat_app()

◆ switch_json_api_execute()

◆ switch_loadable_module_build_dynamic()

◆ switch_loadable_module_enumerate_available()

◆ switch_loadable_module_enumerate_loaded()

◆ switch_loadable_module_exists()

◆ switch_loadable_module_get_api_interface()

◆ switch_loadable_module_get_application_interface()

◆ switch_loadable_module_get_asr_interface()

◆ switch_loadable_module_get_chat_application_interface()

◆ switch_loadable_module_get_chat_interface()

◆ switch_loadable_module_get_codec_interface()

◆ switch_loadable_module_get_codecs()

◆ switch_loadable_module_get_codecs_sorted()

◆ switch_loadable_module_get_database_interface()

◆ switch_loadable_module_get_dialplan_interface()

◆ switch_loadable_module_get_directory_interface()

◆ switch_loadable_module_get_endpoint_interface()

◆ switch_loadable_module_get_file_interface()

◆ switch_loadable_module_get_json_api_interface()

◆ switch_loadable_module_get_limit_interface()

◆ switch_loadable_module_get_management_interface()

◆ switch_loadable_module_get_say_interface()

◆ switch_loadable_module_get_speech_interface()

◆ switch_loadable_module_get_timer_interface()

◆ switch_loadable_module_init()

◆ switch_loadable_module_load_module()

◆ switch_loadable_module_protect()

◆ switch_loadable_module_shutdown()

◆ switch_loadable_module_unload_module()

◆ SWITCH_MOD_DECLARE()

◆ switch_parse_codec_buf()

Variable Documentation

◆ filename