retronetworking
/
freeswitch
13
0
Fork 0
Code Pull Requests Releases Activity
freeswitch/src/mod/applications/mod_translate/mod_translate.c

431 lines
14 KiB
C
Raw Blame History

/*
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
*
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
*
* The Initial Developer of the Original Code is
* Anthony Minessale II <anthm@freeswitch.org>
* Portions created by the Initial Developer are Copyright (C)
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Anthony Minessale II <anthm@freeswitch.org>
* Raymond Chandler <intralanman@freeswitch.org>
*
* mod_translate.c -- TRANSLATE
*
*/
#include <switch.h>
SWITCH_MODULE_LOAD_FUNCTION(mod_translate_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_translate_shutdown);
SWITCH_MODULE_DEFINITION(mod_translate, mod_translate_load, mod_translate_shutdown, NULL);
static switch_mutex_t *MUTEX = NULL;
static struct {
switch_memory_pool_t *pool;
switch_hash_t *translate_profiles;
switch_thread_rwlock_t *profile_hash_rwlock;
} globals;
struct rule {
char *regex;
char *replace;
struct rule *next;
};
typedef struct rule translate_rule_t;
static switch_event_node_t *NODE = NULL;
static switch_status_t load_config(void)
{
char *cf = "translate.conf";
switch_xml_t cfg, xml, rule, profile, profiles;
switch_status_t status = SWITCH_STATUS_SUCCESS;
if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", cf);
status = SWITCH_STATUS_FALSE;
goto done;
}
if ((profiles = switch_xml_child(cfg, "profiles"))) {
for (profile = switch_xml_child(profiles, "profile"); profile; profile = profile->next) {
translate_rule_t *rules_list = NULL;
char *name = (char *) switch_xml_attr_soft(profile, "name");
if (!name) {
continue;
}
for (rule = switch_xml_child(profile, "rule"); rule; rule = rule->next) {
char *regex = (char *) switch_xml_attr_soft(rule, "regex");
char *replace = (char *) switch_xml_attr_soft(rule, "replace");
if (regex && replace) {
translate_rule_t *this_rule = NULL, *rl = NULL;
this_rule = switch_core_alloc(globals.pool, sizeof(translate_rule_t));
this_rule->regex = switch_core_strdup(globals.pool, regex);
this_rule->replace = switch_core_strdup(globals.pool, replace);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Replace number matching [%s] with [%s]\n", regex, replace);
if (rules_list == NULL) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "starting with an empty list\n");
rules_list = this_rule;
} else {
for (rl = rules_list; rl && rl->next; rl = rl->next);
rl->next = this_rule;
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Translation!\n");
}
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding rules to profile [%s]\n", name);
switch_core_hash_insert_wrlock(globals.translate_profiles, name, rules_list, globals.profile_hash_rwlock);
}
}
done:
if (xml) {
switch_xml_free(xml);
}
return status;
}
static void translate_number(char *number, char *profile, char **translated, switch_core_session_t *session, switch_event_t *event, switch_memory_pool_t *pool)
{
translate_rule_t *hi = NULL;
translate_rule_t *rule = NULL;
switch_regex_t *re = NULL;
int proceed = 0, ovector[30];
char *substituted = NULL, *subbed = NULL;
uint32_t len = 0;
if (!profile) {
profile = "US";
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "translating [%s] against [%s] profile\n", number, profile);
hi = switch_core_hash_find_rdlock(globals.translate_profiles, (const char *)profile, globals.profile_hash_rwlock);
if (!hi) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "can't find key for profile matching [%s]\n", profile);
return;
}
for (rule = hi; rule; rule = rule->next) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s =~ /%s/\n", number, rule->regex);
if ((proceed = switch_regex_perform(number, rule->regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
len = (uint32_t) (strlen(number) + strlen(rule->replace) + 10) * proceed;
if (!(substituted = malloc(len))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
switch_regex_safe_free(re);
goto end;
}
memset(substituted, 0, len);
switch_perform_substitution(re, proceed, rule->replace, number, substituted, len, ovector);
if ((switch_string_var_check_const(substituted) || switch_string_has_escaped_data(substituted))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "perform variable expansion\n");
if (session) {
subbed = switch_channel_expand_variables(switch_core_session_get_channel(session), substituted);
} else if (event) {
subbed = switch_event_expand_headers(event, substituted);
}
if (session) {
substituted = switch_core_session_strdup(session, subbed);
} else {
substituted = switch_core_strdup(pool, subbed);
}
if (subbed != substituted) {
switch_safe_free(subbed);
}
}
break;
}
}
end:
*translated = substituted ? substituted : NULL;
}
static void do_unload(void) {
switch_hash_index_t *hi = NULL;
switch_mutex_lock(MUTEX);
while ((hi = switch_core_hash_first_iter( globals.translate_profiles, hi))) {
void *val = NULL;
const void *key;
switch_ssize_t keylen;
translate_rule_t *rl = NULL, *nrl;
switch_core_hash_this(hi, &key, &keylen, &val);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "deleting translate profile [%s]\n", (char *) key);
for (nrl = val; rl;) {
rl = nrl;
nrl = nrl->next;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "deleting rule for [%s]\n", rl->regex);
switch_safe_free(rl->regex);
switch_safe_free(rl->replace);
switch_safe_free(rl);
}
switch_core_hash_delete_wrlock(globals.translate_profiles, key, globals.profile_hash_rwlock);
}
switch_thread_rwlock_destroy(globals.profile_hash_rwlock);
switch_core_hash_destroy(&globals.translate_profiles);
switch_mutex_unlock(MUTEX);
}
static void do_load(void)
{
switch_mutex_lock(MUTEX);
switch_core_hash_init(&globals.translate_profiles);
switch_thread_rwlock_create(&globals.profile_hash_rwlock, globals.pool);
load_config();
switch_mutex_unlock(MUTEX);
}
static void event_handler(switch_event_t *event)
{
switch_mutex_lock(MUTEX);
do_unload();
do_load();
switch_mutex_unlock(MUTEX);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Number Translations Reloaded\n");
}
SWITCH_STANDARD_APP(translate_app_function)
{
int argc = 0;
char *argv[32] = { 0 };
char *mydata = NULL;
char *translated = NULL;
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_memory_pool_t *pool = NULL;
switch_event_t *event = NULL;
switch_assert(session);
if (!(mydata = switch_core_session_strdup(session, data))) {
goto end;
}
if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
char *areacode = switch_core_get_variable("default_areacode");
if (session) {
pool = switch_core_session_get_pool(session);
} else {
switch_core_new_memory_pool(&pool);
switch_event_create(&event, SWITCH_EVENT_MESSAGE);
if (zstr(areacode)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "no default_areacode set, using default of 777\n");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "areacode", "777");
} else {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "areacode", areacode);
}
}
translate_number(argv[0], argv[1], &translated, session, event, NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Translated: %s\n", translated);
switch_channel_set_variable_var_check(channel, "translated", translated, SWITCH_FALSE);
}
end:
if (pool) {
switch_core_destroy_memory_pool(&pool);
}
return;
}
SWITCH_STANDARD_DIALPLAN(translate_dialplan_hunt)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
char *translated_dest = NULL;
char *translated_cid_num = NULL;
char *translate_profile = NULL;
char *areacode = NULL;
switch_event_t *event = NULL;
if (!caller_profile) {
if (!(caller_profile = switch_channel_get_caller_profile(channel))) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error Obtaining Profile!\n");
goto done;
}
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Processing %s <%s>->%s in translate\n",
caller_profile->caller_id_name, caller_profile->caller_id_number, caller_profile->destination_number);
if ((translate_profile = (char *) switch_channel_get_variable(channel, "translate_profile"))) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "using translate_profile variable [%s] for translate profile\n", translate_profile);
} else if ((translate_profile = (char *) switch_channel_get_variable(channel, "country"))) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "using country variable [%s] for translate profile\n", translate_profile);
} else if ((translate_profile = (char *) switch_channel_get_variable(channel, "default_country"))) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "using default_country variable [%s] for translate profile\n", translate_profile);
} else {
translate_profile = "US";
}
areacode = (char *) switch_channel_get_variable(channel, "areacode");
if (zstr(areacode)) {
areacode = (char *) switch_channel_get_variable(channel, "default_areacode");
if (!zstr(areacode)) {
switch_channel_set_variable_safe(channel, "areacode", areacode);
}
}
translate_number((char *) caller_profile->destination_number, translate_profile, &translated_dest, session, event, NULL);
translate_number((char *) caller_profile->caller_id_number, translate_profile, &translated_cid_num, session, event, NULL);
/* maybe we should translate ani/aniii here too? */
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO,
"Profile: [%s] Translated Destination: [%s] Translated CID: [%s]\n", translate_profile, translated_dest, translated_cid_num);
if (!zstr(translated_cid_num)) {
caller_profile->caller_id_number = translated_cid_num;
}
if (!zstr(translated_dest)) {
caller_profile->destination_number = translated_dest;
}
done:
return NULL;
}
#define TRANSLATE_SYNTAX "translate <number> [<profile>]"
SWITCH_STANDARD_API(translate_function)
{
char *mydata = NULL;
switch_memory_pool_t *pool = NULL;
char *translated = NULL;
switch_event_t *event = NULL;
char *argv[32] = { 0 };
int argc = 0;
if (zstr(cmd)) {
goto usage;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s\n", cmd);
mydata = strdup(cmd);
if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
if (!session) {
char *areacode = switch_core_get_variable("default_areacode");
switch_core_new_memory_pool(&pool);
switch_event_create(&event, SWITCH_EVENT_REQUEST_PARAMS);
if (zstr(areacode)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "no default_areacode set, using default of 777\n");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "areacode", "777");
} else {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "areacode", areacode);
}
}
translate_number(argv[0], argv[1], &translated, session, event, pool);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Translated: %s\n", translated);
stream->write_function(stream, "%s", translated);
}
free(mydata);
end:
if (!session) {
if (pool) {
switch_core_destroy_memory_pool(&pool);
}
}
return SWITCH_STATUS_SUCCESS;
usage:
stream->write_function(stream, "USAGE: %s\n", TRANSLATE_SYNTAX);
goto end;
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_translate_shutdown)
{
switch_event_unbind(&NODE);
do_unload();
return SWITCH_STATUS_UNLOAD;
}
SWITCH_MODULE_LOAD_FUNCTION(mod_translate_load)
{
switch_api_interface_t *api_interface;
switch_application_interface_t *app_interface;
switch_dialplan_interface_t *dp_interface;
memset(&globals, 0, sizeof(globals));
globals.pool = pool;
switch_mutex_init(&MUTEX, SWITCH_MUTEX_NESTED, pool);
if ((switch_event_bind_removable(modname, SWITCH_EVENT_RELOADXML, NULL, event_handler, NULL, &NODE) != SWITCH_STATUS_SUCCESS)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind!\n");
return SWITCH_STATUS_TERM;
}
do_load();
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
SWITCH_ADD_API(api_interface, "translate", "TRANSLATE", translate_function, "");
SWITCH_ADD_APP(app_interface, "translate", "Perform an TRANSLATE lookup", "Translate a number based on predefined rules", translate_app_function, "<number> <profile>]",
SAF_SUPPORT_NOMEDIA | SAF_ROUTING_EXEC);
SWITCH_ADD_DIALPLAN(dp_interface, "translate", translate_dialplan_hunt);
return SWITCH_STATUS_SUCCESS;
}
/* For Emacs:
* Local Variables:
* mode:c
* indent-tabs-mode:t
* tab-width:4
* c-basic-offset:4
* End:
* For VIM:
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
*/
View Git Blame Copy Permalink