FreeSWITCH API Documentation  1.7.0
switch_loadable_module.c
Go to the documentation of this file.
1 /*
2  * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
3  * Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
4  *
5  * Version: MPL 1.1
6  *
7  * The contents of this file are subject to the Mozilla Public License Version
8  * 1.1 (the "License"); you may not use this file except in compliance with
9  * the License. You may obtain a copy of the License at
10  * http://www.mozilla.org/MPL/
11  *
12  * Software distributed under the License is distributed on an "AS IS" basis,
13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14  * for the specific language governing rights and limitations under the
15  * License.
16  *
17  * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
18  *
19  * The Initial Developer of the Original Code is
20  * Anthony Minessale II <anthm@freeswitch.org>
21  * Portions created by the Initial Developer are Copyright (C)
22  * the Initial Developer. All Rights Reserved.
23  *
24  * Contributor(s):
25  *
26  * Anthony Minessale II <anthm@freeswitch.org>
27  * Seven Du <dujinfang@gmail.com>
28  *
29  * switch_loadable_module.c -- Loadable Modules
30  *
31  */
32 
33 #include <switch.h>
34 
35 /* for apr_pstrcat */
36 #include <apr_strings.h>
37 
38 /* for apr_env_get and apr_env_set */
39 #include <apr_env.h>
40 
41 /* for apr file and directory handling */
42 #include <apr_file_io.h>
43 
44 typedef struct switch_file_node_s {
45  const switch_file_interface_t *ptr;
46  const char *interface_name;
47  struct switch_file_node_s *next;
48 } switch_file_node_t;
49 
50 typedef struct switch_codec_node_s {
51  const switch_codec_interface_t *ptr;
52  const char *interface_name;
53  struct switch_codec_node_s *next;
54 } switch_codec_node_t;
55 
56 
57 struct switch_loadable_module {
58  char *key;
59  char *filename;
60  int perm;
61  switch_loadable_module_interface_t *module_interface;
62  switch_dso_lib_t lib;
63  switch_module_load_t switch_module_load;
64  switch_module_runtime_t switch_module_runtime;
65  switch_module_shutdown_t switch_module_shutdown;
66  switch_memory_pool_t *pool;
67  switch_status_t status;
68  switch_thread_t *thread;
69  switch_bool_t shutting_down;
70 };
71 
72 struct switch_loadable_module_container {
73  switch_hash_t *module_hash;
74  switch_hash_t *endpoint_hash;
75  switch_hash_t *codec_hash;
76  switch_hash_t *dialplan_hash;
77  switch_hash_t *timer_hash;
78  switch_hash_t *application_hash;
79  switch_hash_t *chat_application_hash;
80  switch_hash_t *api_hash;
81  switch_hash_t *json_api_hash;
82  switch_hash_t *file_hash;
83  switch_hash_t *speech_hash;
84  switch_hash_t *asr_hash;
85  switch_hash_t *directory_hash;
86  switch_hash_t *chat_hash;
87  switch_hash_t *say_hash;
88  switch_hash_t *management_hash;
89  switch_hash_t *limit_hash;
90  switch_hash_t *secondary_recover_hash;
91  switch_mutex_t *mutex;
92  switch_memory_pool_t *pool;
93 };
94 
95 static struct switch_loadable_module_container loadable_modules;
96 static switch_status_t do_shutdown(switch_loadable_module_t *module, switch_bool_t shutdown, switch_bool_t unload, switch_bool_t fail_if_busy,
97  const char **err);
98 static switch_status_t switch_loadable_module_load_module_ex(char *dir, char *fname, switch_bool_t runtime, switch_bool_t global, const char **err);
99 
100 static void *SWITCH_THREAD_FUNC switch_loadable_module_exec(switch_thread_t *thread, void *obj)
101 {
102 
103 
104  switch_status_t status = SWITCH_STATUS_SUCCESS;
105  switch_core_thread_session_t *ts = obj;
106  switch_loadable_module_t *module = ts->objs[0];
107  int restarts;
108 
109  switch_assert(thread != NULL);
110  switch_assert(module != NULL);
111 
112  for (restarts = 0; status != SWITCH_STATUS_TERM && !module->shutting_down; restarts++) {
113  status = module->switch_module_runtime();
114  }
115  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Thread ended for %s\n", module->module_interface->module_name);
116 
117  if (ts->pool) {
118  switch_memory_pool_t *pool = ts->pool;
119  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroying Pool for %s\n", module->module_interface->module_name);
120  switch_core_destroy_memory_pool(&pool);
121  }
122  switch_thread_exit(thread, 0);
123  return NULL;
124 }
125 
126 
127 static void switch_loadable_module_runtime(void)
128 {
129  switch_hash_index_t *hi;
130  void *val;
131  switch_loadable_module_t *module;
132 
133  switch_mutex_lock(loadable_modules.mutex);
134  for (hi = switch_core_hash_first(loadable_modules.module_hash); hi; hi = switch_core_hash_next(&hi)) {
135  switch_core_hash_this(hi, NULL, NULL, &val);
136  module = (switch_loadable_module_t *) val;
137 
138  if (module->switch_module_runtime) {
139  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Starting runtime thread for %s\n", module->module_interface->module_name);
140  module->thread = switch_core_launch_thread(switch_loadable_module_exec, module, loadable_modules.pool);
141  }
142  }
143  switch_mutex_unlock(loadable_modules.mutex);
144 }
145 
146 static switch_status_t switch_loadable_module_process(char *key, switch_loadable_module_t *new_module)
147 {
148  switch_event_t *event;
149  int added = 0;
150 
151  new_module->key = switch_core_strdup(new_module->pool, key);
152 
153  switch_mutex_lock(loadable_modules.mutex);
154  switch_core_hash_insert(loadable_modules.module_hash, key, new_module);
155 
156  if (new_module->module_interface->endpoint_interface) {
157  const switch_endpoint_interface_t *ptr;
158  for (ptr = new_module->module_interface->endpoint_interface; ptr; ptr = ptr->next) {
159  if (!ptr->interface_name) {
160  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load endpoint interface from %s due to no interface name.\n", key);
161  } else {
162  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Endpoint '%s'\n", ptr->interface_name);
163  switch_core_hash_insert(loadable_modules.endpoint_hash, ptr->interface_name, (const void *) ptr);
164  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
165  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "endpoint");
166  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
167  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
168  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
169  switch_event_fire(&event);
170  added++;
171  }
172  }
173  }
174  }
175 
176  if (new_module->module_interface->codec_interface) {
177  const switch_codec_implementation_t *impl;
178  const switch_codec_interface_t *ptr;
179 
180  for (ptr = new_module->module_interface->codec_interface; ptr; ptr = ptr->next) {
181  if (!ptr->interface_name) {
182  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load codec interface from %s due to no interface name.\n", key);
183  } else {
184  unsigned load_interface = 1;
185  switch_codec_node_t *node, *head;
186 
187  for (impl = ptr->implementations; impl; impl = impl->next) {
188  if (!impl->iananame) {
189  load_interface = 0;
190  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
191  "Failed to load codec interface %s from %s due to no iana name in an implementation.\n", ptr->interface_name,
192  key);
193  break;
194  }
195  if (impl->decoded_bytes_per_packet > SWITCH_RECOMMENDED_BUFFER_SIZE) {
196  load_interface = 0;
197  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
198  "Failed to load codec interface %s from %s due to bytes per frame %d exceeding buffer size %d.\n",
199  ptr->interface_name,
200  key, impl->decoded_bytes_per_packet, SWITCH_RECOMMENDED_BUFFER_SIZE);
201  break;
202  }
203  }
204  if (load_interface) {
205  for (impl = ptr->implementations; impl; impl = impl->next) {
206  if (impl->bits_per_second) {
207  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
208  "Adding Codec %s %d %s %dhz %dms %dbps\n",
209  impl->iananame, impl->ianacode,
210  ptr->interface_name, impl->actual_samples_per_second,
211  impl->microseconds_per_packet / 1000, impl->bits_per_second);
212  } else {
213  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
214  "Adding Codec %s %d %s %dhz %dms (VBR)\n",
215  impl->iananame, impl->ianacode,
216  ptr->interface_name, impl->actual_samples_per_second, impl->microseconds_per_packet / 1000);
217  }
218 
219  node = switch_core_alloc(new_module->pool, sizeof(*node));
220  node->ptr = ptr;
221  node->interface_name = switch_core_strdup(new_module->pool, new_module->module_interface->module_name);
222  if ((head = switch_core_hash_find(loadable_modules.codec_hash, impl->iananame))) {
223  node->next = head;
224  }
225 
226  switch_core_hash_insert(loadable_modules.codec_hash, impl->iananame, (const void *) node);
227  }
228 
229  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
230  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "codec");
231  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
232  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
233  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
234  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", new_module->module_interface->module_name);
235  switch_event_fire(&event);
236  added++;
237  }
238  }
239  }
240  }
241  }
242 
243  if (new_module->module_interface->dialplan_interface) {
244  const switch_dialplan_interface_t *ptr;
245 
246  for (ptr = new_module->module_interface->dialplan_interface; ptr; ptr = ptr->next) {
247  if (!ptr->interface_name) {
248  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load dialplan interface from %s due to no interface name.\n", key);
249  } else {
250  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Dialplan '%s'\n", ptr->interface_name);
251  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
252  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "dialplan");
253  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
254  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
255  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
256  switch_event_fire(&event);
257  added++;
258  }
259  switch_core_hash_insert(loadable_modules.dialplan_hash, ptr->interface_name, (const void *) ptr);
260  }
261  }
262  }
263 
264  if (new_module->module_interface->timer_interface) {
265  const switch_timer_interface_t *ptr;
266 
267  for (ptr = new_module->module_interface->timer_interface; ptr; ptr = ptr->next) {
268  if (!ptr->interface_name) {
269  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load timer interface from %s due to no interface name.\n", key);
270  } else {
271  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Timer '%s'\n", ptr->interface_name);
272  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
273  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "timer");
274  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
275  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
276  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
277  switch_event_fire(&event);
278  added++;
279  }
280  switch_core_hash_insert(loadable_modules.timer_hash, ptr->interface_name, (const void *) ptr);
281  }
282  }
283  }
284 
285  if (new_module->module_interface->application_interface) {
286  const switch_application_interface_t *ptr;
287 
288  for (ptr = new_module->module_interface->application_interface; ptr; ptr = ptr->next) {
289  if (!ptr->interface_name) {
290  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load application interface from %s due to no interface name.\n", key);
291  } else {
292  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Application '%s'\n", ptr->interface_name);
293  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
294  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
295  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
296  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
297  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
298  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
299  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
300  switch_event_fire(&event);
301  added++;
302  }
303  switch_core_hash_insert(loadable_modules.application_hash, ptr->interface_name, (const void *) ptr);
304  }
305  }
306  }
307 
308  if (new_module->module_interface->chat_application_interface) {
309  const switch_chat_application_interface_t *ptr;
310 
311  for (ptr = new_module->module_interface->chat_application_interface; ptr; ptr = ptr->next) {
312  if (!ptr->interface_name) {
313  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load application interface from %s due to no interface name.\n", key);
314  } else {
315  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Chat Application '%s'\n", ptr->interface_name);
316  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
317  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
318  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
319  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
320  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
321  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
322  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
323  switch_event_fire(&event);
324  added++;
325  }
326  switch_core_hash_insert(loadable_modules.chat_application_hash, ptr->interface_name, (const void *) ptr);
327  }
328  }
329  }
330 
331  if (new_module->module_interface->api_interface) {
332  const switch_api_interface_t *ptr;
333 
334  for (ptr = new_module->module_interface->api_interface; ptr; ptr = ptr->next) {
335  if (!ptr->interface_name) {
336  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load api interface from %s due to no interface name.\n", key);
337  } else {
338  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding API Function '%s'\n", ptr->interface_name);
339  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
340  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "api");
341  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
342  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
343  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
344  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
345  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
346  switch_event_fire(&event);
347  added++;
348  }
349  switch_core_hash_insert(loadable_modules.api_hash, ptr->interface_name, (const void *) ptr);
350  }
351  }
352  }
353 
354  if (new_module->module_interface->json_api_interface) {
355  const switch_json_api_interface_t *ptr;
356 
357  for (ptr = new_module->module_interface->json_api_interface; ptr; ptr = ptr->next) {
358  if (!ptr->interface_name) {
359  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load JSON api interface from %s due to no interface name.\n", key);
360  } else {
361  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding JSON API Function '%s'\n", ptr->interface_name);
362  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
363  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "json_api");
364  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
365  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
366  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
367  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
368  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
369  switch_event_fire(&event);
370  added++;
371  }
372  switch_core_hash_insert(loadable_modules.json_api_hash, ptr->interface_name, (const void *) ptr);
373  }
374  }
375  }
376 
377  if (new_module->module_interface->file_interface) {
378  const switch_file_interface_t *ptr;
379 
380  for (ptr = new_module->module_interface->file_interface; ptr; ptr = ptr->next) {
381  if (!ptr->interface_name) {
382  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load file interface from %s due to no interface name.\n", key);
383  } else if (!ptr->extens) {
384  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load file interface from %s due to no file extensions.\n", key);
385  } else {
386  int i;
387  switch_file_node_t *node, *head;
388 
389  for (i = 0; ptr->extens[i]; i++) {
390  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding File Format '%s'\n", ptr->extens[i]);
391  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
392  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "file");
393  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->extens[i]);
394  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
395  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
396  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", new_module->module_interface->module_name);
397  switch_event_fire(&event);
398  added++;
399  }
400  node = switch_core_alloc(new_module->pool, sizeof(*node));
401  node->ptr = ptr;
402  node->interface_name = switch_core_strdup(new_module->pool, new_module->module_interface->module_name);
403  if ((head = switch_core_hash_find(loadable_modules.file_hash, ptr->extens[i]))) {
404  node->next = head;
405  }
406 
407  switch_core_hash_insert(loadable_modules.file_hash, ptr->extens[i], (const void *) node);
408  }
409  }
410  }
411  }
412 
413  if (new_module->module_interface->speech_interface) {
414  const switch_speech_interface_t *ptr;
415 
416  for (ptr = new_module->module_interface->speech_interface; ptr; ptr = ptr->next) {
417  if (!ptr->interface_name) {
418  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load speech interface from %s due to no interface name.\n", key);
419  } else {
420  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Speech interface '%s'\n", ptr->interface_name);
421  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
422  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "speech");
423  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
424  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
425  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
426  switch_event_fire(&event);
427  added++;
428  }
429  switch_core_hash_insert(loadable_modules.speech_hash, ptr->interface_name, (const void *) ptr);
430  }
431  }
432  }
433 
434  if (new_module->module_interface->asr_interface) {
435  const switch_asr_interface_t *ptr;
436 
437  for (ptr = new_module->module_interface->asr_interface; ptr; ptr = ptr->next) {
438  if (!ptr->interface_name) {
439  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load asr interface from %s due to no interface name.\n", key);
440  } else {
441  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding ASR interface '%s'\n", ptr->interface_name);
442  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
443  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "asr");
444  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
445  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
446  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
447  switch_event_fire(&event);
448  added++;
449  }
450  switch_core_hash_insert(loadable_modules.asr_hash, ptr->interface_name, (const void *) ptr);
451  }
452  }
453  }
454 
455  if (new_module->module_interface->directory_interface) {
456  const switch_directory_interface_t *ptr;
457 
458  for (ptr = new_module->module_interface->directory_interface; ptr; ptr = ptr->next) {
459  if (!ptr->interface_name) {
460  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load directory interface from %s due to no interface name.\n", key);
461  } else {
462  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Directory interface '%s'\n", ptr->interface_name);
463  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
464  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "directory");
465  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
466  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
467  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
468  switch_event_fire(&event);
469  added++;
470  }
471  switch_core_hash_insert(loadable_modules.directory_hash, ptr->interface_name, (const void *) ptr);
472  }
473  }
474  }
475 
476  if (new_module->module_interface->chat_interface) {
477  const switch_chat_interface_t *ptr;
478 
479  for (ptr = new_module->module_interface->chat_interface; ptr; ptr = ptr->next) {
480  if (!ptr->interface_name) {
481  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load chat interface from %s due to no interface name.\n", key);
482  } else {
483  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Chat interface '%s'\n", ptr->interface_name);
484  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
485  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "chat");
486  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
487  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
488  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
489  switch_event_fire(&event);
490  added++;
491  }
492  switch_core_hash_insert(loadable_modules.chat_hash, ptr->interface_name, (const void *) ptr);
493  }
494  }
495  }
496 
497  if (new_module->module_interface->say_interface) {
498  const switch_say_interface_t *ptr;
499 
500  for (ptr = new_module->module_interface->say_interface; ptr; ptr = ptr->next) {
501  if (!ptr->interface_name) {
502  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load say interface from %s due to no interface name.\n", key);
503  } else {
504  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding Say interface '%s'\n", ptr->interface_name);
505  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
506  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "say");
507  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
508  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
509  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
510  switch_event_fire(&event);
511  added++;
512  }
513  switch_core_hash_insert(loadable_modules.say_hash, ptr->interface_name, (const void *) ptr);
514  }
515  }
516  }
517 
518  if (new_module->module_interface->management_interface) {
519  const switch_management_interface_t *ptr;
520 
521  for (ptr = new_module->module_interface->management_interface; ptr; ptr = ptr->next) {
522  if (!ptr->relative_oid) {
523  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load management interface from %s due to no interface name.\n", key);
524  } else {
525  if (switch_core_hash_find(loadable_modules.management_hash, ptr->relative_oid)) {
526  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
527  "Failed to load management interface %s. OID %s already exists\n", key, ptr->relative_oid);
528  } else {
529  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
530  "Adding Management interface '%s' OID[%s.%s]\n", key, FREESWITCH_OID_PREFIX, ptr->relative_oid);
531  switch_core_hash_insert(loadable_modules.management_hash, ptr->relative_oid, (const void *) ptr);
532  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
533  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "management");
534  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->relative_oid);
535  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
536  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
537  switch_event_fire(&event);
538  added++;
539  }
540  }
541 
542  }
543  }
544  }
545  if (new_module->module_interface->limit_interface) {
546  const switch_limit_interface_t *ptr;
547 
548  for (ptr = new_module->module_interface->limit_interface; ptr; ptr = ptr->next) {
549  if (!ptr->interface_name) {
550  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load limit interface from %s due to no interface name.\n", key);
551  } else {
552  if (switch_core_hash_find(loadable_modules.limit_hash, ptr->interface_name)) {
553  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
554  "Failed to load limit interface %s. Name %s already exists\n", key, ptr->interface_name);
555  } else {
556  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
557  "Adding Limit interface '%s'\n", ptr->interface_name);
558  switch_core_hash_insert(loadable_modules.limit_hash, ptr->interface_name, (const void *) ptr);
559  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
560  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "limit");
561  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
562  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
563  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
564  switch_event_fire(&event);
565  added++;
566  }
567  }
568 
569  }
570  }
571  }
572 
573  if (!added) {
574  if (switch_event_create(&event, SWITCH_EVENT_MODULE_LOAD) == SWITCH_STATUS_SUCCESS) {
575  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "generic");
576  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", new_module->key);
577  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", new_module->key);
578  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "filename", new_module->filename);
579  switch_event_fire(&event);
580  added++;
581  }
582  }
583 
584  switch_mutex_unlock(loadable_modules.mutex);
585  return SWITCH_STATUS_SUCCESS;
586 
587 }
588 
589 #define CHAT_MAX_MSG_QUEUE 101
590 #define CHAT_QUEUE_SIZE 5000
591 
592 static struct {
593  switch_queue_t *msg_queue[CHAT_MAX_MSG_QUEUE];
594  switch_thread_t *msg_queue_thread[CHAT_MAX_MSG_QUEUE];
595  int msg_queue_len;
596  switch_mutex_t *mutex;
597  switch_memory_pool_t *pool;
598  int running;
599 } chat_globals;
600 
601 static int IDX = 0;
602 
603 
604 static switch_status_t do_chat_send(switch_event_t *message_event)
605 
606 {
607  switch_chat_interface_t *ci;
608  switch_status_t status = SWITCH_STATUS_FALSE;
609  switch_hash_index_t *hi;
610  switch_event_t *dup = NULL;
611  const void *var;
612  void *val;
613  const char *proto;
614  const char *replying;
615  const char *dest_proto;
616  int do_skip = 0;
617 
618  /*
619 
620  const char *from;
621  const char *to;
622  const char *subject;
623  const char *body;
624  const char *type;
625  const char *hint;
626  */
627 
628  dest_proto = switch_event_get_header(message_event, "dest_proto");
629 
630  if (!dest_proto) {
631  return SWITCH_STATUS_FALSE;
632  }
633 
634  /*
635 
636  from = switch_event_get_header(message_event, "from");
637  to = switch_event_get_header(message_event, "to");
638  subject = switch_event_get_header(message_event, "subject");
639  body = switch_event_get_body(message_event);
640  type = switch_event_get_header(message_event, "type");
641  hint = switch_event_get_header(message_event, "hint");
642  */
643 
644  if (!(proto = switch_event_get_header(message_event, "proto"))) {
645  proto = "global";
646  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "proto", proto);
647  }
648 
649  replying = switch_event_get_header(message_event, "replying");
650 
651  if (!switch_true(replying) && !switch_stristr("global", proto) && !switch_true(switch_event_get_header(message_event, "skip_global_process"))) {
652  switch_mutex_lock(loadable_modules.mutex);
653  for (hi = switch_core_hash_first(loadable_modules.chat_hash); hi; hi = switch_core_hash_next(&hi)) {
654  switch_core_hash_this(hi, &var, NULL, &val);
655 
656  if ((ci = (switch_chat_interface_t *) val)) {
657  if (ci->chat_send && !strncasecmp(ci->interface_name, "GLOBAL_", 7)) {
658  status = ci->chat_send(message_event);
659 
660  if (status == SWITCH_STATUS_SUCCESS) {
661  if (switch_true(switch_event_get_header(message_event, "final_delivery"))) {
662  /* The event was handled by an extension in the chatplan,
663  * so the event will be duplicated, modified and queued again,
664  * but it won't be processed by the chatplan again.
665  * So this copy of the event can be destroyed by the caller.
666  */
667  do_skip = 1;
668  }
669  } else if (status == SWITCH_STATUS_BREAK) {
670  /* The event went through the chatplan, but no extension matched
671  * to handle the sms messsage. It'll be attempted to be delivered
672  * directly, and unless that works the sms delivery will have failed.
673  */
674  } else {
675  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Chat Interface Error [%s]!\n", dest_proto);
676  break;
677  }
678  }
679  }
680  }
681  switch_safe_free(hi);
682  switch_mutex_unlock(loadable_modules.mutex);
683  }
684 
685 
686  if (!do_skip && !switch_stristr("GLOBAL", dest_proto)) {
687  if ((ci = switch_loadable_module_get_chat_interface(dest_proto)) && ci->chat_send) {
688  status = ci->chat_send(message_event);
689  UNPROTECT_INTERFACE(ci);
690  } else {
691  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid chat interface [%s]!\n", dest_proto);
692  status = SWITCH_STATUS_FALSE;
693  }
694  }
695 
696 
697  switch_event_dup(&dup, message_event);
698 
699  if ( switch_true(switch_event_get_header(message_event, "blocking")) ) {
700  if (status == SWITCH_STATUS_SUCCESS) {
701  switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "Delivery-Failure", "false");
702  } else {
703  switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "Delivery-Failure", "true");
704  }
705  } else {
706  switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "Nonblocking-Delivery", "true");
707  }
708 
709  switch_event_fire(&dup);
710  return status;
711 }
712 
713 static switch_status_t chat_process_event(switch_event_t **eventp)
714 {
715  switch_event_t *event;
716  switch_status_t status;
717 
718  switch_assert(eventp);
719 
720  event = *eventp;
721  *eventp = NULL;
722 
723  status = do_chat_send(event);
724  switch_event_destroy(&event);
725 
726  return status;
727 }
728 
729 
730 void *SWITCH_THREAD_FUNC chat_thread_run(switch_thread_t *thread, void *obj)
731 {
732  void *pop;
733  switch_queue_t *q = (switch_queue_t *) obj;
734 
735  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Chat Thread Started\n");
736 
737 
738  while(switch_queue_pop(q, &pop) == SWITCH_STATUS_SUCCESS && pop) {
739  switch_event_t *event = (switch_event_t *) pop;
740  chat_process_event(&event);
741  switch_cond_next();
742  }
743 
744  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Chat Thread Ended\n");
745 
746  return NULL;
747 }
748 
749 
750 static void chat_thread_start(int idx)
751 {
752 
753  if (idx >= CHAT_MAX_MSG_QUEUE || (idx < chat_globals.msg_queue_len && chat_globals.msg_queue_thread[idx])) {
754  return;
755  }
756 
757  switch_mutex_lock(chat_globals.mutex);
758 
759  if (idx >= chat_globals.msg_queue_len) {
760  int i;
761  chat_globals.msg_queue_len = idx + 1;
762 
763  for (i = 0; i < chat_globals.msg_queue_len; i++) {
764  if (!chat_globals.msg_queue[i]) {
765  switch_threadattr_t *thd_attr = NULL;
766 
767  switch_queue_create(&chat_globals.msg_queue[i], CHAT_QUEUE_SIZE, chat_globals.pool);
768 
769  switch_threadattr_create(&thd_attr, chat_globals.pool);
770  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
771  switch_thread_create(&chat_globals.msg_queue_thread[i],
772  thd_attr,
773  chat_thread_run,
774  chat_globals.msg_queue[i],
775  chat_globals.pool);
776  }
777  }
778  }
779 
780  switch_mutex_unlock(chat_globals.mutex);
781 }
782 
783 
784 static void chat_queue_message(switch_event_t **eventp)
785 {
786  int idx = 0;
787  switch_event_t *event;
788 
789  switch_assert(eventp);
790 
791  event = *eventp;
792  *eventp = NULL;
793 
794  if (chat_globals.running == 0) {
795  chat_process_event(&event);
796  return;
797  }
798 
799  again:
800 
801  switch_mutex_lock(chat_globals.mutex);
802  idx = IDX;
803  IDX++;
804  if (IDX >= chat_globals.msg_queue_len) IDX = 0;
805  switch_mutex_unlock(chat_globals.mutex);
806 
807  chat_thread_start(idx);
808 
809  if (switch_queue_trypush(chat_globals.msg_queue[idx], event) != SWITCH_STATUS_SUCCESS) {
810  if (chat_globals.msg_queue_len < CHAT_MAX_MSG_QUEUE) {
811  chat_thread_start(idx + 1);
812  goto again;
813  } else {
814  switch_queue_push(chat_globals.msg_queue[idx], event);
815  }
816  }
817 }
818 
819 
820 SWITCH_DECLARE(switch_status_t) switch_core_execute_chat_app(switch_event_t *message, const char *app, const char *data)
821 {
822  switch_chat_application_interface_t *cai;
823  switch_status_t status = SWITCH_STATUS_SUCCESS;
824  char *expanded;
825 
826  if (!(cai = switch_loadable_module_get_chat_application_interface(app)) || !cai->chat_application_function) {
827  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid chat application interface [%s]!\n", app);
828  return SWITCH_STATUS_FALSE;
829  }
830 
831  if (switch_test_flag(message, EF_NO_CHAT_EXEC)) {
832  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Message is not allowed to execute apps\n");
833  switch_goto_status(SWITCH_STATUS_FALSE, end);
834  }
835 
836  if (data && !strcmp(data, "__undef")) {
837  data = NULL;
838  }
839 
840  expanded = switch_event_expand_headers(message, data);
841 
842  status = cai->chat_application_function(message, expanded);
843 
844  if (expanded != data) {
845  free(expanded);
846  }
847 
848  end:
849 
850  UNPROTECT_INTERFACE(cai);
851 
852  return status;
853 
854 }
855 
856 
857 
858 SWITCH_DECLARE(switch_status_t) switch_core_chat_send_args(const char *dest_proto, const char *proto, const char *from, const char *to,
859  const char *subject, const char *body, const char *type, const char *hint, switch_bool_t blocking)
860 {
861  switch_event_t *message_event;
862  switch_status_t status;
863 
864  if (switch_event_create(&message_event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
865  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "proto", proto);
866  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "from", from);
867  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "to", to);
868  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "subject", subject);
869  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "type", type);
870  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "hint", hint);
871  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "skip_global_process", "true");
872  if (blocking) {
873  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "blocking", "true");
874  }
875 
876  if (body) {
877  switch_event_add_body(message_event, "%s", body);
878  }
879  } else {
880  abort();
881  }
882 
883  if (dest_proto) {
884  switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "dest_proto", dest_proto);
885  }
886 
887 
888  if (blocking) {
889  status = chat_process_event(&message_event);
890  } else {
891  chat_queue_message(&message_event);
892  status = SWITCH_STATUS_SUCCESS;
893  }
894 
895  return status;
896 
897 }
898 
899 
900 SWITCH_DECLARE(switch_status_t) switch_core_chat_send(const char *dest_proto, switch_event_t *message_event)
901 {
902  switch_event_t *dup;
903 
904  switch_event_dup(&dup, message_event);
905 
906  if (dest_proto) {
907  switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "dest_proto", dest_proto);
908  }
909 
910  chat_queue_message(&dup);
911  return SWITCH_STATUS_SUCCESS;
912 }
913 
914 
915 SWITCH_DECLARE(switch_status_t) switch_core_chat_deliver(const char *dest_proto, switch_event_t **message_event)
916 {
917 
918  if (dest_proto) {
919  switch_event_add_header_string(*message_event, SWITCH_STACK_BOTTOM, "dest_proto", dest_proto);
920  }
921 
922  chat_queue_message(message_event);
923 
924  return SWITCH_STATUS_SUCCESS;
925 }
926 
927 
928 static switch_status_t switch_loadable_module_unprocess(switch_loadable_module_t *old_module)
929 {
930  switch_event_t *event;
931  int removed = 0;
932 
933  switch_mutex_lock(loadable_modules.mutex);
934 
935  if (old_module->module_interface->endpoint_interface) {
936  const switch_endpoint_interface_t *ptr;
937 
938  for (ptr = old_module->module_interface->endpoint_interface; ptr; ptr = ptr->next) {
939  if (ptr->interface_name) {
940 
941  switch_core_session_hupall_endpoint(ptr, SWITCH_CAUSE_MANAGER_REQUEST);
942  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
943  ptr->interface_name);
944  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
945  switch_thread_rwlock_unlock(ptr->rwlock);
946  } else {
947  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
948  }
949 
950  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Endpoint '%s'\n", ptr->interface_name);
951  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
952  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "endpoint");
953  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
954  switch_event_fire(&event);
955  removed++;
956  }
957  switch_core_hash_delete(loadable_modules.endpoint_hash, ptr->interface_name);
958  }
959  }
960  }
961 
962  if (old_module->module_interface->codec_interface) {
963  const switch_codec_implementation_t *impl;
964  const switch_codec_interface_t *ptr;
965  switch_codec_node_t *node, *head, *last = NULL;
966 
967  for (ptr = old_module->module_interface->codec_interface; ptr; ptr = ptr->next) {
968  if (ptr->interface_name) {
969  unsigned load_interface = 1;
970  for (impl = ptr->implementations; impl; impl = impl->next) {
971  if (!impl->iananame) {
972  load_interface = 0;
973  break;
974  }
975  }
976  if (load_interface) {
977  for (impl = ptr->implementations; impl; impl = impl->next) {
978  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
979  "Deleting Codec %s %d %s %dhz %dms\n",
980  impl->iananame, impl->ianacode,
981  ptr->interface_name, impl->actual_samples_per_second, impl->microseconds_per_packet / 1000);
982  switch_core_session_hupall_matching_var("read_codec", impl->iananame, SWITCH_CAUSE_MANAGER_REQUEST);
983  switch_core_session_hupall_matching_var("write_codec", impl->iananame, SWITCH_CAUSE_MANAGER_REQUEST);
984 
985  if ((head = switch_core_hash_find(loadable_modules.codec_hash, impl->iananame))) {
986  for(node = head; node; node = node->next) {
987  if (!strcmp(node->interface_name, old_module->module_interface->module_name)) {
988  if (node == head) {
989  if ((node = node->next)) {
990  switch_core_hash_insert(loadable_modules.codec_hash, impl->iananame, (const void *) node);
991  } else {
992  switch_core_hash_delete(loadable_modules.codec_hash, impl->iananame);
993  }
994  } else {
995  if (last) {
996  last->next = node->next;
997  }
998  }
999  break;
1000  }
1001  last = node;
1002  }
1003  }
1004  }
1005  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1006  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "codec");
1007  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1008  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", old_module->module_interface->module_name);
1009  switch_event_fire(&event);
1010  removed++;
1011  }
1012  }
1013  }
1014  }
1015  }
1016 
1017  if (old_module->module_interface->dialplan_interface) {
1018  const switch_dialplan_interface_t *ptr;
1019 
1020  for (ptr = old_module->module_interface->dialplan_interface; ptr; ptr = ptr->next) {
1021  if (ptr->interface_name) {
1022  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Dialplan '%s'\n", ptr->interface_name);
1023  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1024  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "dialplan");
1025  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1026  switch_event_fire(&event);
1027  removed++;
1028  }
1029  switch_core_hash_delete(loadable_modules.dialplan_hash, ptr->interface_name);
1030  }
1031  }
1032  }
1033 
1034  if (old_module->module_interface->timer_interface) {
1035  const switch_timer_interface_t *ptr;
1036 
1037  for (ptr = old_module->module_interface->timer_interface; ptr; ptr = ptr->next) {
1038  if (ptr->interface_name) {
1039  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Timer '%s'\n", ptr->interface_name);
1040  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1041  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "timer");
1042  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1043  switch_event_fire(&event);
1044  removed++;
1045  }
1046  switch_core_hash_delete(loadable_modules.timer_hash, ptr->interface_name);
1047  }
1048  }
1049  }
1050 
1051  if (old_module->module_interface->application_interface) {
1052  const switch_application_interface_t *ptr;
1053  for (ptr = old_module->module_interface->application_interface; ptr; ptr = ptr->next) {
1054  if (ptr->interface_name) {
1055  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Application '%s'\n", ptr->interface_name);
1056  switch_core_session_hupall_matching_var(SWITCH_CURRENT_APPLICATION_VARIABLE, ptr->interface_name, SWITCH_CAUSE_MANAGER_REQUEST);
1057  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1058  ptr->interface_name);
1059  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1060  switch_thread_rwlock_unlock(ptr->rwlock);
1061  } else {
1062  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1063  }
1064 
1065  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1066  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
1067  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1068  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
1069  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
1070  switch_event_fire(&event);
1071  removed++;
1072  }
1073  switch_core_hash_delete(loadable_modules.application_hash, ptr->interface_name);
1074  }
1075  }
1076  }
1077 
1078  if (old_module->module_interface->chat_application_interface) {
1079  const switch_chat_application_interface_t *ptr;
1080  for (ptr = old_module->module_interface->chat_application_interface; ptr; ptr = ptr->next) {
1081  if (ptr->interface_name) {
1082  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Application '%s'\n", ptr->interface_name);
1083  switch_core_session_hupall_matching_var(SWITCH_CURRENT_APPLICATION_VARIABLE, ptr->interface_name, SWITCH_CAUSE_MANAGER_REQUEST);
1084  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1085  ptr->interface_name);
1086  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1087  switch_thread_rwlock_unlock(ptr->rwlock);
1088  } else {
1089  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1090  }
1091 
1092  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1093  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "application");
1094  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1095  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->short_desc));
1096  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
1097  switch_event_fire(&event);
1098  removed++;
1099  }
1100  switch_core_hash_delete(loadable_modules.chat_application_hash, ptr->interface_name);
1101  }
1102  }
1103  }
1104 
1105  if (old_module->module_interface->api_interface) {
1106  const switch_api_interface_t *ptr;
1107 
1108  for (ptr = old_module->module_interface->api_interface; ptr; ptr = ptr->next) {
1109  if (ptr->interface_name) {
1110  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting API Function '%s'\n", ptr->interface_name);
1111 
1112  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1113  ptr->interface_name);
1114 
1115  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1116  switch_thread_rwlock_unlock(ptr->rwlock);
1117  } else {
1118  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1119  }
1120 
1121 
1122  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1123  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "api");
1124  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1125  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
1126  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
1127  switch_event_fire(&event);
1128  removed++;
1129  }
1130  switch_core_hash_delete(loadable_modules.api_hash, ptr->interface_name);
1131  }
1132  }
1133  }
1134 
1135  if (old_module->module_interface->json_api_interface) {
1136  const switch_json_api_interface_t *ptr;
1137 
1138  for (ptr = old_module->module_interface->json_api_interface; ptr; ptr = ptr->next) {
1139  if (ptr->interface_name) {
1140  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting API Function '%s'\n", ptr->interface_name);
1141 
1142  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1143  ptr->interface_name);
1144 
1145  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1146  switch_thread_rwlock_unlock(ptr->rwlock);
1147  } else {
1148  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1149  }
1150 
1151 
1152  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1153  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "api");
1154  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1155  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "description", switch_str_nil(ptr->desc));
1156  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "syntax", switch_str_nil(ptr->syntax));
1157  switch_event_fire(&event);
1158  removed++;
1159  }
1160  switch_core_hash_delete(loadable_modules.json_api_hash, ptr->interface_name);
1161  }
1162  }
1163  }
1164 
1165  if (old_module->module_interface->file_interface) {
1166  const switch_file_interface_t *ptr;
1167  switch_file_node_t *node, *head, *last = NULL;
1168 
1169  for (ptr = old_module->module_interface->file_interface; ptr; ptr = ptr->next) {
1170  if (ptr->interface_name) {
1171  int i;
1172 
1173  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1174  ptr->interface_name);
1175 
1176  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1177  switch_thread_rwlock_unlock(ptr->rwlock);
1178  } else {
1179  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1180  }
1181 
1182  for (i = 0; ptr->extens[i]; i++) {
1183  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting File Format '%s'\n", ptr->extens[i]);
1184  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1185  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "file");
1186  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->extens[i]);
1187  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "module", old_module->module_interface->module_name);
1188  switch_event_fire(&event);
1189  removed++;
1190  }
1191 
1192  if ((head = switch_core_hash_find(loadable_modules.file_hash, ptr->extens[i]))) {
1193  for(node = head; node; node = node->next) {
1194  if (!strcmp(node->interface_name, old_module->module_interface->module_name)) {
1195  if (node == head) {
1196  if ((node = node->next)) {
1197  switch_core_hash_insert(loadable_modules.file_hash, ptr->extens[i], (const void *) node);
1198  } else {
1199  switch_core_hash_delete(loadable_modules.file_hash, ptr->extens[i]);
1200  }
1201  } else {
1202  if (last) {
1203  last->next = node->next;
1204  }
1205  }
1206  break;
1207  }
1208  last = node;
1209  }
1210  }
1211  }
1212  }
1213  }
1214  }
1215 
1216  if (old_module->module_interface->speech_interface) {
1217  const switch_speech_interface_t *ptr;
1218 
1219  for (ptr = old_module->module_interface->speech_interface; ptr; ptr = ptr->next) {
1220 
1221  if (ptr->interface_name) {
1222 
1223  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1224  ptr->interface_name);
1225 
1226  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1227  switch_thread_rwlock_unlock(ptr->rwlock);
1228  } else {
1229  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1230  }
1231 
1232  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Speech interface '%s'\n", ptr->interface_name);
1233  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1234  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "speech");
1235  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1236  switch_event_fire(&event);
1237  removed++;
1238  }
1239  switch_core_hash_delete(loadable_modules.speech_hash, ptr->interface_name);
1240  }
1241  }
1242  }
1243 
1244  if (old_module->module_interface->asr_interface) {
1245  const switch_asr_interface_t *ptr;
1246 
1247  for (ptr = old_module->module_interface->asr_interface; ptr; ptr = ptr->next) {
1248  if (ptr->interface_name) {
1249 
1250  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1251  ptr->interface_name);
1252 
1253  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1254  switch_thread_rwlock_unlock(ptr->rwlock);
1255  } else {
1256  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1257  }
1258 
1259  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Asr interface '%s'\n", ptr->interface_name);
1260  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1261  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "asr");
1262  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1263  switch_event_fire(&event);
1264  removed++;
1265  }
1266  switch_core_hash_delete(loadable_modules.asr_hash, ptr->interface_name);
1267  }
1268  }
1269  }
1270 
1271  if (old_module->module_interface->directory_interface) {
1272  const switch_directory_interface_t *ptr;
1273 
1274  for (ptr = old_module->module_interface->directory_interface; ptr; ptr = ptr->next) {
1275  if (ptr->interface_name) {
1276 
1277  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1278  ptr->interface_name);
1279 
1280  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1281  switch_thread_rwlock_unlock(ptr->rwlock);
1282  } else {
1283  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1284  }
1285 
1286  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Directory interface '%s'\n", ptr->interface_name);
1287  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1288  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "directory");
1289  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1290  switch_event_fire(&event);
1291  removed++;
1292  }
1293  switch_core_hash_delete(loadable_modules.directory_hash, ptr->interface_name);
1294  }
1295  }
1296  }
1297 
1298 
1299  if (old_module->module_interface->chat_interface) {
1300  const switch_chat_interface_t *ptr;
1301 
1302  for (ptr = old_module->module_interface->chat_interface; ptr; ptr = ptr->next) {
1303  if (ptr->interface_name) {
1304  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1305  ptr->interface_name);
1306 
1307  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1308  switch_thread_rwlock_unlock(ptr->rwlock);
1309  } else {
1310  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1311  }
1312 
1313  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Chat interface '%s'\n", ptr->interface_name);
1314  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1315  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "chat");
1316  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1317  switch_event_fire(&event);
1318  removed++;
1319  }
1320  switch_core_hash_delete(loadable_modules.chat_hash, ptr->interface_name);
1321  }
1322  }
1323  }
1324 
1325  if (old_module->module_interface->say_interface) {
1326  const switch_say_interface_t *ptr;
1327 
1328  for (ptr = old_module->module_interface->say_interface; ptr; ptr = ptr->next) {
1329  if (ptr->interface_name) {
1330  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write lock interface '%s' to wait for existing references.\n",
1331  ptr->interface_name);
1332 
1333  if (switch_thread_rwlock_trywrlock_timeout(ptr->rwlock, 10) == SWITCH_STATUS_SUCCESS) {
1334  switch_thread_rwlock_unlock(ptr->rwlock);
1335  } else {
1336  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up on '%s' waiting for existing references.\n", ptr->interface_name);
1337  }
1338  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deleting Say interface '%s'\n", ptr->interface_name);
1339  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1340  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "say");
1341  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1342  switch_event_fire(&event);
1343  removed++;
1344  }
1345  switch_core_hash_delete(loadable_modules.say_hash, ptr->interface_name);
1346  }
1347  }
1348  }
1349 
1350  if (old_module->module_interface->management_interface) {
1351  const switch_management_interface_t *ptr;
1352 
1353  for (ptr = old_module->module_interface->management_interface; ptr; ptr = ptr->next) {
1354  if (ptr->relative_oid) {
1355  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
1356  "Deleting Management interface '%s' OID[%s.%s]\n", old_module->key, FREESWITCH_OID_PREFIX, ptr->relative_oid);
1357  switch_core_hash_delete(loadable_modules.management_hash, ptr->relative_oid);
1358  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1359  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "management");
1360  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->relative_oid);
1361  switch_event_fire(&event);
1362  removed++;
1363  }
1364  }
1365  }
1366  }
1367 
1368  if (old_module->module_interface->limit_interface) {
1369  const switch_limit_interface_t *ptr;
1370 
1371  for (ptr = old_module->module_interface->limit_interface; ptr; ptr = ptr->next) {
1372  if (ptr->interface_name) {
1373  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
1374  "Deleting Limit interface '%s'\n", ptr->interface_name);
1375  switch_core_hash_delete(loadable_modules.limit_hash, ptr->interface_name);
1376  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1377  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "limit");
1378  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", ptr->interface_name);
1379  switch_event_fire(&event);
1380  removed++;
1381  }
1382  }
1383  }
1384  }
1385 
1386  if (!removed) {
1387  if (switch_event_create(&event, SWITCH_EVENT_MODULE_UNLOAD) == SWITCH_STATUS_SUCCESS) {
1388  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "generic");
1389  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "name", old_module->key);
1390  switch_event_fire(&event);
1391  removed++;
1392  }
1393  }
1394  switch_mutex_unlock(loadable_modules.mutex);
1395 
1396  return SWITCH_STATUS_SUCCESS;
1397 
1398 }
1399 
1400 
1401 static switch_status_t switch_loadable_module_load_file(char *path, char *filename, switch_bool_t global, switch_loadable_module_t **new_module)
1402 {
1403  switch_loadable_module_t *module = NULL;
1404  switch_dso_lib_t dso = NULL;
1405  apr_status_t status = SWITCH_STATUS_SUCCESS;
1406  switch_loadable_module_function_table_t *interface_struct_handle = NULL;
1407  switch_loadable_module_function_table_t *mod_interface_functions = NULL;
1408  char *struct_name = NULL;
1409  switch_module_load_t load_func_ptr = NULL;
1410  int loading = 1;
1411  switch_loadable_module_interface_t *module_interface = NULL;
1412  char *derr = NULL;
1413  const char *err = NULL;
1414  switch_memory_pool_t *pool = NULL;
1415  switch_bool_t load_global = global;
1416 
1417  switch_assert(path != NULL);
1418 
1419  switch_core_new_memory_pool(&pool);
1420  *new_module = NULL;
1421 
1422  struct_name = switch_core_sprintf(pool, "%s_module_interface", filename);
1423 
1424 #ifdef WIN32
1425  dso = switch_dso_open("FreeSwitch.dll", load_global, &derr);
1426 #elif defined (MACOSX) || defined(DARWIN)
1427  {
1428  char *lib_path = switch_mprintf("%s/libfreeswitch.dylib", SWITCH_GLOBAL_dirs.lib_dir);
1429  dso = switch_dso_open(lib_path, load_global, &derr);
1430  switch_safe_free(lib_path);
1431  }
1432 #else
1433  dso = switch_dso_open(NULL, load_global, &derr);
1434 #endif
1435  if (!derr && dso) {
1436  interface_struct_handle = switch_dso_data_sym(dso, struct_name, &derr);
1437  }
1438 
1439  switch_safe_free(derr);
1440 
1441  if (!interface_struct_handle) {
1442  if (dso) switch_dso_destroy(&dso);
1443  dso = switch_dso_open(path, load_global, &derr);
1444  }
1445 
1446  while (loading) {
1447  if (derr) {
1448  err = derr;
1449  break;
1450  }
1451 
1452  if (!interface_struct_handle) {
1453  interface_struct_handle = switch_dso_data_sym(dso, struct_name, &derr);
1454  }
1455 
1456  if (derr) {
1457  err = derr;
1458  break;
1459  }
1460 
1461  if (interface_struct_handle && interface_struct_handle->switch_api_version != SWITCH_API_VERSION) {
1462  err = "Trying to load an out of date module, please rebuild the module.";
1463  break;
1464  }
1465 
1466  if (!load_global && interface_struct_handle && switch_test_flag(interface_struct_handle, SMODF_GLOBAL_SYMBOLS)) {
1467  load_global = SWITCH_TRUE;
1468  switch_dso_destroy(&dso);
1469  interface_struct_handle = NULL;
1470  dso = switch_dso_open(path, load_global, &derr);
1471  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Loading module with global namespace at request of module\n");
1472  continue;
1473  }
1474 
1475  if (interface_struct_handle) {
1476  mod_interface_functions = interface_struct_handle;
1477  load_func_ptr = mod_interface_functions->load;
1478  }
1479 
1480  if (load_func_ptr == NULL) {
1481  err = "Cannot locate symbol 'switch_module_load' please make sure this is a valid module.";
1482  break;
1483  }
1484 
1485  status = load_func_ptr(&module_interface, pool);
1486 
1487  if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_NOUNLOAD) {
1488  err = "Module load routine returned an error";
1489  module_interface = NULL;
1490  break;
1491  }
1492 
1493  if (!module_interface) {
1494  err = "Module failed to initialize its module_interface. Is this a valid module?";
1495  break;
1496  }
1497 
1498  if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
1499  err = "Could not allocate memory\n";
1500  abort();
1501  }
1502 
1503  if (status == SWITCH_STATUS_NOUNLOAD) {
1504  module->perm++;
1505  }
1506 
1507  loading = 0;
1508  }
1509 
1510 
1511  if (err) {
1512 
1513  if (dso) {
1514  switch_dso_destroy(&dso);
1515  }
1516 
1517  if (pool) {
1518  switch_core_destroy_memory_pool(&pool);
1519  }
1520  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error Loading module %s\n**%s**\n", path, err);
1521  switch_safe_free(derr);
1522  return SWITCH_STATUS_GENERR;
1523  }
1524 
1525  module->pool = pool;
1526  module->filename = switch_core_strdup(module->pool, path);
1527  module->module_interface = module_interface;
1528  module->switch_module_load = load_func_ptr;
1529 
1530  if (mod_interface_functions) {
1531  module->switch_module_shutdown = mod_interface_functions->shutdown;
1532  module->switch_module_runtime = mod_interface_functions->runtime;
1533  }
1534 
1535  module->lib = dso;
1536 
1537  *new_module = module;
1538  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Successfully Loaded [%s]\n", module_interface->module_name);
1539 
1540  switch_core_set_signal_handlers();
1541 
1542  return SWITCH_STATUS_SUCCESS;
1543 
1544 }
1545 SWITCH_DECLARE(switch_status_t) switch_loadable_module_load_module(char *dir, char *fname, switch_bool_t runtime, const char **err)
1546 {
1547  return switch_loadable_module_load_module_ex(dir, fname, runtime, SWITCH_FALSE, err);
1548 }
1549 
1550 static switch_status_t switch_loadable_module_load_module_ex(char *dir, char *fname, switch_bool_t runtime, switch_bool_t global, const char **err)
1551 {
1552  switch_size_t len = 0;
1553  char *path;
1554  char *file, *dot;
1555  switch_loadable_module_t *new_module = NULL;
1556  switch_status_t status = SWITCH_STATUS_SUCCESS;
1557 
1558 #ifdef WIN32
1559  const char *ext = ".dll";
1560 #else
1561  const char *ext = ".so";
1562 #endif
1563 
1564  *err = "";
1565 
1566  if ((file = switch_core_strdup(loadable_modules.pool, fname)) == 0) {
1567  *err = "allocation error";
1568  return SWITCH_STATUS_FALSE;
1569  }
1570 
1571  if (switch_is_file_path(file)) {
1572  path = switch_core_strdup(loadable_modules.pool, file);
1573  file = (char *) switch_cut_path(file);
1574  if ((dot = strchr(file, '.'))) {
1575  *dot = '\0';
1576  }
1577  } else {
1578  if ((dot = strchr(file, '.'))) {
1579  *dot = '\0';
1580  }
1581  len = strlen(dir);
1582  len += strlen(file);
1583  len += 8;
1584  path = (char *) switch_core_alloc(loadable_modules.pool, len);
1585  switch_snprintf(path, len, "%s%s%s%s", dir, SWITCH_PATH_SEPARATOR, file, ext);
1586  }
1587 
1588 
1589  if (switch_core_hash_find_locked(loadable_modules.module_hash, file, loadable_modules.mutex)) {
1590  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Module %s Already Loaded!\n", file);
1591  *err = "Module already loaded";
1592  status = SWITCH_STATUS_FALSE;
1593  } else if ((status = switch_loadable_module_load_file(path, file, global, &new_module)) == SWITCH_STATUS_SUCCESS) {
1594  if ((status = switch_loadable_module_process(file, new_module)) == SWITCH_STATUS_SUCCESS && runtime) {
1595  if (new_module->switch_module_runtime) {
1596  new_module->thread = switch_core_launch_thread(switch_loadable_module_exec, new_module, new_module->pool);
1597  }
1598  } else if (status != SWITCH_STATUS_SUCCESS) {
1599  *err = "module load routine returned an error";
1600  }
1601  } else {
1602  *err = "module load file routine returned an error";
1603  }
1604 
1605 
1606  return status;
1607 
1608 }
1609 
1610 SWITCH_DECLARE(switch_status_t) switch_loadable_module_exists(const char *mod)
1611 {
1612  switch_status_t status;
1613 
1614  if (zstr(mod)) {
1615  return SWITCH_STATUS_FALSE;
1616  }
1617 
1618  switch_mutex_lock(loadable_modules.mutex);
1619  if (switch_core_hash_find(loadable_modules.module_hash, mod)) {
1620  status = SWITCH_STATUS_SUCCESS;
1621  } else {
1622  status = SWITCH_STATUS_FALSE;
1623  }
1624  switch_mutex_unlock(loadable_modules.mutex);
1625 
1626  return status;
1627 }
1628 
1629 SWITCH_DECLARE(switch_status_t) switch_loadable_module_unload_module(char *dir, char *fname, switch_bool_t force, const char **err)
1630 {
1631  switch_loadable_module_t *module = NULL;
1632  switch_status_t status = SWITCH_STATUS_SUCCESS;
1633 
1634  if (force) {
1635  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Spin the barrel and pull the trigger.......!\n");
1636  }
1637 
1638  switch_mutex_lock(loadable_modules.mutex);
1639  if ((module = switch_core_hash_find(loadable_modules.module_hash, fname))) {
1640  if (module->perm) {
1641  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Module is not unloadable.\n");
1642  *err = "Module is not unloadable";
1643  status = SWITCH_STATUS_NOUNLOAD;
1644  goto unlock;
1645  } else {
1646  /* Prevent anything from using the module while it's shutting down */
1647  switch_core_hash_delete(loadable_modules.module_hash, fname);
1648  switch_mutex_unlock(loadable_modules.mutex);
1649  if ((status = do_shutdown(module, SWITCH_TRUE, SWITCH_TRUE, !force, err)) != SWITCH_STATUS_SUCCESS) {
1650  /* Something went wrong in the module's shutdown function, add it again */
1651  switch_core_hash_insert_locked(loadable_modules.module_hash, fname, module, loadable_modules.mutex);
1652  }
1653  goto end;
1654  }
1655  } else {
1656  *err = "No such module!";
1657  status = SWITCH_STATUS_FALSE;
1658  }
1659 unlock:
1660  switch_mutex_unlock(loadable_modules.mutex);
1661  end:
1662  if (force) {
1663  switch_yield(1000000);
1664  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "PHEW!\n");
1665  }
1666 
1667  return status;
1668 
1669 }
1670 
1671 SWITCH_DECLARE(switch_status_t) switch_loadable_module_enumerate_available(const char *dir_path, switch_modulename_callback_func_t callback, void *user_data)
1672 {
1673  switch_dir_t *dir = NULL;
1674  switch_status_t status;
1675  char buffer[256];
1676  const char *fname;
1677  const char *fname_ext;
1678  char *fname_base;
1679 
1680 #ifdef WIN32
1681  const char *ext = ".dll";
1682 #else
1683  const char *ext = ".so";
1684 #endif
1685 
1686  if ((status = switch_dir_open(&dir, dir_path, loadable_modules.pool)) != SWITCH_STATUS_SUCCESS) {
1687  return status;
1688  }
1689 
1690  while((fname = switch_dir_next_file(dir, buffer, sizeof(buffer)))) {
1691  if ((fname_ext = strrchr(fname, '.'))) {
1692  if (!strcmp(fname_ext, ext)) {
1693  if (!(fname_base = switch_mprintf("%.*s", (int)(fname_ext-fname), fname))) {
1694  status = SWITCH_STATUS_GENERR;
1695  goto end;
1696  }
1697  callback(user_data, fname_base);
1698  switch_safe_free(fname_base)
1699  }
1700  }
1701  }
1702 
1703 
1704  end:
1705  switch_dir_close(dir);
1706  return status;
1707 }
1708 
1709 SWITCH_DECLARE(switch_status_t) switch_loadable_module_enumerate_loaded(switch_modulename_callback_func_t callback, void *user_data)
1710 {
1711  switch_hash_index_t *hi;
1712  void *val;
1713  switch_loadable_module_t *module;
1714 
1715  switch_mutex_lock(loadable_modules.mutex);
1716  for (hi = switch_core_hash_first(loadable_modules.module_hash); hi; hi = switch_core_hash_next(&hi)) {
1717  switch_core_hash_this(hi, NULL, NULL, &val);
1718  module = (switch_loadable_module_t *) val;
1719 
1720  callback(user_data, module->module_interface->module_name);
1721  }
1722  switch_mutex_unlock(loadable_modules.mutex);
1723 
1724  return SWITCH_STATUS_SUCCESS;
1725 }
1726 
1727 SWITCH_DECLARE(switch_status_t) switch_loadable_module_build_dynamic(char *filename,
1728  switch_module_load_t switch_module_load,
1729  switch_module_runtime_t switch_module_runtime,
1730  switch_module_shutdown_t switch_module_shutdown, switch_bool_t runtime)
1731 {
1732  switch_loadable_module_t *module = NULL;
1733  switch_module_load_t load_func_ptr = NULL;
1734  int loading = 1;
1735  const char *err = NULL;
1736  switch_loadable_module_interface_t *module_interface = NULL;
1737  switch_memory_pool_t *pool;
1738 
1739 
1740  if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
1741  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
1742  abort();
1743  }
1744 
1745  if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
1746  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Couldn't allocate memory\n");
1747  abort();
1748  }
1749 
1750 
1751 
1752  while (loading) {
1753  switch_status_t status;
1754  load_func_ptr = (switch_module_load_t) switch_module_load;
1755 
1756  if (load_func_ptr == NULL) {
1757  err = "Cannot Load";
1758  break;
1759  }
1760 
1761  status = load_func_ptr(&module_interface, pool);
1762 
1763  if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_NOUNLOAD) {
1764  err = "Module load routine returned an error";
1765  module_interface = NULL;
1766  break;
1767  }
1768 
1769  if ((module = switch_core_alloc(pool, sizeof(switch_loadable_module_t))) == 0) {
1770  err = "Could not allocate memory\n";
1771  abort();
1772  }
1773 
1774  if (status == SWITCH_STATUS_NOUNLOAD) {
1775  module->perm++;
1776  }
1777 
1778  loading = 0;
1779  }
1780 
1781  if (err) {
1782  switch_core_destroy_memory_pool(&pool);
1783  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error Loading module %s\n**%s**\n", filename, err);
1784  return SWITCH_STATUS_GENERR;
1785  }
1786 
1787  module->pool = pool;
1788  module->filename = switch_core_strdup(module->pool, filename);
1789  module->module_interface = module_interface;
1790  module->switch_module_load = load_func_ptr;
1791 
1792  if (switch_module_shutdown) {
1793  module->switch_module_shutdown = switch_module_shutdown;
1794  }
1795  if (switch_module_runtime) {
1796  module->switch_module_runtime = switch_module_runtime;
1797  }
1798  if (runtime && module->switch_module_runtime) {
1799  module->thread = switch_core_launch_thread(switch_loadable_module_exec, module, module->pool);
1800  }
1801  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Successfully Loaded [%s]\n", module_interface->module_name);
1802  return switch_loadable_module_process((char *) module->filename, module);
1803 }
1804 
1805 #ifdef WIN32
1806 static void switch_loadable_module_path_init()
1807 {
1808  char *path = NULL, *working = NULL;
1809  apr_dir_t *perl_dir_handle = NULL;
1810 
1811  apr_env_get(&path, "path", loadable_modules.pool);
1812  apr_filepath_get(&working, APR_FILEPATH_NATIVE, loadable_modules.pool);
1813 
1814  if (apr_dir_open(&perl_dir_handle, ".\\perl", loadable_modules.pool) == APR_SUCCESS) {
1815  apr_dir_close(perl_dir_handle);
1816  apr_env_set("path", apr_pstrcat(loadable_modules.pool, path, ";", working, "\\perl", NULL), loadable_modules.pool);
1817  }
1818 }
1819 #endif
1820 
1821 SWITCH_DECLARE(switch_status_t) switch_loadable_module_init(switch_bool_t autoload)
1822 {
1823 
1824  apr_finfo_t finfo = { 0 };
1825  apr_dir_t *module_dir_handle = NULL;
1826  apr_int32_t finfo_flags = APR_FINFO_DIRENT | APR_FINFO_TYPE | APR_FINFO_NAME;
1827  char *cf = "modules.conf";
1828  char *pcf = "post_load_modules.conf";
1829  switch_xml_t cfg, xml;
1830  unsigned char all = 0;
1831  unsigned int count = 0;
1832  const char *err;
1833 
1834 
1835 #ifdef WIN32
1836  const char *ext = ".dll";
1837  const char *EXT = ".DLL";
1838 #elif defined (MACOSX) || defined (DARWIN)
1839  const char *ext = ".dylib";
1840  const char *EXT = ".DYLIB";
1841 #else
1842  const char *ext = ".so";
1843  const char *EXT = ".SO";
1844 #endif
1845 
1846  memset(&loadable_modules, 0, sizeof(loadable_modules));
1847  switch_core_new_memory_pool(&loadable_modules.pool);
1848 
1849 
1850 #ifdef WIN32
1851  switch_loadable_module_path_init();
1852 #endif
1853 
1854  switch_core_hash_init(&loadable_modules.module_hash);
1855  switch_core_hash_init_nocase(&loadable_modules.endpoint_hash);
1856  switch_core_hash_init_nocase(&loadable_modules.codec_hash);
1857  switch_core_hash_init_nocase(&loadable_modules.timer_hash);
1858  switch_core_hash_init_nocase(&loadable_modules.application_hash);
1859  switch_core_hash_init_nocase(&loadable_modules.chat_application_hash);
1860  switch_core_hash_init_nocase(&loadable_modules.api_hash);
1861  switch_core_hash_init_nocase(&loadable_modules.json_api_hash);
1862  switch_core_hash_init(&loadable_modules.file_hash);
1863  switch_core_hash_init_nocase(&loadable_modules.speech_hash);
1864  switch_core_hash_init_nocase(&loadable_modules.asr_hash);
1865  switch_core_hash_init_nocase(&loadable_modules.directory_hash);
1866  switch_core_hash_init_nocase(&loadable_modules.chat_hash);
1867  switch_core_hash_init_nocase(&loadable_modules.say_hash);
1868  switch_core_hash_init_nocase(&loadable_modules.management_hash);
1869  switch_core_hash_init_nocase(&loadable_modules.limit_hash);
1870  switch_core_hash_init_nocase(&loadable_modules.dialplan_hash);
1871  switch_core_hash_init(&loadable_modules.secondary_recover_hash);
1872  switch_mutex_init(&loadable_modules.mutex, SWITCH_MUTEX_NESTED, loadable_modules.pool);
1873 
1874  if (!autoload) return SWITCH_STATUS_SUCCESS;
1875 
1876  switch_loadable_module_load_module("", "CORE_SOFTTIMER_MODULE", SWITCH_FALSE, &err);
1877  switch_loadable_module_load_module("", "CORE_PCM_MODULE", SWITCH_FALSE, &err);
1878  switch_loadable_module_load_module("", "CORE_SPEEX_MODULE", SWITCH_FALSE, &err);
1879 #ifdef SWITCH_HAVE_YUV
1880 #ifdef SWITCH_HAVE_VPX
1881  switch_loadable_module_load_module("", "CORE_VPX_MODULE", SWITCH_FALSE, &err);
1882 #endif
1883 #endif
1884 
1885  if ((xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
1886  switch_xml_t mods, ld;
1887  if ((mods = switch_xml_child(cfg, "modules"))) {
1888  for (ld = switch_xml_child(mods, "load"); ld; ld = ld->next) {
1889  switch_bool_t global = SWITCH_FALSE;
1890  const char *val = switch_xml_attr_soft(ld, "module");
1891  const char *path = switch_xml_attr_soft(ld, "path");
1892  const char *critical = switch_xml_attr_soft(ld, "critical");
1893  const char *sglobal = switch_xml_attr_soft(ld, "global");
1894  if (zstr(val) || (strchr(val, '.') && !strstr(val, ext) && !strstr(val, EXT))) {
1895  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Invalid extension for %s\n", val);
1896  continue;
1897  }
1898  global = switch_true(sglobal);
1899 
1900  if (path && zstr(path)) {
1901  path = SWITCH_GLOBAL_dirs.mod_dir;
1902  }
1903  if (switch_loadable_module_load_module_ex((char *) path, (char *) val, SWITCH_FALSE, global, &err) == SWITCH_STATUS_GENERR) {
1904  if (critical && switch_true(critical)) {
1905  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to load critical module '%s', abort()\n", val);
1906  abort();
1907  }
1908  }
1909  count++;
1910  }
1911  }
1912  switch_xml_free(xml);
1913 
1914  } else {
1915  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "open of %s failed\n", cf);
1916  }
1917 
1918  if ((xml = switch_xml_open_cfg(pcf, &cfg, NULL))) {
1919  switch_xml_t mods, ld;
1920 
1921  if ((mods = switch_xml_child(cfg, "modules"))) {
1922  for (ld = switch_xml_child(mods, "load"); ld; ld = ld->next) {
1923  switch_bool_t global = SWITCH_FALSE;
1924  const char *val = switch_xml_attr_soft(ld, "module");
1925  const char *path = switch_xml_attr_soft(ld, "path");
1926  const char *sglobal = switch_xml_attr_soft(ld, "global");
1927  if (zstr(val) || (strchr(val, '.') && !strstr(val, ext) && !strstr(val, EXT))) {
1928  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Invalid extension for %s\n", val);
1929  continue;
1930  }
1931  global = switch_true(sglobal);
1932 
1933  if (path && zstr(path)) {
1934  path = SWITCH_GLOBAL_dirs.mod_dir;
1935  }
1936  switch_loadable_module_load_module_ex((char *) path, (char *) val, SWITCH_FALSE, global, &err);
1937  count++;
1938  }
1939  }
1940  switch_xml_free(xml);
1941 
1942  } else {
1943  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "open of %s failed\n", pcf);
1944  }
1945 
1946  if (!count) {
1947  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "No modules loaded, assuming 'load all'\n");
1948  all = 1;
1949  }
1950 
1951  if (all) {
1952  if (apr_dir_open(&module_dir_handle, SWITCH_GLOBAL_dirs.mod_dir, loadable_modules.pool) != APR_SUCCESS) {
1953  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can't open directory: %s\n", SWITCH_GLOBAL_dirs.mod_dir);
1954  return SWITCH_STATUS_GENERR;
1955  }
1956 
1957  while (apr_dir_read(&finfo, finfo_flags, module_dir_handle) == APR_SUCCESS) {
1958  const char *fname = finfo.fname;
1959 
1960  if (finfo.filetype != APR_REG) {
1961  continue;
1962  }
1963 
1964  if (!fname) {
1965  fname = finfo.name;
1966  }
1967 
1968  if (!fname) {
1969  continue;
1970  }
1971 
1972  if (zstr(fname) || (!strstr(fname, ext) && !strstr(fname, EXT))) {
1973  continue;
1974  }
1975 
1976  switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) fname, SWITCH_FALSE, &err);
1977  }
1978  apr_dir_close(module_dir_handle);
1979  }
1980 
1981  switch_loadable_module_runtime();
1982 
1983  memset(&chat_globals, 0, sizeof(chat_globals));
1984  chat_globals.running = 1;
1985  chat_globals.pool = loadable_modules.pool;
1986  switch_mutex_init(&chat_globals.mutex, SWITCH_MUTEX_NESTED, chat_globals.pool);
1987 
1988  chat_thread_start(1);
1989 
1990  return SWITCH_STATUS_SUCCESS;
1991 }
1992 
1993 static switch_status_t do_shutdown(switch_loadable_module_t *module, switch_bool_t shutdown, switch_bool_t unload, switch_bool_t fail_if_busy,
1994  const char **err)
1995 {
1996  int32_t flags = switch_core_flags();
1997  switch_assert(module != NULL);
1998 
1999  if (fail_if_busy && module->module_interface->rwlock && switch_thread_rwlock_trywrlock(module->module_interface->rwlock) != SWITCH_STATUS_SUCCESS) {
2000  if (err) {
2001  *err = "Module in use.";
2002  }
2003  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Module %s is in use, cannot unload.\n", module->module_interface->module_name);
2004  return SWITCH_STATUS_FALSE;
2005  }
2006 
2007  module->shutting_down = SWITCH_TRUE;
2008 
2009  if (shutdown) {
2010  switch_loadable_module_unprocess(module);
2011  if (module->switch_module_shutdown) {
2012  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping: %s\n", module->module_interface->module_name);
2013  module->status = module->switch_module_shutdown();
2014  } else {
2015  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s has no shutdown routine\n", module->module_interface->module_name);
2016  }
2017  }
2018 
2019  if (fail_if_busy && module->module_interface->rwlock) {
2020  switch_thread_rwlock_unlock(module->module_interface->rwlock);
2021  }
2022 
2023  if (unload && module->status != SWITCH_STATUS_NOUNLOAD && !(flags & SCF_VG)) {
2024  switch_memory_pool_t *pool;
2025  switch_status_t st;
2026 
2027  if (module->thread) {
2028  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s stopping runtime thread.\n", module->module_interface->module_name);
2029  switch_thread_join(&st, module->thread);
2030  }
2031 
2032  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s unloaded.\n", module->module_interface->module_name);
2033  switch_dso_destroy(&module->lib);
2034  if ((pool = module->pool)) {
2035  module = NULL;
2036  switch_core_destroy_memory_pool(&pool);
2037  }
2038  }
2039 
2040  return SWITCH_STATUS_SUCCESS;
2041 
2042 }
2043 
2044 SWITCH_DECLARE(void) switch_loadable_module_shutdown(void)
2045 {
2046  switch_hash_index_t *hi;
2047  void *val;
2048  switch_loadable_module_t *module;
2049  int i;
2050 
2051  if (!loadable_modules.module_hash) {
2052  return;
2053  }
2054 
2055  chat_globals.running = 0;
2056 
2057  for (i = 0; i < chat_globals.msg_queue_len; i++) {
2058  switch_queue_push(chat_globals.msg_queue[i], NULL);
2059  }
2060 
2061  for (i = 0; i < chat_globals.msg_queue_len; i++) {
2062  switch_status_t st;
2063  switch_thread_join(&st, chat_globals.msg_queue_thread[i]);
2064  }
2065 
2066 
2067  for (hi = switch_core_hash_first(loadable_modules.module_hash); hi; hi = switch_core_hash_next(&hi)) {
2068  switch_core_hash_this(hi, NULL, NULL, &val);
2069  module = (switch_loadable_module_t *) val;
2070  if (!module->perm) {
2071  do_shutdown(module, SWITCH_TRUE, SWITCH_FALSE, SWITCH_FALSE, NULL);
2072  }
2073  }
2074 
2075  switch_yield(1000000);
2076 
2077  for (hi = switch_core_hash_first(loadable_modules.module_hash); hi; hi = switch_core_hash_next(&hi)) {
2078  switch_core_hash_this(hi, NULL, NULL, &val);
2079  module = (switch_loadable_module_t *) val;
2080  if (!module->perm) {
2081  do_shutdown(module, SWITCH_FALSE, SWITCH_TRUE, SWITCH_FALSE, NULL);
2082  }
2083  }
2084 
2085  switch_core_hash_destroy(&loadable_modules.module_hash);
2086  switch_core_hash_destroy(&loadable_modules.endpoint_hash);
2087  switch_core_hash_destroy(&loadable_modules.codec_hash);
2088  switch_core_hash_destroy(&loadable_modules.timer_hash);
2089  switch_core_hash_destroy(&loadable_modules.application_hash);
2090  switch_core_hash_destroy(&loadable_modules.chat_application_hash);
2091  switch_core_hash_destroy(&loadable_modules.api_hash);
2092  switch_core_hash_destroy(&loadable_modules.json_api_hash);
2093  switch_core_hash_destroy(&loadable_modules.file_hash);
2094  switch_core_hash_destroy(&loadable_modules.speech_hash);
2095  switch_core_hash_destroy(&loadable_modules.asr_hash);
2096  switch_core_hash_destroy(&loadable_modules.directory_hash);
2097  switch_core_hash_destroy(&loadable_modules.chat_hash);
2098  switch_core_hash_destroy(&loadable_modules.say_hash);
2099  switch_core_hash_destroy(&loadable_modules.management_hash);
2100  switch_core_hash_destroy(&loadable_modules.limit_hash);
2101  switch_core_hash_destroy(&loadable_modules.dialplan_hash);
2102 
2103  switch_core_destroy_memory_pool(&loadable_modules.pool);
2104 }
2105 
2106 SWITCH_DECLARE(switch_endpoint_interface_t *) switch_loadable_module_get_endpoint_interface(const char *name)
2107 {
2108  switch_endpoint_interface_t *ptr;
2109 
2110  switch_mutex_lock(loadable_modules.mutex);
2111  ptr = switch_core_hash_find(loadable_modules.endpoint_hash, name);
2112  if (ptr) {
2113  PROTECT_INTERFACE(ptr);
2114  }
2115  switch_mutex_unlock(loadable_modules.mutex);
2116 
2117 
2118  return ptr;
2119 }
2120 
2121 SWITCH_DECLARE(switch_file_interface_t *) switch_loadable_module_get_file_interface(const char *name, const char *modname)
2122 {
2123  switch_file_interface_t *i = NULL;
2124  switch_file_node_t *node, *head;
2125 
2126  switch_mutex_lock(loadable_modules.mutex);
2127 
2128  if ((head = switch_core_hash_find(loadable_modules.file_hash, name))) {
2129  if (modname) {
2130  for (node = head; node; node = node->next) {
2131  if (!strcasecmp(node->interface_name, modname)) {
2132  i = (switch_file_interface_t *) node->ptr;
2133  break;
2134  }
2135  }
2136  } else {
2137  i = (switch_file_interface_t *) head->ptr;
2138  }
2139  }
2140 
2141  switch_mutex_unlock(loadable_modules.mutex);
2142 
2143  if (i) PROTECT_INTERFACE(i);
2144 
2145  return i;
2146 }
2147 
2148 SWITCH_DECLARE(switch_codec_interface_t *) switch_loadable_module_get_codec_interface(const char *name, const char *modname)
2149 {
2150  switch_codec_interface_t *codec = NULL;
2151  switch_codec_node_t *node, *head;
2152 
2153  switch_mutex_lock(loadable_modules.mutex);
2154 
2155  if ((head = switch_core_hash_find(loadable_modules.codec_hash, name))) {
2156  if (modname) {
2157  for (node = head; node; node = node->next) {
2158  if (!strcasecmp(node->interface_name, modname)) {
2159  codec = (switch_codec_interface_t *) node->ptr;
2160  break;
2161  }
2162  }
2163  } else {
2164  codec = (switch_codec_interface_t *) head->ptr;
2165  }
2166  }
2167 
2168  switch_mutex_unlock(loadable_modules.mutex);
2169 
2170  if (codec) {
2171  PROTECT_INTERFACE(codec);
2172  }
2173 
2174  return codec;
2175 }
2176 
2177 #define HASH_FUNC(_kind_) SWITCH_DECLARE(switch_##_kind_##_interface_t *) switch_loadable_module_get_##_kind_##_interface(const char *name) \
2178  { \
2179  switch_##_kind_##_interface_t *i = NULL; \
2180  if (loadable_modules._kind_##_hash && (i = switch_core_hash_find_locked(loadable_modules._kind_##_hash, name, loadable_modules.mutex))) { \
2181  PROTECT_INTERFACE(i); \
2182  } \
2183  return i; \
2184  }
2185 
2186 HASH_FUNC(dialplan)
2187 HASH_FUNC(timer)
2188 HASH_FUNC(application)
2189 HASH_FUNC(chat_application)
2190 HASH_FUNC(api)
2191 HASH_FUNC(json_api)
2192 HASH_FUNC(speech)
2193 HASH_FUNC(asr)
2194 HASH_FUNC(directory)
2195 HASH_FUNC(chat)
2196 HASH_FUNC(limit)
2197 
2198 
2199 SWITCH_DECLARE(switch_say_interface_t *) switch_loadable_module_get_say_interface(const char *name)
2200 {
2201  return switch_core_hash_find_locked(loadable_modules.say_hash, name, loadable_modules.mutex);
2202 }
2203 
2204 SWITCH_DECLARE(switch_management_interface_t *) switch_loadable_module_get_management_interface(const char *relative_oid)
2205 {
2206  return switch_core_hash_find_locked(loadable_modules.management_hash, relative_oid, loadable_modules.mutex);
2207 }
2208 
2209 #ifdef DEBUG_CODEC_SORTING
2210 static void do_print(const switch_codec_implementation_t **array, int arraylen)
2211 {
2212  int i;
2213 
2214  for(i = 0; i < arraylen; i++) {
2215  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
2216  "DEBUG %d %s:%d %d\n", i, array[i]->iananame, array[i]->ianacode, array[i]->microseconds_per_packet / 1000);
2217  }
2218 
2219 }
2220 #endif
2221 
2222 /* helper only -- bounds checking enforced by caller */
2223 static void do_swap(const switch_codec_implementation_t **array, int a, int b)
2224 {
2225  const switch_codec_implementation_t *tmp = array[b];
2226  array[b] = array[a];
2227  array[a] = tmp;
2228 }
2229 
2230 static void switch_loadable_module_sort_codecs(const switch_codec_implementation_t **array, int arraylen)
2231 {
2232  int i = 0, sorted_ptime = 0;
2233 
2234 #ifdef DEBUG_CODEC_SORTING
2235  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--BEFORE\n");
2236  do_print(array, arraylen);
2237  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--BEFORE\n");
2238 #endif
2239 
2240  for (i = 0; i < arraylen; i++) {
2241  int this_ptime = array[i]->microseconds_per_packet / 1000;
2242 
2243  if (!strcasecmp(array[i]->iananame, "ilbc")) {
2244  this_ptime = 20;
2245  }
2246 
2247  if (!sorted_ptime) {
2248  sorted_ptime = this_ptime;
2249 #ifdef DEBUG_CODEC_SORTING
2250  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "sorted1 = %d\n", sorted_ptime);
2251 #endif
2252  }
2253 
2254  if (i > 0 && strcasecmp(array[i]->iananame, array[i-1]->iananame) && this_ptime != sorted_ptime) {
2255  int j;
2256  int swapped = 0;
2257 
2258 #ifdef DEBUG_CODEC_SORTING
2259  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%d != %d\n", this_ptime, sorted_ptime);
2260 #endif
2261  for(j = i; j < arraylen; j++) {
2262  int check_ptime = array[j]->microseconds_per_packet / 1000;
2263 
2264  if (!strcasecmp(array[i]->iananame, "ilbc")) {
2265  check_ptime = 20;
2266  }
2267 
2268  if (check_ptime == sorted_ptime) {
2269 #ifdef DEBUG_CODEC_SORTING
2270  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "swap %d %d ptime %d\n", i, j, check_ptime);
2271 #endif
2272  do_swap(array, i, j);
2273  swapped = 1;
2274  break;
2275  }
2276  }
2277 
2278  if (!swapped) {
2279  sorted_ptime = this_ptime;
2280 #ifdef DEBUG_CODEC_SORTING
2281  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "sorted2 = %d\n", sorted_ptime);
2282 #endif
2283  }
2284  }
2285  }
2286 
2287 #ifdef DEBUG_CODEC_SORTING
2288  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--AFTER\n");
2289  do_print(array, arraylen);
2290  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "--AFTER\n");
2291 #endif
2292 
2293 }
2294 
2295 
2296 SWITCH_DECLARE(int) switch_loadable_module_get_codecs(const switch_codec_implementation_t **array, int arraylen)
2297 {
2298  switch_hash_index_t *hi;
2299  void *val;
2300  switch_codec_interface_t *codec_interface;
2301  int i = 0;
2302  const switch_codec_implementation_t *imp;
2303  switch_codec_node_t *node, *head;
2304 
2305  switch_mutex_lock(loadable_modules.mutex);
2306  for (hi = switch_core_hash_first(loadable_modules.codec_hash); hi; hi = switch_core_hash_next(&hi)) {
2307  switch_core_hash_this(hi, NULL, NULL, &val);
2308  head = (switch_codec_node_t *) val;
2309 
2310  for (node = head; node; node = node->next) {
2311  codec_interface = (switch_codec_interface_t *) node->ptr;
2312 
2313  /* Look for the default ptime of the codec because it's the safest choice */
2314  for (imp = codec_interface->implementations; imp; imp = imp->next) {
2315  uint32_t default_ptime = switch_default_ptime(imp->iananame, imp->ianacode);
2316 
2317  if (imp->microseconds_per_packet / 1000 == (int)default_ptime) {
2318  array[i++] = imp;
2319  goto found;
2320  }
2321  }
2322  /* oh well we will use what we have */
2323  array[i++] = codec_interface->implementations;
2324  }
2325 
2326  found:
2327 
2328  if (i > arraylen) {
2329  break;
2330  }
2331 
2332  }
2333  switch_safe_free(hi);
2334 
2335  switch_mutex_unlock(loadable_modules.mutex);
2336 
2337  switch_loadable_module_sort_codecs(array, i);
2338 
2339  return i;
2340 
2341 }
2342 
2343 SWITCH_DECLARE(char *) switch_parse_codec_buf(char *buf, uint32_t *interval, uint32_t *rate, uint32_t *bit, uint32_t *channels, char **modname)
2344 {
2345  char *cur, *next = NULL, *name, *p;
2346 
2347  name = next = cur = buf;
2348 
2349  *channels = 1;
2350 
2351  for (;;) {
2352  if (!next) {
2353  break;
2354  }
2355 
2356  if ((p = strchr(next, '@'))) {
2357  *p++ = '\0';
2358  }
2359  next = p;
2360 
2361  if (cur != name) {
2362  if (strchr(cur, 'i')) {
2363  *interval = atoi(cur);
2364  } else if ((strchr(cur, 'k') || strchr(cur, 'h'))) {
2365  *rate = atoi(cur);
2366  } else if (strchr(cur, 'b')) {
2367  *bit = atoi(cur);
2368  } else if (strchr(cur, 'c')) {
2369  *channels = atoi(cur);
2370  } else {
2371  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);
2372  }
2373  }
2374  cur = next;
2375  }
2376 
2377  if ((p = strchr(name, '.'))) {
2378  *p++ = '\0';
2379  *modname = name;
2380  name = p;
2381  }
2382 
2383  return name;
2384 }
2385 
2386 SWITCH_DECLARE(int) switch_loadable_module_get_codecs_sorted(const switch_codec_implementation_t **array, int arraylen, char **prefs, int preflen)
2387 {
2388  int x, i = 0, j = 0;
2389  switch_codec_interface_t *codec_interface;
2390  const switch_codec_implementation_t *imp;
2391 
2392  switch_mutex_lock(loadable_modules.mutex);
2393 
2394  for (x = 0; x < preflen; x++) {
2395  char *name, buf[256], jbuf[256], *modname = NULL;
2396  uint32_t interval = 0, rate = 0, bit = 0, channels = 1;
2397 
2398  switch_copy_string(buf, prefs[x], sizeof(buf));
2399  name = switch_parse_codec_buf(buf, &interval, &rate, &bit, &channels, &modname);
2400 
2401  for(j = 0; j < x; j++) {
2402  char *jname, *jmodname = NULL;
2403  uint32_t jinterval = 0, jrate = 0, jbit = 0, jchannels = 1;
2404  uint32_t ointerval = interval, orate = rate, ochannels = channels;
2405 
2406  if (ointerval == 0) {
2407  ointerval = switch_default_ptime(name, 0);
2408  }
2409 
2410  if (orate == 0) {
2411  orate = switch_default_rate(name, 0);
2412  }
2413 
2414  if (ochannels == 0) {
2415  ochannels = 1;
2416  }
2417 
2418  switch_copy_string(jbuf, prefs[j], sizeof(jbuf));
2419  jname = switch_parse_codec_buf(jbuf, &jinterval, &jrate, &jbit, &jchannels, &jmodname);
2420 
2421  if (jinterval == 0) {
2422  jinterval = switch_default_ptime(jname, 0);
2423  }
2424 
2425  if (jrate == 0) {
2426  jrate = switch_default_rate(jname, 0);
2427  }
2428 
2429  if (jchannels == 0) {
2430  jchannels = 1;
2431  }
2432 
2433  if (!strcasecmp(name, jname) && ointerval == jinterval && orate == jrate && ochannels == jchannels) {
2434  goto next_x;
2435  }
2436  }
2437 
2438  if ((codec_interface = switch_loadable_module_get_codec_interface(name, modname)) != 0) {
2439  /* If no specific codec interval is requested opt for the default above all else because lots of stuff assumes it */
2440  for (imp = codec_interface->implementations; imp; imp = imp->next) {
2441  uint32_t default_ptime = switch_default_ptime(imp->iananame, imp->ianacode);
2442  uint32_t default_rate = switch_default_rate(imp->iananame, imp->ianacode);
2443 
2444  if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
2445  uint32_t crate = !strcasecmp(imp->iananame, "g722") ? imp->samples_per_second : imp->actual_samples_per_second;
2446 
2447  if ((!interval && (uint32_t) (imp->microseconds_per_packet / 1000) != default_ptime) ||
2448  (interval && (uint32_t) (imp->microseconds_per_packet / 1000) != interval)) {
2449  continue;
2450  }
2451 
2452  if (((!rate && crate != default_rate) || (rate && (uint32_t) imp->actual_samples_per_second != rate))) {
2453  continue;
2454  }
2455 
2456  if (bit && (uint32_t) imp->bits_per_second != bit) {
2457  continue;
2458  }
2459 
2460  if (channels && imp->number_of_channels != channels) {
2461  continue;
2462  }
2463  }
2464 
2465 
2466  array[i++] = imp;
2467  goto found;
2468 
2469  }
2470 
2471  /* Either looking for a specific interval or there was no interval specified and there wasn't one at the default ptime available */
2472  for (imp = codec_interface->implementations; imp; imp = imp->next) {
2473  if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
2474  uint32_t crate = !strcasecmp(imp->iananame, "g722") ? imp->samples_per_second : imp->actual_samples_per_second;
2475 
2476  if (interval && (uint32_t) (imp->microseconds_per_packet / 1000) != interval) {
2477  continue;
2478  }
2479 
2480  if (rate && (uint32_t) crate != rate) {
2481  continue;
2482  }
2483 
2484  if (bit && (uint32_t) imp->bits_per_second != bit) {
2485  continue;
2486  }
2487 
2488  if (channels && imp->number_of_channels != channels) {
2489  continue;
2490  }
2491  }
2492 
2493  array[i++] = imp;
2494  goto found;
2495 
2496  }
2497 
2498  found:
2499 
2500  UNPROTECT_INTERFACE(codec_interface);
2501 
2502  if (i > arraylen) {
2503  break;
2504  }
2505 
2506  }
2507 
2508  next_x:
2509 
2510  continue;
2511  }
2512 
2513  switch_mutex_unlock(loadable_modules.mutex);
2514 
2515  switch_loadable_module_sort_codecs(array, i);
2516 
2517  return i;
2518 }
2519 
2520 SWITCH_DECLARE(switch_status_t) switch_api_execute(const char *cmd, const char *arg, switch_core_session_t *session, switch_stream_handle_t *stream)
2521 {
2522  switch_api_interface_t *api;
2523  switch_status_t status;
2524  char *arg_used;
2525  char *cmd_used;
2526 
2527  switch_assert(stream != NULL);
2528  switch_assert(stream->data != NULL);
2529  switch_assert(stream->write_function != NULL);
2530 
2531  if (strcasecmp(cmd, "console_complete")) {
2532  cmd_used = switch_strip_whitespace(cmd);
2533  arg_used = switch_strip_whitespace(arg);
2534  } else {
2535  cmd_used = (char *) cmd;
2536  arg_used = (char *) arg;
2537  }
2538 
2539 
2540  if (!stream->param_event) {
2541  switch_event_create(&stream->param_event, SWITCH_EVENT_API);
2542  }
2543 
2544  if (stream->param_event) {
2545  if (cmd_used && *cmd_used) {
2546  switch_event_add_header_string(stream->param_event, SWITCH_STACK_BOTTOM, "API-Command", cmd_used);
2547  }
2548  if (arg_used && *arg_used) {
2549  switch_event_add_header_string(stream->param_event, SWITCH_STACK_BOTTOM, "API-Command-Argument", arg_used);
2550  }
2551  }
2552 
2553 
2554  if (cmd_used && (api = switch_loadable_module_get_api_interface(cmd_used)) != 0) {
2555  if ((status = api->function(arg_used, session, stream)) != SWITCH_STATUS_SUCCESS) {
2556  stream->write_function(stream, "COMMAND RETURNED ERROR!\n");
2557  }
2558  UNPROTECT_INTERFACE(api);
2559  } else {
2560  status = SWITCH_STATUS_FALSE;
2561  stream->write_function(stream, "INVALID COMMAND!\n");
2562  }
2563 
2564  if (stream->param_event) {
2565  switch_event_fire(&stream->param_event);
2566  }
2567 
2568  if (cmd_used != cmd) {
2569  switch_safe_free(cmd_used);
2570  }
2571 
2572  if (arg_used != arg) {
2573  switch_safe_free(arg_used);
2574  }
2575 
2576  return status;
2577 }
2578 
2579 SWITCH_DECLARE(switch_status_t) switch_json_api_execute(cJSON *json, switch_core_session_t *session, cJSON **retval)
2580 {
2581  switch_json_api_interface_t *json_api;
2582  switch_status_t status;
2583  cJSON *function, *json_reply = NULL;
2584 
2585  switch_assert(json);
2586 
2587  function = cJSON_GetObjectItem(json, "command");
2588 
2589  if (function && function->valuestring
2590  && cJSON_GetObjectItem(json, "data") && (json_api = switch_loadable_module_get_json_api_interface(function->valuestring)) != 0) {
2591  if ((status = json_api->function(json, session, &json_reply)) != SWITCH_STATUS_SUCCESS) {
2592  cJSON_AddItemToObject(json, "status", cJSON_CreateString("error"));
2593  cJSON_AddItemToObject(json, "message", cJSON_CreateString("The command returned an error"));
2594  } else {
2595  cJSON_AddItemToObject(json, "status", cJSON_CreateString("success"));
2596  }
2597 
2598  if (!json_reply) {
2599  json_reply = cJSON_CreateNull();
2600  }
2601 
2602  if (retval) {
2603  *retval = json_reply;
2604  } else {
2605  cJSON_AddItemToObject(json, "response", json_reply);
2606  }
2607 
2608  UNPROTECT_INTERFACE(json_api);
2609  } else {
2610  status = SWITCH_STATUS_FALSE;
2611  cJSON_AddItemToObject(json, "status", cJSON_CreateString("error"));
2612  cJSON_AddItemToObject(json, "message", cJSON_CreateString("Invalid request or non-existant command"));
2613  cJSON_AddItemToObject(json, "response", cJSON_CreateNull());
2614  }
2615 
2616  return status;
2617 }
2618 
2619 
2620 SWITCH_DECLARE(switch_loadable_module_interface_t *) switch_loadable_module_create_module_interface(switch_memory_pool_t *pool, const char *name)
2621 {
2622  switch_loadable_module_interface_t *mod;
2623 
2624  mod = switch_core_alloc(pool, sizeof(switch_loadable_module_interface_t));
2625  switch_assert(mod != NULL);
2626 
2627  mod->pool = pool;
2628 
2629  mod->module_name = switch_core_strdup(mod->pool, name);
2630  switch_thread_rwlock_create(&mod->rwlock, mod->pool);
2631  return mod;
2632 }
2633 
2634 #define ALLOC_INTERFACE(_TYPE_) { \
2635  switch_##_TYPE_##_interface_t *i, *ptr; \
2636  i = switch_core_alloc(mod->pool, sizeof(switch_##_TYPE_##_interface_t)); \
2637  switch_assert(i != NULL); \
2638  for (ptr = mod->_TYPE_##_interface; ptr && ptr->next; ptr = ptr->next); \
2639  if (ptr) { \
2640  ptr->next = i; \
2641  } else { \
2642  mod->_TYPE_##_interface = i; \
2643  } \
2644  switch_thread_rwlock_create(&i->rwlock, mod->pool); \
2645  switch_mutex_init(&i->reflock, SWITCH_MUTEX_NESTED, mod->pool); \
2646  i->parent = mod; \
2647  return i; }
2648 
2649 
2650 SWITCH_DECLARE(void *) switch_loadable_module_create_interface(switch_loadable_module_interface_t *mod, switch_module_interface_name_t iname)
2651 {
2652 
2653  switch (iname) {
2654  case SWITCH_ENDPOINT_INTERFACE:
2655  ALLOC_INTERFACE(endpoint)
2656 
2657  case SWITCH_TIMER_INTERFACE:
2658  ALLOC_INTERFACE(timer)
2659 
2660  case SWITCH_DIALPLAN_INTERFACE:
2661  ALLOC_INTERFACE(dialplan)
2662 
2663  case SWITCH_CODEC_INTERFACE:
2664  ALLOC_INTERFACE(codec)
2665 
2666  case SWITCH_APPLICATION_INTERFACE:
2667  ALLOC_INTERFACE(application)
2668 
2669  case SWITCH_CHAT_APPLICATION_INTERFACE:
2670  ALLOC_INTERFACE(chat_application)
2671 
2672  case SWITCH_API_INTERFACE:
2673  ALLOC_INTERFACE(api)
2674 
2675  case SWITCH_JSON_API_INTERFACE:
2676  ALLOC_INTERFACE(json_api)
2677 
2678  case SWITCH_FILE_INTERFACE:
2679  ALLOC_INTERFACE(file)
2680 
2681  case SWITCH_SPEECH_INTERFACE:
2682  ALLOC_INTERFACE(speech)
2683 
2684  case SWITCH_DIRECTORY_INTERFACE:
2685  ALLOC_INTERFACE(directory)
2686 
2687  case SWITCH_CHAT_INTERFACE:
2688  ALLOC_INTERFACE(chat)
2689 
2690  case SWITCH_SAY_INTERFACE:
2691  ALLOC_INTERFACE(say)
2692 
2693  case SWITCH_ASR_INTERFACE:
2694  ALLOC_INTERFACE(asr)
2695 
2696  case SWITCH_MANAGEMENT_INTERFACE:
2697  ALLOC_INTERFACE(management)
2698 
2699  case SWITCH_LIMIT_INTERFACE:
2700  ALLOC_INTERFACE(limit)
2701 
2702  default:
2703  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid Module Type!\n");
2704  return NULL;
2705  }
2706 }
2707 
2708 struct switch_say_file_handle {
2709  char *ext;
2710  int cnt;
2711  struct switch_stream_handle stream;
2712  switch_event_t *param_event;
2713 };
2714 
2715 SWITCH_DECLARE(char *) switch_say_file_handle_get_variable(switch_say_file_handle_t *sh, const char *var)
2716 {
2717  char *ret = NULL;
2718 
2719  if (sh->param_event) {
2720  ret = switch_event_get_header(sh->param_event, var);
2721  }
2722 
2723  return ret;
2724 
2725 }
2726 
2727 SWITCH_DECLARE(char *) switch_say_file_handle_get_path(switch_say_file_handle_t *sh)
2728 {
2729  return (char *) sh->stream.data;
2730 }
2731 
2732 SWITCH_DECLARE(char *) switch_say_file_handle_detach_path(switch_say_file_handle_t *sh)
2733 {
2734  char *path;
2735 
2736  switch_assert(sh);
2737  path = (char *) sh->stream.data;
2738  sh->stream.data = NULL;
2739  return path;
2740 }
2741 
2742 
2743 SWITCH_DECLARE(void) switch_say_file_handle_destroy(switch_say_file_handle_t **sh)
2744 {
2745  switch_assert(sh);
2746 
2747  switch_safe_free((*sh)->stream.data);
2748  switch_safe_free((*sh)->ext);
2749 
2750  if ((*sh)->param_event) {
2751  switch_event_destroy(&(*sh)->param_event);
2752  }
2753  free(*sh);
2754  *sh = NULL;
2755 }
2756 
2757 SWITCH_DECLARE(switch_status_t) switch_say_file_handle_create(switch_say_file_handle_t **sh, const char *ext, switch_event_t **var_event)
2758 {
2759  switch_assert(sh);
2760 
2761  if (zstr(ext)) {
2762  ext = "wav";
2763  }
2764 
2765  *sh = malloc(sizeof(**sh));
2766  memset(*sh, 0, sizeof(**sh));
2767 
2768  SWITCH_STANDARD_STREAM((*sh)->stream);
2769 
2770  if (var_event) {
2771  (*sh)->param_event = *var_event;
2772  *var_event = NULL;
2773  }
2774 
2775  (*sh)->ext = strdup(ext);
2776 
2777  return SWITCH_STATUS_SUCCESS;
2778 }
2779 
2780 SWITCH_DECLARE(void) switch_say_file(switch_say_file_handle_t *sh, const char *fmt, ...)
2781 {
2782  char buf[256] = "";
2783  int ret;
2784  va_list ap;
2785 
2786  va_start(ap, fmt);
2787 
2788  if ((ret = switch_vsnprintf(buf, sizeof(buf), fmt, ap)) > 0) {
2789  if (!sh->cnt++) {
2790  sh->stream.write_function(&sh->stream, "file_string://%s.%s", buf, sh->ext);
2791  } else if (strstr(buf, "://")) {
2792  sh->stream.write_function(&sh->stream, "!%s", buf);
2793  } else {
2794  sh->stream.write_function(&sh->stream, "!%s.%s", buf, sh->ext);
2795  }
2796 
2797  }
2798 
2799  va_end(ap);
2800 }
2801 
2802 SWITCH_DECLARE(switch_core_recover_callback_t) switch_core_get_secondary_recover_callback(const char *key)
2803 {
2804  switch_core_recover_callback_t cb;
2805 
2806  switch_mutex_lock(loadable_modules.mutex);
2807  cb = (switch_core_recover_callback_t) (intptr_t) switch_core_hash_find(loadable_modules.secondary_recover_hash, key);
2808  switch_mutex_unlock(loadable_modules.mutex);
2809 
2810  return cb;
2811 }
2812 
2813 
2814 SWITCH_DECLARE(switch_status_t) switch_core_register_secondary_recover_callback(const char *key, switch_core_recover_callback_t cb)
2815 {
2816  switch_status_t status = SWITCH_STATUS_SUCCESS;
2817 
2818  switch_assert(cb);
2819 
2820  switch_mutex_lock(loadable_modules.mutex);
2821  if (switch_core_hash_find(loadable_modules.secondary_recover_hash, key)) {
2822  status = SWITCH_STATUS_FALSE;
2823  } else {
2824  switch_core_hash_insert(loadable_modules.secondary_recover_hash, key, (void *)(intptr_t) cb);
2825  }
2826  switch_mutex_unlock(loadable_modules.mutex);
2827 
2828  return status;
2829 }
2830 
2831 
2832 SWITCH_DECLARE(void) switch_core_unregister_secondary_recover_callback(const char *key)
2833 {
2834  switch_mutex_lock(loadable_modules.mutex);
2835  switch_core_hash_delete(loadable_modules.secondary_recover_hash, key);
2836  switch_mutex_unlock(loadable_modules.mutex);
2837 }
2838 
2839 
2840 /* For Emacs:
2841  * Local Variables:
2842  * mode:c
2843  * indent-tabs-mode:t
2844  * tab-width:4
2845  * c-basic-offset:4
2846  * End:
2847  * For VIM:
2848  * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
2849  */
switch_queue_t
struct apr_queue_t switch_queue_t
Definition: switch_apr.h:590
switch_loadable_module_container::timer_hash
switch_hash_t * timer_hash
Definition: switch_loadable_module.c:77
switch_management_interface::relative_oid
const char * relative_oid
Definition: switch_module_interfaces.h:565
switch_core_hash_find_locked
void * switch_core_hash_find_locked(_In_ switch_hash_t *hash, _In_z_ const char *key, _In_ switch_mutex_t *mutex)
Retrieve data from a given hash.
switch_say_file_handle_get_variable
char * switch_say_file_handle_get_variable(switch_say_file_handle_t *sh, const char *var)
Definition: switch_loadable_module.c:2715
loadable_modules
static struct switch_loadable_module_container loadable_modules
Definition: switch_loadable_module.c:95
switch_event_fire
#define switch_event_fire(event)
Fire an event filling in most of the arguements with obvious values.
Definition: switch_event.h:412
switch_xml_free
void switch_xml_free(_In_opt_ switch_xml_t xml)
frees the memory allocated for an switch_xml structure
switch_say_file
void switch_say_file(switch_say_file_handle_t *sh, const char *fmt,...)
Definition: switch_loadable_module.c:2780
switch_core_new_memory_pool
#define switch_core_new_memory_pool(p)
Create a new sub memory pool from the core's master pool.
Definition: switch_core.h:631
switch_application_interface
A module interface to implement an application.
Definition: switch_module_interfaces.h:760
switch_thread_rwlock_unlock
switch_status_t switch_thread_rwlock_unlock(switch_thread_rwlock_t *rwlock)
Definition: switch_apr.c:263
SWITCH_FILE_INTERFACE
Definition: switch_types.h:385
switch_xml_attr_soft
const char * switch_xml_attr_soft(_In_ switch_xml_t xml, _In_z_ const char *attr)
returns the value of the requested tag attribute, or "" if not found
switch_loadable_module::switch_module_load
switch_module_load_t switch_module_load
Definition: switch_loadable_module.c:63
SWITCH_CODEC_INTERFACE
Definition: switch_types.h:382
switch_loadable_module::pool
switch_memory_pool_t * pool
Definition: switch_loadable_module.c:66
SWITCH_DIALPLAN_INTERFACE
Definition: switch_types.h:381
switch_directory_interface::next
struct switch_directory_interface * next
Definition: switch_module_interfaces.h:617
switch_event_expand_headers
#define switch_event_expand_headers(_event, _in)
Definition: switch_event.h:354
ALLOC_INTERFACE
#define ALLOC_INTERFACE(_TYPE_)
Definition: switch_loadable_module.c:2634
SWITCH_THREAD_FUNC
#define SWITCH_THREAD_FUNC
Definition: switch_platform.h:201
switch_limit_interface
Abstract interface to a limit module.
Definition: switch_module_interfaces.h:576
switch_loadable_module::key
char * key
Definition: switch_loadable_module.c:58
SWITCH_CHAT_APPLICATION_INTERFACE
Definition: switch_types.h:393
switch_say_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:537
cJSON_CreateNull
cJSON * cJSON_CreateNull(void)
Definition: switch_json.c:537
IDX
static int IDX
Definition: switch_loadable_module.c:601
SWITCH_CHANNEL_LOG
#define SWITCH_CHANNEL_LOG
Definition: switch_types.h:1246
switch_loadable_module::status
switch_status_t status
Definition: switch_loadable_module.c:67
switch_loadable_module_load_module
switch_status_t switch_loadable_module_load_module(char *dir, char *fname, switch_bool_t runtime, const char **err)
Load a module.
Definition: switch_loadable_module.c:1545
SWITCH_TRUE
Definition: switch_types.h:407
chat_queue_message
static void chat_queue_message(switch_event_t **eventp)
Definition: switch_loadable_module.c:784
switch_core_hash_destroy
switch_status_t switch_core_hash_destroy(_Inout_ switch_hash_t **hash)
Destroy an existing hash table.
switch_dialplan_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:258
switch_api_interface::function
switch_api_function_t function
Definition: switch_module_interfaces.h:808
switch_json_api_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:829
switch_core_hash_find
void * switch_core_hash_find(_In_ switch_hash_t *hash, _In_z_ const char *key)
Retrieve data from a given hash.
switch_loadable_module_interface::dialplan_interface
switch_dialplan_interface_t * dialplan_interface
Definition: switch_loadable_module.h:63
SWITCH_EVENT_MODULE_LOAD
Definition: switch_types.h:1961
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.
switch_endpoint_interface
Abstraction of an module endpoint interface This is the glue between the abstract idea of a "channel"...
Definition: switch_module_interfaces.h:173
switch_loadable_module_interface::directory_interface
switch_directory_interface_t * directory_interface
Definition: switch_loadable_module.h:79
switch_core_hash_init
#define switch_core_hash_init(_hash)
Definition: switch_core.h:1390
switch_codec_node_s::ptr
const switch_codec_interface_t * ptr
Definition: switch_loadable_module.c:51
SWITCH_EVENT_MESSAGE
Definition: switch_types.h:1964
switch_management_interface::next
struct switch_management_interface * next
Definition: switch_module_interfaces.h:572
switch_loadable_module_function_table
Definition: switch_types.h:2446
switch_json_api_interface::syntax
const char * syntax
Definition: switch_module_interfaces.h:828
switch_loadable_module_container::endpoint_hash
switch_hash_t * endpoint_hash
Definition: switch_loadable_module.c:74
switch_codec_implementation::bits_per_second
int bits_per_second
Definition: switch_module_interfaces.h:709
switch_speech_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:492
switch_core_session_hupall_matching_var
#define switch_core_session_hupall_matching_var(_vn, _vv, _c)
Definition: switch_core.h:984
switch_core_get_secondary_recover_callback
switch_core_recover_callback_t switch_core_get_secondary_recover_callback(const char *key)
Definition: switch_loadable_module.c:2802
switch_loadable_module_container::pool
switch_memory_pool_t * pool
Definition: switch_loadable_module.c:92
SWITCH_MANAGEMENT_INTERFACE
Definition: switch_types.h:391
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.
Definition: switch_loadable_module.c:1671
running
int running
Definition: switch_loadable_module.c:598
SWITCH_RECOMMENDED_BUFFER_SIZE
#define SWITCH_RECOMMENDED_BUFFER_SIZE
Definition: switch_types.h:557
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) ...
Definition: switch_loadable_module.c:1727
switch_bool_t
switch_bool_t
Definition: switch_types.h:405
switch_loadable_module::shutting_down
switch_bool_t shutting_down
Definition: switch_loadable_module.c:69
switch_core_strdup
#define switch_core_strdup(_pool, _todup)
Copy a string using memory allocation from a given pool.
Definition: switch_core.h:729
switch_chat_interface::chat_send
switch_status_t(* chat_send)(switch_event_t *message_event)
Definition: switch_module_interfaces.h:553
switch_chat_application_interface::chat_application_function
switch_chat_application_function_t chat_application_function
Definition: switch_module_interfaces.h:785
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.
Definition: switch_loadable_module.c:2520
switch_loadable_module_interface::codec_interface
switch_codec_interface_t * codec_interface
Definition: switch_loadable_module.h:65
switch_threadattr_stacksize_set
switch_status_t switch_threadattr_stacksize_set(switch_threadattr_t *attr, switch_size_t stacksize)
Definition: switch_apr.c:660
SWITCH_ENDPOINT_INTERFACE
Definition: switch_types.h:379
switch_core_destroy_memory_pool
#define switch_core_destroy_memory_pool(p)
Returns a subpool back to the main pool.
Definition: switch_core.h:640
switch_codec_implementation::decoded_bytes_per_packet
uint32_t decoded_bytes_per_packet
Definition: switch_module_interfaces.h:715
switch_say_file_handle::stream
struct switch_stream_handle stream
Definition: switch_loadable_module.c:2711
switch_event
Representation of an event.
Definition: switch_event.h:80
switch_chat_application_interface
A module interface to implement a chat application.
Definition: switch_module_interfaces.h:781
switch_codec_interface::implementations
switch_codec_implementation_t * implementations
Definition: switch_module_interfaces.h:747
switch_loadable_module_container::secondary_recover_hash
switch_hash_t * secondary_recover_hash
Definition: switch_loadable_module.c:90
switch_event_add_body
switch_status_t switch_event_add_body(switch_event_t *event, const char *fmt,...) PRINTF_FUNCTION(2
Add a body to an event.
SWITCH_LIMIT_INTERFACE
Definition: switch_types.h:392
EF_NO_CHAT_EXEC
Definition: switch_event.h:121
switch_endpoint_interface::next
struct switch_endpoint_interface * next
Definition: switch_module_interfaces.h:194
FREESWITCH_OID_PREFIX
#define FREESWITCH_OID_PREFIX
Definition: switch.h:53
switch_core_session
Definition: switch_core_pvt.h:105
msg_queue_len
int msg_queue_len
Definition: switch_loadable_module.c:595
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.
Definition: switch_loadable_module.c:2204
switch_chat_interface
Abstract interface to a chat module.
Definition: switch_module_interfaces.h:549
switch_loadable_module_container::api_hash
switch_hash_t * api_hash
Definition: switch_loadable_module.c:80
switch_directories::mod_dir
char * mod_dir
Definition: switch_types.h:519
switch_asr_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:406
switch_chat_application_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:794
switch_strip_whitespace
char * switch_strip_whitespace(const char *str)
Definition: switch_utils.c:1301
switch_loadable_module_sort_codecs
static void switch_loadable_module_sort_codecs(const switch_codec_implementation_t **array, int arraylen)
Definition: switch_loadable_module.c:2230
switch_xml
A representation of an XML tree.
Definition: switch_xml.h:76
switch_dialplan_interface
Abstract interface to a dialplan module.
Definition: switch_module_interfaces.h:256
switch_queue_pop
switch_status_t switch_queue_pop(switch_queue_t *queue, void **data)
Definition: switch_apr.c:1119
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.
Definition: switch_loadable_module.c:2579
switch_speech_interface::next
struct switch_speech_interface * next
Definition: switch_module_interfaces.h:496
switch_timer_interface
A table of functions that a timer module implements.
Definition: switch_module_interfaces.h:233
chat_thread_run
void *SWITCH_THREAD_FUNC chat_thread_run(switch_thread_t *thread, void *obj)
Definition: switch_loadable_module.c:730
switch_event_dup
switch_status_t switch_event_dup(switch_event_t **event, switch_event_t *todup)
Duplicate an event.
Definition: switch_event.c:1302
switch_loadable_module
Definition: switch_loadable_module.c:57
switch_loadable_module_container::mutex
switch_mutex_t * mutex
Definition: switch_loadable_module.c:91
SWITCH_API_VERSION
#define SWITCH_API_VERSION
Definition: switch_types.h:2422
cur
pack cur
Definition: switch_bitpack.h:88
thread
static switch_thread_t * thread
Definition: switch_log.c:279
switch_loadable_module_container::asr_hash
switch_hash_t * asr_hash
Definition: switch_loadable_module.c:84
switch_snprintf
int switch_snprintf(_Out_z_cap_(len) char *buf, _In_ switch_size_t len, _In_z_ _Printf_format_string_ const char *format,...)
runtime
struct switch_runtime runtime
Definition: switch_core.c:64
switch_true
static int switch_true(const char *expr)
Evaluate the truthfullness of a string expression.
Definition: switch_utils.h:450
SWITCH_CODEC_TYPE_VIDEO
Definition: switch_types.h:1703
switch_chat_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:551
switch_json_api_interface::desc
const char * desc
Definition: switch_module_interfaces.h:824
switch_say_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:541
switch_loadable_module_container::say_hash
switch_hash_t * say_hash
Definition: switch_loadable_module.c:87
switch_asr_interface
Abstract interface to an asr module.
Definition: switch_module_interfaces.h:404
SWITCH_LOG_WARNING
Definition: switch_types.h:1213
switch_asr_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:432
switch_loadable_module_shutdown
void switch_loadable_module_shutdown(void)
Shutdown the module backend and call the shutdown routine in all loaded modules.
Definition: switch_loadable_module.c:2044
switch_say_file_handle
Definition: switch_loadable_module.c:2708
SWITCH_STATUS_TERM
Definition: switch_types.h:1176
switch_application_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:762
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.
switch_file_interface
Abstract interface to a file format module.
Definition: switch_module_interfaces.h:269
switch_core_thread_session::pool
switch_memory_pool_t * pool
Definition: switch_core.h:223
SWITCH_EVENT_API
Definition: switch_types.h:1950
zstr
#define zstr(x)
Definition: switch_utils.h:281
chat_process_event
static switch_status_t chat_process_event(switch_event_t **eventp)
Definition: switch_loadable_module.c:713
switch_codec_node_t
struct switch_codec_node_s switch_codec_node_t
pool
switch_memory_pool_t * pool
Definition: switch_loadable_module.c:597
switch_modulename_callback_func_t
int(* switch_modulename_callback_func_t)(void *user_data, const char *module_name)
Definition: switch_types.h:2454
switch_loadable_module_container::module_hash
switch_hash_t * module_hash
Definition: switch_loadable_module.c:73
SWITCH_STATUS_NOUNLOAD
Definition: switch_types.h:1171
switch_json_api_interface::next
struct switch_json_api_interface * next
Definition: switch_module_interfaces.h:833
switch_loadable_module_function_table::load
switch_module_load_t load
Definition: switch_types.h:2448
switch_mutex_unlock
switch_status_t switch_mutex_unlock(switch_mutex_t *lock)
Definition: switch_apr.c:290
msg_queue_thread
switch_thread_t * msg_queue_thread[CHAT_MAX_MSG_QUEUE]
Definition: switch_loadable_module.c:594
switch_thread_exit
switch_status_t switch_thread_exit(switch_thread_t *thd, switch_status_t retval)
Definition: switch_apr.c:1245
switch_thread_join
switch_status_t switch_thread_join(switch_status_t *retval, switch_thread_t *thd)
Definition: switch_apr.c:1255
switch_loadable_module_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_loadable_module.h:90
switch_timer_interface::next
struct switch_timer_interface * next
Definition: switch_module_interfaces.h:252
UNPROTECT_INTERFACE
#define UNPROTECT_INTERFACE(_it)
Definition: switch_module_interfaces.h:837
switch_core_chat_send
switch_status_t switch_core_chat_send(const char *dest_proto, switch_event_t *message_event)
Definition: switch_loadable_module.c:900
HASH_FUNC
#define HASH_FUNC(_kind_)
Definition: switch_loadable_module.c:2177
SWITCH_MUTEX_NESTED
#define SWITCH_MUTEX_NESTED
Definition: switch_apr.h:318
switch_core_unregister_secondary_recover_callback
void switch_core_unregister_secondary_recover_callback(const char *key)
Definition: switch_loadable_module.c:2832
switch_loadable_module_interface::timer_interface
switch_timer_interface_t * timer_interface
Definition: switch_loadable_module.h:61
switch_directory_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:613
SWITCH_ASR_INTERFACE
Definition: switch_types.h:390
SWITCH_PATH_SEPARATOR
#define SWITCH_PATH_SEPARATOR
Definition: switch_types.h:122
switch_xml::next
switch_xml_t next
Definition: switch_xml.h:88
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.
switch_speech_interface
Abstract interface to a speech module.
Definition: switch_module_interfaces.h:477
switch_loadable_module_container::file_hash
switch_hash_t * file_hash
Definition: switch_loadable_module.c:82
buf
switch_byte_t switch_byte_t * buf
Definition: switch_bitpack.h:76
SWITCH_LOG_NOTICE
Definition: switch_types.h:1212
switch_loadable_module_load_file
static switch_status_t switch_loadable_module_load_file(char *path, char *filename, switch_bool_t global, switch_loadable_module_t **new_module)
Definition: switch_loadable_module.c:1401
switch_yield
#define switch_yield(ms)
Wait a desired number of microseconds and yield the CPU.
Definition: switch_utils.h:908
SWITCH_STATUS_GENERR
Definition: switch_types.h:1164
switch_loadable_module_container::codec_hash
switch_hash_t * codec_hash
Definition: switch_loadable_module.c:75
switch_api_interface
A module interface to implement an api function.
Definition: switch_module_interfaces.h:802
switch_loadable_module_runtime
static void switch_loadable_module_runtime(void)
Definition: switch_loadable_module.c:127
switch_core_hash_insert_locked
switch_status_t switch_core_hash_insert_locked(_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ const void *data, _In_opt_ switch_mutex_t *mutex)
Insert data into a hash.
CHAT_MAX_MSG_QUEUE
#define CHAT_MAX_MSG_QUEUE
Definition: switch_loadable_module.c:589
switch_dialplan_interface::next
struct switch_dialplan_interface * next
Definition: switch_module_interfaces.h:265
SWITCH_LOG_CONSOLE
Definition: switch_types.h:1217
switch_say_interface
Abstract interface to a say module.
Definition: switch_module_interfaces.h:535
switch_say_file_handle_create
switch_status_t switch_say_file_handle_create(switch_say_file_handle_t **sh, const char *ext, switch_event_t **var_event)
Definition: switch_loadable_module.c:2757
switch_mutex_lock
switch_status_t switch_mutex_lock(switch_mutex_t *lock)
Definition: switch_apr.c:285
SWITCH_SAY_INTERFACE
Definition: switch_types.h:389
switch_core_flags
switch_core_flag_t switch_core_flags(void)
return core flags
Definition: switch_core.c:2852
switch_loadable_module::lib
switch_dso_lib_t lib
Definition: switch_loadable_module.c:62
switch_api_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:804
switch_dso_destroy
void switch_dso_destroy(switch_dso_lib_t *lib)
Definition: switch_dso.c:87
switch_codec_implementation::codec_type
switch_codec_type_t codec_type
Definition: switch_module_interfaces.h:697
switch_core_alloc
#define switch_core_alloc(_pool, _mem)
Allocate memory directly from a memory pool.
Definition: switch_core.h:682
switch_codec_implementation::actual_samples_per_second
uint32_t actual_samples_per_second
Definition: switch_module_interfaces.h:707
switch_management_interface
Abstract interface to a management module.
Definition: switch_module_interfaces.h:563
switch_loadable_module_container::application_hash
switch_hash_t * application_hash
Definition: switch_loadable_module.c:78
switch_loadable_module_interface::chat_interface
switch_chat_interface_t * chat_interface
Definition: switch_loadable_module.h:81
SWITCH_THREAD_STACKSIZE
#define SWITCH_THREAD_STACKSIZE
Definition: switch_types.h:551
switch_loadable_module_interface::speech_interface
switch_speech_interface_t * speech_interface
Definition: switch_loadable_module.h:77
CHAT_QUEUE_SIZE
#define CHAT_QUEUE_SIZE
Definition: switch_loadable_module.c:590
SCF_VG
Definition: switch_types.h:354
switch_event_add_header_string
switch_status_t switch_event_add_header_string(switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
Add a string header to an event.
Definition: switch_event.c:1189
switch_api_interface::next
struct switch_api_interface * next
Definition: switch_module_interfaces.h:815
switch_chat_application_interface::syntax
const char * syntax
Definition: switch_module_interfaces.h:791
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.
Definition: switch_loadable_module.c:2121
switch_loadable_module::perm
int perm
Definition: switch_loadable_module.c:60
switch_loadable_module_unprocess
static switch_status_t switch_loadable_module_unprocess(switch_loadable_module_t *old_module)
Definition: switch_loadable_module.c:928
switch_safe_free
#define switch_safe_free(it)
Free a pointer and set it to NULL unless it already is NULL.
Definition: switch_utils.h:789
switch_json_api_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:822
switch_endpoint_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:175
switch_file_node_s::interface_name
const char * interface_name
Definition: switch_loadable_module.c:46
switch_codec_interface
Top level module interface to implement a series of codec implementations.
Definition: switch_module_interfaces.h:743
switch_loadable_module_interface::endpoint_interface
switch_endpoint_interface_t * endpoint_interface
Definition: switch_loadable_module.h:59
switch_mutex_init
switch_status_t switch_mutex_init(switch_mutex_t **lock, unsigned int flags, switch_memory_pool_t *pool)
Definition: switch_apr.c:270
SWITCH_STATUS_BREAK
Definition: switch_types.h:1166
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.
Definition: switch_loadable_module.c:2296
SWITCH_API_INTERFACE
Definition: switch_types.h:384
switch_hashtable
Definition: switch_hashtable_private.h:35
switch_loadable_module_exists
switch_status_t switch_loadable_module_exists(const char *mod)
Check if a module is loaded.
Definition: switch_loadable_module.c:1610
switch_core_hash_this
void switch_core_hash_this(_In_ switch_hash_index_t *hi, _Out_opt_ptrdiff_cap_(klen) const void **key, _Out_opt_ switch_ssize_t *klen, _Out_ void **val)
Gets the key and value of the current hash element.
switch_module_interface_name_t
switch_module_interface_name_t
Definition: switch_types.h:378
SWITCH_TIMER_INTERFACE
Definition: switch_types.h:380
switch_size_t
uintptr_t switch_size_t
Definition: switch_platform.h:223
switch_codec_interface::next
struct switch_codec_interface * next
Definition: switch_module_interfaces.h:756
switch_chat_interface::next
struct switch_chat_interface * next
Definition: switch_module_interfaces.h:559
switch_loadable_module_load_module_ex
static switch_status_t switch_loadable_module_load_module_ex(char *dir, char *fname, switch_bool_t runtime, switch_bool_t global, const char **err)
Definition: switch_loadable_module.c:1550
switch_core_hash_next
switch_hash_index_t * switch_core_hash_next(_In_ switch_hash_index_t **hi)
Gets the next element of a hashtable.
switch_file_node_s
Definition: switch_loadable_module.c:44
switch_stream_handle
Definition: switch_module_interfaces.h:93
switch_default_ptime
uint32_t switch_default_ptime(const char *name, uint32_t number)
Definition: switch_core.c:2026
switch_say_file_handle_detach_path
char * switch_say_file_handle_detach_path(switch_say_file_handle_t *sh)
Definition: switch_loadable_module.c:2732
switch_say_file_handle::ext
char * ext
Definition: switch_loadable_module.c:2709
switch_dir_open
switch_status_t switch_dir_open(switch_dir_t **new_dir, const char *dirname, switch_memory_pool_t *pool)
Definition: switch_apr.c:538
switch_chat_application_interface::next
struct switch_chat_application_interface * next
Definition: switch_module_interfaces.h:798
switch_codec_node_s::next
struct switch_codec_node_s * next
Definition: switch_loadable_module.c:53
cJSON_AddItemToObject
void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
Definition: switch_json.c:520
switch_cond_next
void switch_cond_next(void)
Definition: switch_time.c:638
msg_queue
switch_queue_t * msg_queue[CHAT_MAX_MSG_QUEUE]
Definition: switch_loadable_module.c:593
switch_loadable_module_function_table::runtime
switch_module_runtime_t runtime
Definition: switch_types.h:2450
SWITCH_STANDARD_STREAM
#define SWITCH_STANDARD_STREAM(s)
Definition: switch_console.h:46
switch_codec_implementation::microseconds_per_packet
int microseconds_per_packet
Definition: switch_module_interfaces.h:711
switch_copy_string
char * switch_copy_string(_Out_z_cap_(dst_size) char *dst, _In_z_ const char *src, _In_ switch_size_t dst_size)
cJSON_GetObjectItem
cJSON * cJSON_GetObjectItem(const cJSON *object, const char *string)
Definition: switch_json.c:498
switch_loadable_module::filename
char * filename
Definition: switch_loadable_module.c:59
switch_api_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:811
switch_dso_open
switch_dso_lib_t switch_dso_open(const char *path, int global, char **err)
Definition: switch_dso.c:95
switch_core_thread_session::objs
void * objs[SWITCH_MAX_CORE_THREAD_SESSION_OBJS]
Definition: switch_core.h:220
switch_loadable_module_interface::file_interface
switch_file_interface_t * file_interface
Definition: switch_loadable_module.h:75
switch_core_hash_delete
void * switch_core_hash_delete(_In_ switch_hash_t *hash, _In_z_ const char *key)
Delete data from a hash based on desired key.
switch_loadable_module_interface::application_interface
switch_application_interface_t * application_interface
Definition: switch_loadable_module.h:67
switch_dir_next_file
const char * switch_dir_next_file(switch_dir_t *thedir, char *buf, switch_size_t len)
Definition: switch_apr.c:595
SWITCH_EVENT_MODULE_UNLOAD
Definition: switch_types.h:1962
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.
Definition: switch_loadable_module.c:2148
SWITCH_CAUSE_MANAGER_REQUEST
Definition: switch_types.h:2080
SWITCH_GLOBAL_dirs
switch_directories SWITCH_GLOBAL_dirs
Definition: switch_core.c:60
switch_api_interface::desc
const char * desc
Definition: switch_module_interfaces.h:806
switch_loadable_module_interface::limit_interface
switch_limit_interface_t * limit_interface
Definition: switch_loadable_module.h:89
cJSON_CreateString
cJSON * cJSON_CreateString(const char *string)
Definition: switch_json.c:542
switch_str_nil
#define switch_str_nil(s)
Make a null string a blank string instead.
Definition: switch_utils.h:903
switch_dir
Definition: switch_apr.c:533
switch_loadable_module_interface::management_interface
switch_management_interface_t * management_interface
Definition: switch_loadable_module.h:87
chat_globals
static struct @5 chat_globals
switch_application_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:773
switch_codec_implementation::number_of_channels
uint8_t number_of_channels
Definition: switch_module_interfaces.h:719
switch_mutex_t
struct apr_thread_mutex_t switch_mutex_t
Definition: switch_apr.h:314
switch_loadable_module_get_codecs_sorted
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...
Definition: switch_loadable_module.c:2386
switch_codec_implementation::samples_per_second
uint32_t samples_per_second
Definition: switch_module_interfaces.h:705
switch_status_t
switch_status_t
Common return values.
Definition: switch_types.h:1154
SWITCH_LOG_CRIT
Definition: switch_types.h:1215
SWITCH_LOG_DEBUG
Definition: switch_types.h:1210
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.
switch_loadable_module_unload_module
switch_status_t switch_loadable_module_unload_module(char *dir, char *fname, switch_bool_t force, const char **err)
Unoad a module.
Definition: switch_loadable_module.c:1629
switch_goto_status
#define switch_goto_status(_status, _label)
Definition: switch_utils.h:256
switch_loadable_module::module_interface
switch_loadable_module_interface_t * module_interface
Definition: switch_loadable_module.c:61
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.
Definition: switch_loadable_module.c:2106
switch_loadable_module::thread
switch_thread_t * thread
Definition: switch_loadable_module.c:68
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.
Definition: switch_loadable_module.c:2199
switch_application_interface::short_desc
const char * short_desc
Definition: switch_module_interfaces.h:768
switch_xml_open_cfg
switch_xml_t switch_xml_open_cfg(_In_z_ const char *file_path, _Out_ switch_xml_t *node, _In_opt_ switch_event_t *params)
open a config in the core registry
switch_say_file_handle_get_path
char * switch_say_file_handle_get_path(switch_say_file_handle_t *sh)
Definition: switch_loadable_module.c:2727
do_chat_send
static switch_status_t do_chat_send(switch_event_t *message_event)
Definition: switch_loadable_module.c:604
switch_chat_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:555
switch_file_node_s::next
struct switch_file_node_s * next
Definition: switch_loadable_module.c:47
switch_core_launch_thread
switch_thread_t * switch_core_launch_thread(void *(SWITCH_THREAD_FUNC *func)(switch_thread_t *, void *), void *obj, switch_memory_pool_t *pool)
Launch a thread.
switch_loadable_module_container
Definition: switch_loadable_module.c:72
switch_core_chat_send_args
switch_status_t switch_core_chat_send_args(const char *dest_proto, const char *proto, const char *from, const char *to, const char *subject, const char *body, const char *type, const char *hint, switch_bool_t blocking)
Definition: switch_loadable_module.c:858
switch_loadable_module_create_module_interface
switch_loadable_module_interface_t * switch_loadable_module_create_module_interface(switch_memory_pool_t *pool, const char *name)
Definition: switch_loadable_module.c:2620
switch_loadable_module_interface::json_api_interface
switch_json_api_interface_t * json_api_interface
Definition: switch_loadable_module.h:73
switch_codec_implementation::ianacode
switch_payload_t ianacode
Definition: switch_module_interfaces.h:699
switch_core_hash_insert
#define switch_core_hash_insert(_h, _k, _d)
Definition: switch_core.h:1410
switch_thread_t
struct apr_thread_t switch_thread_t
Definition: switch_apr.h:941
switch_say_file_handle::param_event
switch_event_t * param_event
Definition: switch_loadable_module.c:2712
switch.h
Main Library Header.
switch_loadable_module_container::chat_hash
switch_hash_t * chat_hash
Definition: switch_loadable_module.c:86
switch_chat_application_interface::short_desc
const char * short_desc
Definition: switch_module_interfaces.h:789
switch_event_create
#define switch_event_create(event, id)
Create a new event assuming it will not be custom event and therefore hiding the unused parameters...
Definition: switch_event.h:383
switch_is_file_path
static switch_bool_t switch_is_file_path(const char *file)
Definition: switch_utils.h:1098
switch_core_register_secondary_recover_callback
switch_status_t switch_core_register_secondary_recover_callback(const char *key, switch_core_recover_callback_t cb)
Definition: switch_loadable_module.c:2814
switch_loadable_module_container::limit_hash
switch_hash_t * limit_hash
Definition: switch_loadable_module.c:89
SWITCH_DECLARE
#define SWITCH_DECLARE(type)
Definition: switch_platform.h:193
switch_loadable_module_interface::module_name
const char * module_name
Definition: switch_loadable_module.h:57
switch_codec_node_s
Definition: switch_loadable_module.c:50
SWITCH_JSON_API_INTERFACE
Definition: switch_types.h:394
switch_limit_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:578
apr_threadattr_t
Definition: switch_apr.c:625
switch_event_get_header
#define switch_event_get_header(_e, _h)
Definition: switch_event.h:172
switch_codec_node_s::interface_name
const char * interface_name
Definition: switch_loadable_module.c:52
switch_hashtable_iterator
Definition: switch_hashtable_private.h:29
switch_api_interface::syntax
const char * syntax
Definition: switch_module_interfaces.h:810
switch_xml_child
switch_xml_t switch_xml_child(_In_ switch_xml_t xml, _In_z_ const char *name)
returns the first child tag (one level deeper) with the given name or NULL \ if not found ...
SWITCH_CHAT_INTERFACE
Definition: switch_types.h:388
SMODF_GLOBAL_SYMBOLS
Definition: switch_types.h:2442
switch_loadable_module_exec
static void *SWITCH_THREAD_FUNC switch_loadable_module_exec(switch_thread_t *thread, void *obj)
Definition: switch_loadable_module.c:100
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.
Definition: switch_loadable_module.c:1709
SWITCH_DIRECTORY_INTERFACE
Definition: switch_types.h:387
do_swap
static void do_swap(const switch_codec_implementation_t **array, int a, int b)
Definition: switch_loadable_module.c:2223
switch_core_execute_chat_app
switch_status_t switch_core_execute_chat_app(switch_event_t *message, const char *app, const char *data)
Definition: switch_loadable_module.c:820
switch_queue_trypush
switch_status_t switch_queue_trypush(switch_queue_t *queue, void *data)
Definition: switch_apr.c:1155
SWITCH_APPLICATION_INTERFACE
Definition: switch_types.h:383
switch_codec_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:745
switch_loadable_module_container::chat_application_hash
switch_hash_t * chat_application_hash
Definition: switch_loadable_module.c:79
SWITCH_LOG_ERROR
Definition: switch_types.h:1214
switch_say_interface::next
struct switch_say_interface * next
Definition: switch_module_interfaces.h:545
switch_core_session_hupall_endpoint
void switch_core_session_hupall_endpoint(const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause)
Hangup all sessions that belong to an endpoint.
Definition: switch_core_session.c:312
switch_core_recover_callback_t
int(* switch_core_recover_callback_t)(switch_core_session_t *session)
Definition: switch_types.h:2298
switch_loadable_module_container::directory_hash
switch_hash_t * directory_hash
Definition: switch_loadable_module.c:85
switch_application_interface::syntax
const char * syntax
Definition: switch_module_interfaces.h:770
switch_codec_implementation::next
struct switch_codec_implementation * next
Definition: switch_module_interfaces.h:739
switch_loadable_module::switch_module_runtime
switch_module_runtime_t switch_module_runtime
Definition: switch_loadable_module.c:64
SWITCH_STATUS_FALSE
Definition: switch_types.h:1156
switch_endpoint_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:186
switch_loadable_module_init
switch_status_t switch_loadable_module_init(switch_bool_t autoload)
Initilize the module backend and load all the modules.
Definition: switch_loadable_module.c:1821
switch_core_thread_session
A generic object to pass as a thread's session object to allow mutiple arguements and a pool...
Definition: switch_core.h:214
switch_queue_push
switch_status_t switch_queue_push(switch_queue_t *queue, void *data)
Definition: switch_apr.c:1129
switch_core_chat_deliver
switch_status_t switch_core_chat_deliver(const char *dest_proto, switch_event_t **message_event)
Definition: switch_loadable_module.c:915
switch_dso_data_sym
void * switch_dso_data_sym(switch_dso_lib_t lib, const char *sym, char **err)
Definition: switch_dso.c:126
switch_memory_pool_t
struct apr_pool_t switch_memory_pool_t
Definition: switch_types.h:2155
chat_thread_start
static void chat_thread_start(int idx)
Definition: switch_loadable_module.c:750
SWITCH_STATUS_SUCCESS
Definition: switch_types.h:1155
switch_application_interface::next
struct switch_application_interface * next
Definition: switch_module_interfaces.h:777
switch_loadable_module_interface::pool
switch_memory_pool_t * pool
Definition: switch_loadable_module.h:92
switch_thread_rwlock_create
switch_status_t switch_thread_rwlock_create(switch_thread_rwlock_t **rwlock, switch_memory_pool_t *pool)
Definition: switch_apr.c:212
switch_test_flag
#define switch_test_flag(obj, flag)
Test for the existance of a flag on an arbitary object.
Definition: switch_utils.h:624
switch_loadable_module_function_table::shutdown
switch_module_shutdown_t shutdown
Definition: switch_types.h:2449
switch_speech_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:479
switch_log_printf
void switch_log_printf(_In_ switch_text_channel_t channel, _In_z_ const char *file, _In_z_ const char *func, _In_ int line, _In_opt_z_ const char *userdata, _In_ switch_log_level_t level, _In_z_ _Printf_format_string_ const char *fmt,...) PRINTF_FUNCTION(7
Write log data to the logging engine.
switch_stristr
const char * switch_stristr(const char *instr, const char *str)
Definition: switch_utils.c:1479
SWITCH_CURRENT_APPLICATION_VARIABLE
#define SWITCH_CURRENT_APPLICATION_VARIABLE
Definition: switch_types.h:140
switch_threadattr_create
switch_status_t switch_threadattr_create(switch_threadattr_t **new_attr, switch_memory_pool_t *pool)
Definition: switch_apr.c:642
switch_thread_create
switch_status_t switch_thread_create(switch_thread_t **new_thread, switch_threadattr_t *attr, switch_thread_start_t func, void *data, switch_memory_pool_t *cont)
Definition: switch_apr.c:675
switch_codec_implementation
A table of settings and callbacks that define a paticular implementation of a codec.
Definition: switch_module_interfaces.h:695
PROTECT_INTERFACE
#define PROTECT_INTERFACE(_it)
Definition: switch_module_interfaces.h:836
switch_codec_implementation::iananame
char * iananame
Definition: switch_module_interfaces.h:701
switch_json_api_interface
A module interface to implement a json api function.
Definition: switch_module_interfaces.h:820
switch_dso_lib_t
void * switch_dso_lib_t
Definition: switch_dso.h:30
switch_file_node_s::ptr
const switch_file_interface_t * ptr
Definition: switch_loadable_module.c:45
switch_say_file_handle_destroy
void switch_say_file_handle_destroy(switch_say_file_handle_t **sh)
Definition: switch_loadable_module.c:2743
switch_limit_interface::next
struct switch_limit_interface * next
Definition: switch_module_interfaces.h:596
switch_loadable_module_interface::api_interface
switch_api_interface_t * api_interface
Definition: switch_loadable_module.h:71
switch_thread_rwlock_trywrlock_timeout
switch_status_t switch_thread_rwlock_trywrlock_timeout(switch_thread_rwlock_t *rwlock, int timeout)
Definition: switch_apr.c:247
switch_file_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:271
switch_chat_application_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:783
SWITCH_STACK_BOTTOM
Definition: switch_types.h:1124
switch_queue_create
switch_status_t switch_queue_create(switch_queue_t **queue, unsigned int queue_capacity, switch_memory_pool_t *pool)
Definition: switch_apr.c:1109
switch_core_set_signal_handlers
void switch_core_set_signal_handlers(void)
Definition: switch_core.c:2494
switch_event_destroy
void switch_event_destroy(switch_event_t **event)
Destroy an event.
Definition: switch_event.c:1231
switch_json_api_interface::function
switch_json_api_function_t function
Definition: switch_module_interfaces.h:826
switch_vsnprintf
int switch_vsnprintf(char *buf, switch_size_t len, const char *format, va_list ap)
Definition: switch_apr.c:194
filename
char * filename
Definition: switch_loadable_module.h:331
switch_loadable_module_interface::asr_interface
switch_asr_interface_t * asr_interface
Definition: switch_loadable_module.h:85
switch_core_sprintf
char * switch_core_sprintf(_In_ switch_memory_pool_t *pool, _In_z_ _Printf_format_string_ const char *fmt,...)
printf-style style printing routine. The data is output to a string allocated from the pool ...
switch_assert
#define switch_assert(expr)
Definition: switch_platform.h:338
switch_loadable_module_process
static switch_status_t switch_loadable_module_process(char *key, switch_loadable_module_t *new_module)
Definition: switch_loadable_module.c:146
switch_cut_path
const char * switch_cut_path(const char *in)
Create a pointer to the file name in a given file path eliminating the directory name.
Definition: switch_utils.c:2658
SWITCH_FALSE
Definition: switch_types.h:406
switch_loadable_module_interface::say_interface
switch_say_interface_t * say_interface
Definition: switch_loadable_module.h:83
switch_say_file_handle::cnt
int cnt
Definition: switch_loadable_module.c:2710
switch_loadable_module::switch_module_shutdown
switch_module_shutdown_t switch_module_shutdown
Definition: switch_loadable_module.c:65
switch_loadable_module_interface::chat_application_interface
switch_chat_application_interface_t * chat_application_interface
Definition: switch_loadable_module.h:69
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)
Definition: switch_loadable_module.c:2343
switch_file_interface::next
struct switch_file_interface * next
Definition: switch_module_interfaces.h:300
switch_core_hash_first
#define switch_core_hash_first(_h)
Definition: switch_core.h:1501
switch_file_interface::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_module_interfaces.h:296
switch_file_interface::extens
char ** extens
Definition: switch_module_interfaces.h:295
switch_mprintf
SWITCH_BEGIN_EXTERN_C char * switch_mprintf(const char *zFormat,...)
Definition: switch_mprintf.c:897
switch_directories::lib_dir
char * lib_dir
Definition: switch_types.h:532
switch_default_rate
uint32_t switch_default_rate(const char *name, uint32_t number)
Definition: switch_core.c:2037
switch_loadable_module_function_table::switch_api_version
int switch_api_version
Definition: switch_types.h:2447
memset
memset(buf, 0, buflen)
switch_loadable_module_container::management_hash
switch_hash_t * management_hash
Definition: switch_loadable_module.c:88
SWITCH_SPEECH_INTERFACE
Definition: switch_types.h:386
switch_loadable_module_container::speech_hash
switch_hash_t * speech_hash
Definition: switch_loadable_module.c:83
switch_core_hash_init_nocase
#define switch_core_hash_init_nocase(_hash)
Definition: switch_core.h:1391
switch_loadable_module_interface
The abstraction of a loadable module.
Definition: switch_loadable_module.h:55
switch_timer_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:235
do_shutdown
static switch_status_t do_shutdown(switch_loadable_module_t *module, switch_bool_t shutdown, switch_bool_t unload, switch_bool_t fail_if_busy, const char **err)
Definition: switch_loadable_module.c:1993
switch_directory_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:602
switch_loadable_module_create_interface
void * switch_loadable_module_create_interface(switch_loadable_module_interface_t *mod, switch_module_interface_name_t iname)
Definition: switch_loadable_module.c:2650
switch_loadable_module_container::json_api_hash
switch_hash_t * json_api_hash
Definition: switch_loadable_module.c:81
switch_directory_interface
Abstract interface to a directory module.
Definition: switch_module_interfaces.h:600
switch_asr_interface::next
struct switch_asr_interface * next
Definition: switch_module_interfaces.h:436
switch_thread_rwlock_trywrlock
switch_status_t switch_thread_rwlock_trywrlock(switch_thread_rwlock_t *rwlock)
Definition: switch_apr.c:242
switch_dir_close
switch_status_t switch_dir_close(switch_dir_t *thedir)
Definition: switch_apr.c:559
switch_loadable_module_container::dialplan_hash
switch_hash_t * dialplan_hash
Definition: switch_loadable_module.c:76
switch_file_node_t
struct switch_file_node_s switch_file_node_t
Generated on Mon Apr 18 2016 13:05:00 for FreeSWITCH API Documentation by   doxygen 1.8.8