| File: | mod_dialplan_asterisk.c |
| Warning: | line 224, column 12 Although the value stored to 'proceed' is used in the enclosing expression, the value is never actually read from 'proceed' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 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 | * |
| 28 | * mod_dialplan_asterisk.c -- Asterisk extensions.conf style dialplan parser. |
| 29 | * |
| 30 | */ |
| 31 | #include <switch.h> |
| 32 | #include <sys/types.h> |
| 33 | #include <sys/stat.h> |
| 34 | #include <fcntl.h> |
| 35 | |
| 36 | SWITCH_MODULE_LOAD_FUNCTION(mod_dialplan_asterisk_load)switch_status_t mod_dialplan_asterisk_load (switch_loadable_module_interface_t **module_interface, switch_memory_pool_t *pool); |
| 37 | SWITCH_MODULE_DEFINITION(mod_dialplan_asterisk, mod_dialplan_asterisk_load, NULL, NULL)static const char modname[] = "mod_dialplan_asterisk" ; __attribute__ ((visibility("default"))) switch_loadable_module_function_table_t mod_dialplan_asterisk_module_interface = { 5, mod_dialplan_asterisk_load , ((void*)0), ((void*)0), SMODF_NONE }; |
| 38 | |
| 39 | static switch_status_t exec_app(switch_core_session_t *session, char *app, char *arg) |
| 40 | { |
| 41 | switch_application_interface_t *application_interface; |
| 42 | switch_status_t status = SWITCH_STATUS_FALSE; |
| 43 | |
| 44 | if ((application_interface = switch_loadable_module_get_application_interface(app))) { |
| 45 | status = switch_core_session_exec(session, application_interface, arg); |
| 46 | UNPROTECT_INTERFACE(application_interface)if (application_interface) {switch_mutex_lock(application_interface ->reflock); application_interface->refs--; application_interface ->parent->refs--; switch_mutex_unlock(application_interface ->reflock); switch_thread_rwlock_unlock(application_interface ->rwlock); switch_thread_rwlock_unlock(application_interface ->parent->rwlock);}; |
| 47 | } |
| 48 | |
| 49 | return status; |
| 50 | } |
| 51 | |
| 52 | SWITCH_STANDARD_APP(dial_function)static void dial_function (switch_core_session_t *session, const char *data) |
| 53 | { |
| 54 | int argc; |
| 55 | char *argv[4] = { 0 }; |
| 56 | char *mydata; |
| 57 | switch_channel_t *channel = switch_core_session_get_channel(session); |
| 58 | |
| 59 | if (data && (mydata = switch_core_session_strdup(session, data)switch_core_perform_session_strdup(session, data, "mod_dialplan_asterisk.c" , (const char *)__func__, 59))) { |
| 60 | if ((argc = switch_separate_string(mydata, '|', argv, (sizeof(argv) / sizeof(argv[0])))) < 2) { |
| 61 | goto error; |
| 62 | } |
| 63 | |
| 64 | if (argc > 1) { |
| 65 | switch_channel_set_variable(channel, "call_timeout", argv[1])switch_channel_set_variable_var_check(channel, "call_timeout" , argv[1], SWITCH_TRUE); |
| 66 | } |
| 67 | |
| 68 | switch_replace_char(argv[0], '&', ',', SWITCH_FALSE); |
| 69 | |
| 70 | if (exec_app(session, "bridge", argv[0]) != SWITCH_STATUS_SUCCESS) { |
| 71 | goto error; |
| 72 | } |
| 73 | |
| 74 | goto ok; |
| 75 | } |
| 76 | |
| 77 | error: |
| 78 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 78, ((void*)0), SWITCH_LOG_ERROR, "Error!\n"); |
| 79 | |
| 80 | ok: |
| 81 | |
| 82 | return; |
| 83 | } |
| 84 | |
| 85 | SWITCH_STANDARD_APP(avoid_function)static void avoid_function (switch_core_session_t *session, const char *data) |
| 86 | { |
| 87 | #if 0 |
| 88 | void *y = NULL((void*)0); |
| 89 | #endif |
| 90 | int x = 0; |
| 91 | switch_channel_t *channel = switch_core_session_get_channel(session); |
| 92 | |
| 93 | for (x = 0; x < 5; x++) { |
| 94 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 94, ((void*)0), SWITCH_LOG_WARNING, "Avoiding initial deadlock on channel %s.\n", switch_channel_get_name(channel)); |
| 95 | switch_yield(100000)switch_sleep(100000);; |
| 96 | } |
| 97 | |
| 98 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 98, ((void*)0), SWITCH_LOG_WARNING, "I should never be called!.\n"); |
| 99 | #if 0 |
| 100 | memset((void *) y, 0, 1000); |
| 101 | #endif |
| 102 | } |
| 103 | |
| 104 | SWITCH_STANDARD_APP(goto_function)static void goto_function (switch_core_session_t *session, const char *data) |
| 105 | { |
| 106 | char *argv[3] = { 0 }; |
| 107 | char *mydata; |
| 108 | |
| 109 | if (data && (mydata = switch_core_session_strdup(session, data)switch_core_perform_session_strdup(session, data, "mod_dialplan_asterisk.c" , (const char *)__func__, 109))) { |
| 110 | if (switch_separate_string(mydata, '|', argv, (sizeof(argv) / sizeof(argv[0]))) < 1) { |
| 111 | goto error; |
| 112 | } |
| 113 | |
| 114 | switch_ivr_session_transfer(session, argv[1], "asterisk", argv[0]); |
| 115 | goto ok; |
| 116 | } |
| 117 | |
| 118 | error: |
| 119 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 119, ((void*)0), SWITCH_LOG_ERROR, "Error!\n"); |
| 120 | |
| 121 | ok: |
| 122 | |
| 123 | return; |
| 124 | } |
| 125 | |
| 126 | SWITCH_STANDARD_DIALPLAN(asterisk_dialplan_hunt)static switch_caller_extension_t *asterisk_dialplan_hunt (switch_core_session_t *session, void *arg, switch_caller_profile_t *caller_profile ) |
| 127 | { |
| 128 | switch_caller_extension_t *extension = NULL((void*)0); |
| 129 | switch_channel_t *channel = switch_core_session_get_channel(session); |
| 130 | char *cf = "extensions.conf"; |
| 131 | switch_config_t cfg; |
| 132 | char *var, *val; |
| 133 | const char *context = NULL((void*)0); |
| 134 | |
| 135 | if (arg) { |
| 136 | cf = arg; |
| 137 | } |
| 138 | |
| 139 | if (!caller_profile) { |
| 140 | caller_profile = switch_channel_get_caller_profile(channel); |
| 141 | } |
| 142 | |
| 143 | if (!caller_profile || zstr(caller_profile->destination_number)_zstr(caller_profile->destination_number)) { |
| 144 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 144, ((void*)0), SWITCH_LOG_ERROR, "Error Obtaining Profile!\n"); |
| 145 | |
| 146 | return NULL((void*)0); |
| 147 | } |
| 148 | |
| 149 | context = caller_profile->context ? caller_profile->context : "default"; |
| 150 | |
| 151 | if (!switch_config_open_file(&cfg, cf)) { |
| 152 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 152, ((void*)0), SWITCH_LOG_ERROR, "Open of %s failed\n", cf); |
| 153 | switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "mod_dialplan_asterisk.c" , (const char *)__func__, 153, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER ); |
| 154 | |
| 155 | return NULL((void*)0); |
| 156 | } |
| 157 | |
| 158 | while (switch_config_next_pair(&cfg, &var, &val)) { |
| 159 | if (!strcasecmp(cfg.category, context)) { |
| 160 | char *field_expanded = NULL((void*)0); |
| 161 | |
| 162 | if (!strcasecmp(var, "include")) { |
| 163 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 163, ((void*)0), SWITCH_LOG_ERROR, "param '%s' not implemented at line %d!\n", var, cfg.lineno); |
| 164 | } else { |
| 165 | int argc; |
| 166 | char *argv[3] = { 0 }; |
| 167 | char *pattern = NULL((void*)0); |
| 168 | char *app = NULL((void*)0); |
| 169 | char *argument = NULL((void*)0); |
| 170 | char *expression = NULL((void*)0), expression_buf[1024] = { 0 }; |
| 171 | char substituted[2048] = ""; |
| 172 | const char *field_data = caller_profile->destination_number; |
| 173 | int proceed = 0; |
| 174 | switch_regex_t *re = NULL((void*)0); |
| 175 | switch_regex_match_data_t *match_data = NULL((void*)0); |
| 176 | char *cid = NULL((void*)0); |
| 177 | |
| 178 | expression = expression_buf; |
| 179 | |
| 180 | argc = switch_separate_string(val, ',', argv, (sizeof(argv) / sizeof(argv[0]))); |
| 181 | if (argc < 3) { |
| 182 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 182, ((void*)0), SWITCH_LOG_ERROR, "Parse error line %d!\n", cfg.lineno); |
| 183 | continue; |
| 184 | } |
| 185 | |
| 186 | pattern = argv[0]; |
| 187 | |
| 188 | if (!strcasecmp(var, "exten")) { |
| 189 | char *p; |
| 190 | if (pattern && (p = strchr(pattern, '/'))) { |
| 191 | *p++ = '\0'; |
| 192 | cid = pattern; |
| 193 | pattern = p; |
| 194 | } |
| 195 | } else { |
| 196 | if (strchr(var, '$')) { |
| 197 | if ((field_expanded = switch_channel_expand_variables(channel, var)switch_channel_expand_variables_check(channel, var, ((void*)0 ), ((void*)0), 0)) == var) { |
| 198 | field_expanded = NULL((void*)0); |
| 199 | field_data = var; |
| 200 | } else { |
| 201 | field_data = field_expanded; |
| 202 | } |
| 203 | } else { |
| 204 | field_data = switch_caller_get_field_by_name(caller_profile, var); |
| 205 | } |
| 206 | } |
| 207 | |
| 208 | if (pattern && (*pattern == '_' || *pattern == '~')) { |
| 209 | if (*pattern == '_') { |
| 210 | pattern++; |
| 211 | if (switch_ast2regex(pattern, expression_buf, sizeof(expression_buf))) { |
| 212 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 212, ((void*)0), SWITCH_LOG_DEBUG, "Converting [%s] to real regex [%s] you should try them!\n", |
| 213 | pattern, expression_buf); |
| 214 | } |
| 215 | } else { |
| 216 | pattern++; |
| 217 | expression = pattern; |
| 218 | } |
| 219 | |
| 220 | if (!field_data) { |
| 221 | field_data = ""; |
| 222 | } |
| 223 | |
| 224 | if (!(proceed = switch_regex_perform(field_data, expression, &re, &match_data))) { |
Although the value stored to 'proceed' is used in the enclosing expression, the value is never actually read from 'proceed' | |
| 225 | switch_regex_safe_free(re, match_data)if (re) { switch_regex_match_free(match_data); switch_regex_free (re); re = ((void*)0); }; |
| 226 | switch_safe_free(field_expanded)if (field_expanded) {free(field_expanded);field_expanded=((void *)0);}; |
| 227 | continue; |
| 228 | } |
| 229 | } else { |
| 230 | if (pattern && strcasecmp(pattern, field_data)) { |
| 231 | switch_safe_free(field_expanded)if (field_expanded) {free(field_expanded);field_expanded=((void *)0);}; |
| 232 | continue; |
| 233 | } |
| 234 | } |
| 235 | |
| 236 | if (cid) { |
| 237 | if (strcasecmp(cid, caller_profile->caller_id_number)) { |
| 238 | switch_safe_free(field_expanded)if (field_expanded) {free(field_expanded);field_expanded=((void *)0);}; |
| 239 | continue; |
| 240 | } |
| 241 | } |
| 242 | |
| 243 | switch_channel_set_variable(channel, "EXTEN", caller_profile->destination_number)switch_channel_set_variable_var_check(channel, "EXTEN", caller_profile ->destination_number, SWITCH_TRUE); |
| 244 | switch_channel_set_variable(channel, "CHANNEL", switch_channel_get_name(channel))switch_channel_set_variable_var_check(channel, "CHANNEL", switch_channel_get_name (channel), SWITCH_TRUE); |
| 245 | switch_channel_set_variable(channel, "UNIQUEID", switch_core_session_get_uuid(session))switch_channel_set_variable_var_check(channel, "UNIQUEID", switch_core_session_get_uuid (session), SWITCH_TRUE); |
| 246 | |
| 247 | //pri = argv[1]; |
| 248 | app = argv[2]; |
| 249 | |
| 250 | if ((argument = strchr(app, '('))) { |
| 251 | char *p; |
| 252 | *argument++ = '\0'; |
| 253 | p = strrchr(argument, ')'); |
| 254 | if (p) { |
| 255 | *p = '\0'; |
| 256 | } |
| 257 | } else if ((argument = strchr(app, ','))) { |
| 258 | *argument++ = '\0'; |
| 259 | } |
| 260 | |
| 261 | if (!argument) { |
| 262 | argument = ""; |
| 263 | } |
| 264 | |
| 265 | if (!field_data) { |
| 266 | field_data = ""; |
| 267 | } |
| 268 | |
| 269 | if (strchr(expression, '(')) { |
| 270 | switch_perform_substitution(match_data, argument, substituted, sizeof(substituted)); |
| 271 | argument = substituted; |
| 272 | } |
| 273 | |
| 274 | switch_regex_safe_free(re, match_data)if (re) { switch_regex_match_free(match_data); switch_regex_free (re); re = ((void*)0); }; |
| 275 | |
| 276 | if (!extension) { |
| 277 | if (zstr(field_data)_zstr(field_data)) { |
| 278 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 278, ((void*)0), SWITCH_LOG_CRIT, "No extension!\n"); |
| 279 | switch_safe_free(field_expanded)if (field_expanded) {free(field_expanded);field_expanded=((void *)0);}; |
| 280 | break; |
| 281 | } |
| 282 | |
| 283 | if ((extension = switch_caller_extension_new(session, field_data, field_data)) == 0) { |
| 284 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 284, ((void*)0), SWITCH_LOG_CRIT, "Memory Error!\n"); |
| 285 | switch_safe_free(field_expanded)if (field_expanded) {free(field_expanded);field_expanded=((void *)0);}; |
| 286 | break; |
| 287 | } |
| 288 | } |
| 289 | |
| 290 | switch_caller_extension_add_application(session, extension, app, argument); |
| 291 | } |
| 292 | |
| 293 | switch_safe_free(field_expanded)if (field_expanded) {free(field_expanded);field_expanded=((void *)0);}; |
| 294 | } |
| 295 | } |
| 296 | |
| 297 | switch_config_close_file(&cfg); |
| 298 | |
| 299 | return extension; |
| 300 | } |
| 301 | |
| 302 | /* fake chan_sip */ |
| 303 | switch_endpoint_interface_t *sip_endpoint_interface; |
| 304 | static switch_call_cause_t sip_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, |
| 305 | switch_caller_profile_t *outbound_profile, |
| 306 | switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, |
| 307 | switch_call_cause_t *cancel_cause); |
| 308 | switch_io_routines_t sip_io_routines = { |
| 309 | /*.outgoing_channel */ sip_outgoing_channel |
| 310 | }; |
| 311 | |
| 312 | static switch_call_cause_t sip_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, |
| 313 | switch_caller_profile_t *outbound_profile, |
| 314 | switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, |
| 315 | switch_call_cause_t *cancel_cause) |
| 316 | { |
| 317 | const char *profile; |
| 318 | char *dup_profile = NULL((void*)0); |
| 319 | |
| 320 | if (session) { |
| 321 | profile = switch_channel_get_variable(switch_core_session_get_channel(session), "sip_profile")switch_channel_get_variable_dup(switch_core_session_get_channel (session), "sip_profile", SWITCH_TRUE, -1); |
| 322 | } else { |
| 323 | dup_profile = switch_core_get_variable_dup("sip_profile"); |
| 324 | profile = dup_profile; |
| 325 | } |
| 326 | if (zstr(profile)_zstr(profile)) { |
| 327 | profile = "default"; |
| 328 | } |
| 329 | |
| 330 | outbound_profile->destination_number = switch_core_sprintf(outbound_profile->pool, "%s/%s", profile, outbound_profile->destination_number); |
| 331 | |
| 332 | UNPROTECT_INTERFACE(sip_endpoint_interface)if (sip_endpoint_interface) {switch_mutex_lock(sip_endpoint_interface ->reflock); sip_endpoint_interface->refs--; sip_endpoint_interface ->parent->refs--; switch_mutex_unlock(sip_endpoint_interface ->reflock); switch_thread_rwlock_unlock(sip_endpoint_interface ->rwlock); switch_thread_rwlock_unlock(sip_endpoint_interface ->parent->rwlock);}; |
| 333 | |
| 334 | switch_safe_free(dup_profile)if (dup_profile) {free(dup_profile);dup_profile=((void*)0);}; |
| 335 | |
| 336 | return switch_core_session_outgoing_channel(session, var_event, "sofia", outbound_profile, new_session, pool, SOF_NONE, cancel_cause); |
| 337 | } |
| 338 | |
| 339 | |
| 340 | |
| 341 | |
| 342 | /* fake chan_iax2 */ |
| 343 | switch_endpoint_interface_t *iax2_endpoint_interface; |
| 344 | static switch_call_cause_t iax2_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, |
| 345 | switch_caller_profile_t *outbound_profile, |
| 346 | switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, |
| 347 | switch_call_cause_t *cancel_cause); |
| 348 | switch_io_routines_t iax2_io_routines = { |
| 349 | /*.outgoing_channel */ iax2_outgoing_channel |
| 350 | }; |
| 351 | |
| 352 | static switch_call_cause_t iax2_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, |
| 353 | switch_caller_profile_t *outbound_profile, |
| 354 | switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, |
| 355 | switch_call_cause_t *cancel_cause) |
| 356 | { |
| 357 | UNPROTECT_INTERFACE(iax2_endpoint_interface)if (iax2_endpoint_interface) {switch_mutex_lock(iax2_endpoint_interface ->reflock); iax2_endpoint_interface->refs--; iax2_endpoint_interface ->parent->refs--; switch_mutex_unlock(iax2_endpoint_interface ->reflock); switch_thread_rwlock_unlock(iax2_endpoint_interface ->rwlock); switch_thread_rwlock_unlock(iax2_endpoint_interface ->parent->rwlock);}; |
| 358 | |
| 359 | return switch_core_session_outgoing_channel(session, var_event, "iax", outbound_profile, new_session, pool, SOF_NONE, cancel_cause); |
| 360 | } |
| 361 | |
| 362 | SWITCH_MODULE_LOAD_FUNCTION(mod_dialplan_asterisk_load)switch_status_t mod_dialplan_asterisk_load (switch_loadable_module_interface_t **module_interface, switch_memory_pool_t *pool) |
| 363 | { |
| 364 | switch_dialplan_interface_t *dp_interface; |
| 365 | switch_application_interface_t *app_interface; |
| 366 | int x = 0; |
| 367 | |
| 368 | /* connect my internal structure to the blank pointer passed to me */ |
| 369 | *module_interface = switch_loadable_module_create_module_interface(pool, modname); |
| 370 | /* add a dialplan interface */ |
| 371 | SWITCH_ADD_DIALPLAN(dp_interface, "asterisk", asterisk_dialplan_hunt)for (;;) { dp_interface = (switch_dialplan_interface_t *)switch_loadable_module_create_interface (*module_interface, SWITCH_DIALPLAN_INTERFACE); dp_interface-> hunt_function = asterisk_dialplan_hunt; dp_interface->interface_name = "asterisk"; break; }; |
| 372 | |
| 373 | /* a few fake apps for the sake of emulation */ |
| 374 | SWITCH_ADD_APP(app_interface, "Dial", "Dial", "Dial", dial_function, "Dial", SAF_SUPPORT_NOMEDIA)for (;;) { app_interface = (switch_application_interface_t *) switch_loadable_module_create_interface(*module_interface, SWITCH_APPLICATION_INTERFACE ); app_interface->interface_name = "Dial"; app_interface-> application_function = dial_function; app_interface->short_desc = "Dial"; app_interface->long_desc = "Dial"; app_interface ->syntax = "Dial"; app_interface->flags = SAF_SUPPORT_NOMEDIA ; break; }; |
| 375 | SWITCH_ADD_APP(app_interface, "Goto", "Goto", "Goto", goto_function, "Goto", SAF_SUPPORT_NOMEDIA)for (;;) { app_interface = (switch_application_interface_t *) switch_loadable_module_create_interface(*module_interface, SWITCH_APPLICATION_INTERFACE ); app_interface->interface_name = "Goto"; app_interface-> application_function = goto_function; app_interface->short_desc = "Goto"; app_interface->long_desc = "Goto"; app_interface ->syntax = "Goto"; app_interface->flags = SAF_SUPPORT_NOMEDIA ; break; }; |
| 376 | SWITCH_ADD_APP(app_interface, "AvoidingDeadlock", "Avoid", "Avoid", avoid_function, "Avoid", SAF_SUPPORT_NOMEDIA)for (;;) { app_interface = (switch_application_interface_t *) switch_loadable_module_create_interface(*module_interface, SWITCH_APPLICATION_INTERFACE ); app_interface->interface_name = "AvoidingDeadlock"; app_interface ->application_function = avoid_function; app_interface-> short_desc = "Avoid"; app_interface->long_desc = "Avoid"; app_interface ->syntax = "Avoid"; app_interface->flags = SAF_SUPPORT_NOMEDIA ; break; }; |
| 377 | |
| 378 | /* fake chan_sip facade */ |
| 379 | sip_endpoint_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE); |
| 380 | sip_endpoint_interface->interface_name = "SIP"; |
| 381 | sip_endpoint_interface->io_routines = &sip_io_routines; |
| 382 | |
| 383 | /* fake chan_iax2 facade */ |
| 384 | iax2_endpoint_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE); |
| 385 | iax2_endpoint_interface->interface_name = "IAX2"; |
| 386 | iax2_endpoint_interface->io_routines = &iax2_io_routines; |
| 387 | |
| 388 | if (getenv("FAITHFUL_EMULATION")) { |
| 389 | for (x = 0; x < 10; x++) { |
| 390 | switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "mod_dialplan_asterisk.c", (const char *)__func__, 390, ((void*)0), SWITCH_LOG_WARNING, "Avoiding Deadlock.\n"); |
| 391 | switch_yield(100000)switch_sleep(100000);; |
| 392 | } |
| 393 | } |
| 394 | |
| 395 | /* indicate that the module should continue to be loaded */ |
| 396 | return SWITCH_STATUS_SUCCESS; |
| 397 | } |
| 398 | |
| 399 | /* For Emacs: |
| 400 | * Local Variables: |
| 401 | * mode:c |
| 402 | * indent-tabs-mode:t |
| 403 | * tab-width:4 |
| 404 | * c-basic-offset:4 |
| 405 | * End: |
| 406 | * For VIM: |
| 407 | * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet: |
| 408 | */ |