/* * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * Copyright (C) 2005-2012, Anthony Minessale II * * 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 * Portions created by the Initial Developer are Copyright (C) * the Initial Developer. All Rights Reserved. * * Contributor(s): * * Raymond Chandler * Rupa Schomaker * Emmanuel Schmidbauer * * mod_lcr.c -- Least Cost Routing Module * */ #include #define LCR_SYNTAX "lcr [] [caller_id] [intrastate] [as xml]" #define LCR_ADMIN_SYNTAX "lcr_admin show profiles" #define LCR_HEADERS_COUNT 7 #define LCR_HEADERS_DIGITS 0 #define LCR_HEADERS_CARRIER 1 #define LCR_HEADERS_RATE 2 #define LCR_HEADERS_DIALSTRING 3 #define LCR_HEADERS_CODEC 4 #define LCR_HEADERS_CID 5 #define LCR_HEADERS_LIMIT 6 static char headers[LCR_HEADERS_COUNT][32] = { "Digit Match", "Carrier", "Rate", "Dialstring", "Codec", "CID Regexp", "Limit", }; /* sql for random function */ static char *db_random = NULL; struct lcr_obj { char *carrier_name; char *gw_prefix; char *gw_suffix; char *digit_str; char *prefix; char *suffix; char *dialstring; float rate; char *rate_str; float user_rate; char *user_rate_str; size_t lstrip; size_t tstrip; size_t digit_len; char *codec; char *cid; char *limit_realm; char *limit_id; int limit_max; switch_event_t *fields; struct lcr_obj *prev; struct lcr_obj *next; }; struct max_obj { size_t carrier_name; size_t digit_str; size_t rate; size_t codec; size_t cid; size_t dialstring; size_t limit; }; typedef struct lcr_obj lcr_obj_t; typedef lcr_obj_t *lcr_route; typedef struct max_obj max_obj_t; typedef max_obj_t *max_len; struct profile_obj { char *name; uint16_t id; char *order_by; char *custom_sql; char *export_fields_str; int export_fields_cnt; char **export_fields; char *limit_type; switch_bool_t custom_sql_has_percent; switch_bool_t custom_sql_has_vars; switch_bool_t profile_has_intrastate; switch_bool_t profile_has_intralata; switch_bool_t profile_has_npanxx; switch_bool_t reorder_by_rate; switch_bool_t quote_in_list; switch_bool_t single_bridge; switch_bool_t info_in_headers; switch_bool_t enable_sip_redir; }; typedef struct profile_obj profile_t; struct callback_obj { lcr_route head; switch_hash_t *dedup_hash; int matches; switch_memory_pool_t *pool; char *lookup_number; char *lrn_number; char *cid; switch_bool_t intrastate; switch_bool_t intralata; profile_t *profile; switch_core_session_t *session; switch_event_t *event; float max_rate; }; typedef struct callback_obj callback_t; static struct { switch_memory_pool_t *pool; char *dbname; char *odbc_dsn; switch_mutex_t *mutex; switch_hash_t *profile_hash; profile_t *default_profile; void *filler1; } globals; SWITCH_MODULE_LOAD_FUNCTION(mod_lcr_load); SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_lcr_shutdown); SWITCH_MODULE_DEFINITION(mod_lcr, mod_lcr_load, mod_lcr_shutdown, NULL); static void lcr_destroy(lcr_route route) { while(route) { switch_event_destroy(&route->fields); route=route->next; } } static const char *do_cid(switch_memory_pool_t *pool, const char *cid, const char *number, switch_core_session_t *session) { switch_regex_t *re = NULL; int proceed = 0, ovector[30]; char *substituted = NULL; uint32_t len = 0; char *src = NULL; char *dst = NULL; char *tmp_regex = NULL; char *src_regex = NULL; char *dst_regex = NULL; switch_channel_t *channel = NULL; if (!zstr(cid)) { len = (uint32_t)strlen(cid); } else { goto done; } src = switch_core_strdup(pool, cid); /* check that this is a valid regexp and split the string */ if ((src[0] == '/') && src[len-1] == '/') { /* strip leading / trailing slashes */ src[len-1] = '\0'; src++; /* break on first / */ if((dst = strchr(src, '/'))) { *dst = '\0'; dst++; } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid destination part in regexp: %s\n", src); goto done; } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "src: %s, dst: %s\n", src, dst); } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Not a valid regexp: %s\n", src); goto done; } /* if a session is provided, check if the source part of the regex has any channel variables, then expand them */ if (session) { channel = switch_core_session_get_channel(session); switch_assert(channel); if (switch_string_var_check_const(src) || switch_string_has_escaped_data(src)) { tmp_regex = switch_channel_expand_variables(channel, src); src_regex = switch_core_strdup(pool, tmp_regex); switch_safe_free(tmp_regex); src = src_regex; } if (switch_string_var_check_const(dst) || switch_string_has_escaped_data(dst)) { tmp_regex = switch_channel_expand_variables(channel, dst); dst_regex = switch_core_strdup(pool, tmp_regex); switch_safe_free(tmp_regex); dst = dst_regex; } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "expanded src: %s, dst: %s\n", src, dst); } if ((proceed = switch_regex_perform(number, src, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) { len = (uint32_t) (strlen(src) + strlen(dst) + 10) * proceed; /* guestimate size */ if (!(substituted = switch_core_alloc(pool, len))) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Memory Error!\n"); goto done; } memset(substituted, 0, len); switch_perform_substitution(re, proceed, dst, number, substituted, len, ovector); } else { goto done; } switch_regex_safe_free(re); return substituted; done: switch_regex_safe_free(re); return number; } static char *get_bridge_data(switch_memory_pool_t *pool, char *dialed_number, char *caller_id, lcr_route cur_route, profile_t *profile, switch_core_session_t *session) { size_t lstrip; size_t tstrip; char *data = NULL; char *destination_number = NULL; char *codec = NULL; char *cid = NULL; char *header = NULL; char *user_rate = NULL; char *export_fields = NULL; destination_number = switch_core_strdup(pool, dialed_number); tstrip = ((cur_route->digit_len - cur_route->tstrip) + 1); lstrip = cur_route->lstrip; if (cur_route->tstrip > 0) { if (strlen(destination_number) > tstrip) { destination_number[tstrip] = '\0'; } else { destination_number[0] = '\0'; } } if (cur_route->lstrip > 0) { if (strlen(destination_number) > lstrip) { destination_number += lstrip; } else { destination_number[0] = '\0'; } } codec = ""; if (!zstr(cur_route->codec)) { codec = switch_core_sprintf(pool, ",absolute_codec_string=%s", cur_route->codec); } cid = ""; if (!zstr(cur_route->cid)) { cid = switch_core_sprintf(pool, ",origination_caller_id_number=%s", do_cid(pool, cur_route->cid, caller_id, session)); } header = ""; if (profile->info_in_headers) { header = switch_core_sprintf(pool, ",sip_h_X-LCR-INFO=lcr_rate=%s;lcr_carrier=%s", cur_route->rate_str, cur_route->carrier_name); } if (zstr(cur_route->user_rate_str)) { user_rate = ""; } else { user_rate = switch_core_sprintf(pool, ",lcr_user_rate=%s", cur_route->user_rate_str); } export_fields = ""; if (profile->export_fields_cnt > 0) { int i = 0; char *val = NULL; for (i = 0; i < profile->export_fields_cnt; i++) { val = switch_event_get_header(cur_route->fields, profile->export_fields[i]); if (val) { export_fields = switch_core_sprintf(pool, "%s,%s=%s", export_fields, profile->export_fields[i], val); } } } if (profile->enable_sip_redir) { data = switch_core_sprintf(pool, "%s%s%s%s%s" , cur_route->gw_prefix, cur_route->prefix , destination_number, cur_route->suffix, cur_route->gw_suffix); } else { data = switch_core_sprintf(pool, "[lcr_carrier=%s,lcr_rate=%s%s%s%s%s%s]%s%s%s%s%s" , cur_route->carrier_name, cur_route->rate_str , user_rate, codec, cid, header, export_fields , cur_route->gw_prefix, cur_route->prefix , destination_number, cur_route->suffix, cur_route->gw_suffix); } if (session && (switch_string_var_check_const(data) || switch_string_has_escaped_data(data))) { data = switch_channel_expand_variables(switch_core_session_get_channel(session), data); } if (session && (switch_string_var_check_const(data) || switch_string_has_escaped_data(data))) { data = switch_channel_expand_variables(switch_core_session_get_channel(session), data); } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Returning Dialstring %s\n", data); return data; } static profile_t *locate_profile(const char *profile_name) { profile_t *profile = NULL; if (zstr(profile_name)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "profile_name is empty\n"); if (globals.default_profile) { profile = globals.default_profile; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "using default_profile\n"); } else if ((profile = switch_core_hash_find(globals.profile_hash, "default"))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "no default set, using profile named \"default\"\n"); } } else if (!(profile = switch_core_hash_find(globals.profile_hash, profile_name))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error invalid profile %s\n", profile_name); } return profile; } static void init_max_lens(max_len maxes) { maxes->digit_str = (headers[LCR_HEADERS_DIGITS] == NULL ? 0 : strlen(headers[LCR_HEADERS_DIGITS])); maxes->carrier_name = (headers[LCR_HEADERS_CARRIER] == NULL ? 0 : strlen(headers[LCR_HEADERS_CARRIER])); maxes->dialstring = (headers[LCR_HEADERS_DIALSTRING] == NULL ? 0 : strlen(headers[LCR_HEADERS_DIALSTRING])); maxes->rate = 8; maxes->codec = (headers[LCR_HEADERS_CODEC] == NULL ? 0 : strlen(headers[LCR_HEADERS_CODEC])); maxes->cid = (headers[LCR_HEADERS_CID] == NULL ? 0 : strlen(headers[LCR_HEADERS_CID])); maxes->limit = (headers[LCR_HEADERS_LIMIT] == NULL ? 0 : strlen(headers[LCR_HEADERS_LIMIT])); } static switch_status_t process_max_lengths(max_obj_t *maxes, lcr_route routes, char *destination_number) { lcr_route current = NULL; if (routes == NULL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "no routes\n"); return SWITCH_STATUS_FALSE; } if (maxes == NULL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "no maxes\n"); return SWITCH_STATUS_FALSE; } init_max_lens(maxes); for (current = routes; current; current = current->next) { size_t this_len; if (current->carrier_name) { this_len = strlen(current->carrier_name); if (this_len > maxes->carrier_name) { maxes->carrier_name = this_len; } } if (current->dialstring) { this_len = strlen(current->dialstring); if (this_len > maxes->dialstring) { maxes->dialstring = this_len; } } if (current->digit_str) { if (current->digit_len > maxes->digit_str) { maxes->digit_str = current->digit_len; } } if (current->rate_str) { this_len = strlen(current->rate_str); if (this_len > maxes->rate) { maxes->rate = this_len; } } if (current->codec) { this_len= strlen(current->codec); if (this_len > maxes->codec) { maxes->codec = this_len; } } if (current->cid) { this_len = strlen(current->cid); if (this_len > maxes->cid) { maxes->cid = this_len; } } if (current->limit_realm && current->limit_id) { this_len = strlen(current->limit_realm) + strlen(current->limit_id) + 5; if (this_len > maxes->limit) { maxes->limit = this_len; } } } return SWITCH_STATUS_SUCCESS; } static switch_cache_db_handle_t *lcr_get_db_handle(void) { switch_cache_db_handle_t *dbh = NULL; char *dsn; if (!zstr(globals.odbc_dsn)) { dsn = globals.odbc_dsn; } else { dsn = globals.dbname; } if (switch_cache_db_get_db_handle_dsn(&dbh, dsn) != SWITCH_STATUS_SUCCESS) { dbh = NULL; } return dbh; } static switch_bool_t db_check(char *sql) { switch_bool_t ret = SWITCH_FALSE; switch_cache_db_handle_t *dbh = NULL; if (globals.odbc_dsn && (dbh = lcr_get_db_handle())) { if (switch_cache_db_execute_sql(dbh, sql, NULL) == SWITCH_STATUS_SUCCESS) { ret = SWITCH_TRUE; } } switch_cache_db_release_db_handle(&dbh); return ret; } /* try each type of random until we suceed */ static switch_bool_t set_db_random() { if (db_check("SELECT rand();") == SWITCH_TRUE) { db_random = "rand()"; return SWITCH_TRUE; } if (db_check("SELECT random();") == SWITCH_TRUE) { db_random = "random()"; return SWITCH_TRUE; } return SWITCH_FALSE; } /* make a new string with digits only */ static char *string_digitsonly(switch_memory_pool_t *pool, const char *str) { char *p, *np, *newstr; size_t len; p = (char *)str; len = strlen(str); newstr = switch_core_alloc(pool, len+1); np = newstr; while(*p) { if (switch_isdigit(*p)) { *np = *p; np++; } p++; } *np = '\0'; return newstr; } /* escape sql */ #ifdef _WAITING_FOR_ESCAPE static char *escape_sql(const char *sql) { return switch_string_replace(sql, "'", "''"); } #endif /* expand the digits */ static char *expand_digits(switch_memory_pool_t *pool, char *digits, switch_bool_t quote) { switch_stream_handle_t dig_stream = { 0 }; char *ret; char *digits_copy; int n; int digit_len; SWITCH_STANDARD_STREAM(dig_stream); digit_len = (int)strlen(digits); digits_copy = switch_core_strdup(pool, digits); for (n = digit_len; n > 0; n--) { digits_copy[n] = '\0'; dig_stream.write_function(&dig_stream, "%s%s%s%s", (n==digit_len ? "" : ", "), (quote ? "'" : ""), digits_copy, (quote ? "'" : "")); } ret = switch_core_strdup(pool, dig_stream.data); switch_safe_free(dig_stream.data); return ret; } /* format the custom sql */ static char *format_custom_sql(const char *custom_sql, callback_t *cb_struct, const char *digits) { char * tmpSQL = NULL; char * newSQL = NULL; switch_channel_t *channel; /* first replace %s with digits to maintain backward compat */ if (cb_struct->profile->custom_sql_has_percent == SWITCH_TRUE) { tmpSQL = switch_string_replace(custom_sql, "%q", digits); newSQL = tmpSQL; } /* expand the vars */ if (cb_struct->profile->custom_sql_has_vars == SWITCH_TRUE) { if (cb_struct->session) { channel = switch_core_session_get_channel(cb_struct->session); switch_assert(channel); /* newSQL = switch_channel_expand_variables_escape(channel, tmpSQL ? tmpSQL : custom_sql, escape_sql); */ newSQL = switch_channel_expand_variables(channel, tmpSQL ? tmpSQL : custom_sql); } else if (cb_struct->event) { /* use event system to expand vars */ newSQL = switch_event_expand_headers(cb_struct->event, tmpSQL ? tmpSQL : custom_sql); } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_CRIT, "mod_lcr called without a valid session while using a custom_sql that has channel variables.\n"); } } if (tmpSQL != newSQL) { switch_safe_free(tmpSQL); } if (newSQL == NULL) { return (char *) custom_sql; } else { return newSQL; } } static switch_bool_t lcr_execute_sql_callback(char *sql, switch_core_db_callback_func_t callback, void *pdata) { switch_bool_t retval = SWITCH_FALSE; switch_cache_db_handle_t *dbh = NULL; if (globals.odbc_dsn && (dbh = lcr_get_db_handle())) { if (switch_cache_db_execute_sql_callback(dbh, sql, callback, pdata, NULL) != SWITCH_STATUS_SUCCESS) { retval = SWITCH_FALSE; } else { retval = SWITCH_TRUE; } } switch_cache_db_release_db_handle(&dbh); return retval; } /* CF = compare field */ #define CF(x) !strcmp(x, columnNames[i]) static int route_add_callback(void *pArg, int argc, char **argv, char **columnNames) { lcr_route additional = NULL; lcr_route current = NULL; callback_t *cbt = (callback_t *) pArg; char *key = NULL; char *key2 = NULL; int i = 0; int r = 0; switch_bool_t lcr_skipped = SWITCH_TRUE; /* assume we'll throw it away, paranoid about leak */ switch_memory_pool_t *pool = cbt->pool; additional = switch_core_alloc(pool, sizeof(lcr_obj_t)); switch_event_create(&additional->fields, SWITCH_EVENT_REQUEST_PARAMS); for (i = 0; i < argc ; i++) { if (CF("lcr_digits")) { additional->digit_len = strlen(argv[i]); additional->digit_str = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_prefix")) { additional->prefix = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_suffix")) { additional->suffix = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_carrier_name")) { additional->carrier_name = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_rate_field")) { if (!argv[i] || zstr(argv[i])) { /* maybe we want to consider saying which carriers have null rate fields... maybe they can run the query and find out */ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "rate field is null, skipping\n"); /* kill prev/next pointers */ /* additional->prev = NULL; */ goto end; } additional->rate = (float)atof(switch_str_nil(argv[i])); additional->rate_str = switch_core_sprintf(pool, "%0.5f", additional->rate); } else if (CF("lcr_gw_prefix")) { additional->gw_prefix = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_gw_suffix")) { additional->gw_suffix = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_lead_strip")) { additional->lstrip = atoi(switch_str_nil(argv[i])); } else if (CF("lcr_trail_strip")) { additional->tstrip = atoi(switch_str_nil(argv[i])); } else if (CF("lcr_codec")) { additional->codec = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_cid")) { additional->cid = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_user_rate")) { additional->user_rate = (float)atof(switch_str_nil(argv[i])); additional->user_rate_str = switch_core_sprintf(pool, "%0.5f", additional->user_rate); } else if (CF("lcr_limit_realm")) { additional->limit_realm = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_limit_id")) { additional->limit_id = switch_core_strdup(pool, switch_str_nil(argv[i])); } else if (CF("lcr_limit_max")) { additional->limit_max = (float)atof(switch_str_nil(argv[i])); } /* add all fields to the fields event */ switch_event_add_header_string(additional->fields, SWITCH_STACK_BOTTOM, columnNames[i], argv[i]); } cbt->matches++; additional->dialstring = get_bridge_data(pool, cbt->lookup_number, cbt->cid, additional, cbt->profile, cbt->session); if (cbt->head == NULL) { if (cbt->max_rate && (cbt->max_rate < additional->rate)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Skipping [%s] because [%f] is higher than the max_rate of [%f]\n", additional->carrier_name, additional->rate, cbt->max_rate); lcr_skipped = SWITCH_FALSE; r = 0; goto end; } key = switch_core_sprintf(pool, "%s:%s", additional->gw_prefix, additional->gw_suffix); if (cbt->profile->single_bridge) { key2 = switch_core_sprintf(pool, "%s", additional->carrier_name); } additional->next = cbt->head; cbt->head = additional; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding %s to head of list\n", additional->carrier_name); if (switch_core_hash_insert(cbt->dedup_hash, key, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } if (cbt->profile->single_bridge) { if (switch_core_hash_insert(cbt->dedup_hash, key2, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } } lcr_skipped = SWITCH_FALSE; r = 0; goto end; } for (current = cbt->head; current; current = current->next) { if (cbt->max_rate && (cbt->max_rate < additional->rate)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Skipping [%s] because [%f] is higher than the max_rate of [%f]\n", additional->carrier_name, additional->rate, cbt->max_rate); break; } key = switch_core_sprintf(pool, "%s:%s", additional->gw_prefix, additional->gw_suffix); if (switch_core_hash_find(cbt->dedup_hash, key)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Ignoring Duplicate route for termination point (%s)\n", key); break; } if (cbt->profile->single_bridge) { key2 = switch_core_sprintf(pool, "%s", additional->carrier_name); if (switch_core_hash_find(cbt->dedup_hash, key2)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Ignoring duplicate carrier gateway for single bridge. (%s)\n", key2); break; } } if (!cbt->profile->reorder_by_rate) { /* use db order */ if (current->next == NULL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding %s to end of list\n", additional->carrier_name); current->next = additional; additional->prev = current; if (switch_core_hash_insert(cbt->dedup_hash, key, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } if (cbt->profile->single_bridge) { if (switch_core_hash_insert(cbt->dedup_hash, key2, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } } lcr_skipped = SWITCH_FALSE; break; } } else { if (current->rate > additional->rate) { /* insert myself here */ if (current->prev != NULL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding %s before %s\n", additional->carrier_name, current->carrier_name); current->prev->next = additional; } else { /* put this one at the head */ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Inserting %s to list head before %s\n", additional->carrier_name, current->carrier_name); cbt->head = additional; } additional->next = current; current->prev = additional; if (switch_core_hash_insert(cbt->dedup_hash, key, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } if (cbt->profile->single_bridge) { if (switch_core_hash_insert(cbt->dedup_hash, key2, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } } lcr_skipped = SWITCH_FALSE; break; } else if (current->next == NULL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "adding %s to end of list after %s\n", additional->carrier_name, current->carrier_name); current->next = additional; additional->prev = current; if (switch_core_hash_insert(cbt->dedup_hash, key, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } if (cbt->profile->single_bridge) { if (switch_core_hash_insert(cbt->dedup_hash, key2, additional) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error inserting into dedup hash\n"); r = -1; goto end; } } lcr_skipped = SWITCH_FALSE; break; } } } end: /* lcr was not added to any lists, so destroy lcr object here */ if (lcr_skipped == SWITCH_TRUE) { /* complain loudly if we're asked to destroy a route that is added to the route list */ if (additional && additional->prev != NULL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "additional->prev != NULL\n"); } if (current && current->next == additional) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "current->next == additional\n"); } lcr_destroy(additional); } return r; } static int intrastatelata_callback(void *pArg, int argc, char **argv, char **columnNames) { int count = 0; callback_t *cbt = (callback_t *) pArg; count = atoi(argv[1]); if (count == 1) { if (!strcmp(argv[0], "state")) { cbt->intrastate = SWITCH_TRUE; } else if (!strcmp(argv[0], "lata")) { cbt->intralata = SWITCH_TRUE; } } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Type: %s, Count: %d\n", argv[0], count); return SWITCH_STATUS_SUCCESS; } static switch_status_t is_intrastatelata(callback_t *cb_struct) { char *sql = NULL; /* extract npa nxx - make some assumptions about format: e164 format without the + NANP only (so 11 digits starting with 1) */ if (!cb_struct->lookup_number || strlen(cb_struct->lookup_number) != 11 || *cb_struct->lookup_number != '1' || !switch_is_number(cb_struct->lookup_number)) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "%s doesn't appear to be a NANP number\n", cb_struct->lookup_number); /* dest doesn't appear to be NANP number */ return SWITCH_STATUS_GENERR; } if (!cb_struct->cid || strlen(cb_struct->cid) != 11 || *cb_struct->cid != '1' || !switch_is_number(cb_struct->cid)) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "%s doesn't appear to be a NANP number\n", cb_struct->cid); /* cid not NANP */ return SWITCH_STATUS_GENERR; } /* assume that if the area code (plus leading 1) are the same we're intrastate */ /* probably a bad assumption */ /* if (!strncmp(cb_struct->lookup_number, cb_struct->cid, 4)) { cb_struct->intrastate = SWITCH_TRUE; return SWITCH_STATUS_SUCCESS; } */ sql = switch_core_sprintf(cb_struct->pool, "SELECT 'state', count(DISTINCT state) FROM npa_nxx_company_ocn WHERE (npa=%3.3s AND nxx=%3.3s) OR (npa=%3.3s AND nxx=%3.3s)" " UNION " "SELECT 'lata', count(DISTINCT lata) FROM npa_nxx_company_ocn WHERE (npa=%3.3s AND nxx=%3.3s) OR (npa=%3.3s AND nxx=%3.3s)", cb_struct->lookup_number+1, cb_struct->lookup_number+4, cb_struct->cid+1, cb_struct->cid+4, cb_struct->lookup_number+1, cb_struct->lookup_number+4, cb_struct->cid+1, cb_struct->cid+4); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "SQL: %s\n", sql); return(lcr_execute_sql_callback(sql, intrastatelata_callback, cb_struct)); } static switch_status_t lcr_do_lookup(callback_t *cb_struct) { switch_stream_handle_t sql_stream = { 0 }; char *digits = cb_struct->lookup_number; char *digits_copy = NULL; char *digits_expanded = NULL; char *lrn_digits_expanded = NULL; profile_t *profile = cb_struct->profile; switch_bool_t lookup_status; switch_channel_t *channel; char *id_str; char *safe_sql = NULL; char *rate_field = NULL; char *user_rate_field = NULL; switch_assert(cb_struct->lookup_number != NULL); digits_copy = string_digitsonly(cb_struct->pool, digits); if (zstr(digits_copy)) { return SWITCH_STATUS_GENERR; } /* allocate the dedup hash */ if (switch_core_hash_init(&cb_struct->dedup_hash, cb_struct->pool) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_ERROR, "Error initializing the dedup hash\n"); return SWITCH_STATUS_GENERR; } digits_expanded = expand_digits(cb_struct->pool, digits_copy, cb_struct->profile->quote_in_list); if (cb_struct->lrn_number) { lrn_digits_expanded = expand_digits(cb_struct->pool, cb_struct->lrn_number, cb_struct->profile->quote_in_list); } else { lrn_digits_expanded = switch_core_strdup(cb_struct->pool, digits_expanded); } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "Has NPA NXX: [%u == %u]\n", profile->profile_has_npanxx, SWITCH_TRUE); if (profile->profile_has_npanxx == SWITCH_TRUE) { is_intrastatelata(cb_struct); } /* set our rate field based on env and profile */ if (cb_struct->intralata == SWITCH_TRUE && profile->profile_has_intralata == SWITCH_TRUE) { rate_field = switch_core_strdup(cb_struct->pool, "intralata_rate"); user_rate_field = switch_core_strdup(cb_struct->pool, "user_intralata_rate"); } else if (cb_struct->intrastate == SWITCH_TRUE && profile->profile_has_intrastate == SWITCH_TRUE) { rate_field = switch_core_strdup(cb_struct->pool, "intrastate_rate"); user_rate_field = switch_core_strdup(cb_struct->pool, "user_intrastate_rate"); } else { rate_field = switch_core_strdup(cb_struct->pool, "rate"); user_rate_field = switch_core_strdup(cb_struct->pool, "user_rate"); } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "intra routing [state:%d lata:%d] so rate field is [%s]\n", cb_struct->intrastate, cb_struct->intralata, rate_field); /* set some channel vars if we have a session */ if (cb_struct->session) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "we have a session\n"); if ((channel = switch_core_session_get_channel(cb_struct->session))) { const char *max_rate = switch_channel_get_variable(channel, "max_rate"); if (!zstr(max_rate)) { cb_struct->max_rate = atof(max_rate); } switch_channel_set_variable_var_check(channel, "lcr_rate_field", rate_field, SWITCH_FALSE); switch_channel_set_variable_var_check(channel, "lcr_user_rate_field", user_rate_field, SWITCH_FALSE); switch_channel_set_variable_var_check(channel, "lcr_query_digits", digits_copy, SWITCH_FALSE); id_str = switch_core_sprintf(cb_struct->pool, "%d", cb_struct->profile->id); switch_channel_set_variable_var_check(channel, "lcr_query_profile", id_str, SWITCH_FALSE); switch_channel_set_variable_var_check(channel, "lcr_query_expanded_digits", digits_expanded, SWITCH_FALSE); switch_channel_set_variable_var_check(channel, "lcr_query_expanded_lrn_digits", lrn_digits_expanded, SWITCH_FALSE); if ( cb_struct->lrn_number ) { switch_channel_set_variable_var_check(channel, "lcr_lrn", cb_struct->lrn_number, SWITCH_FALSE); } } } if (cb_struct->event) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "we have an event\n"); switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_rate_field", rate_field); switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_user_rate_field", user_rate_field); switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_query_digits", digits_copy); id_str = switch_core_sprintf(cb_struct->pool, "%d", cb_struct->profile->id); switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_query_profile", id_str); switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_query_expanded_digits", digits_expanded); switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_query_expanded_lrn_digits", lrn_digits_expanded); if ( cb_struct->lrn_number ) { switch_event_add_header_string(cb_struct->event, SWITCH_STACK_BOTTOM, "lcr_lrn", cb_struct->lrn_number); } } /* set up the query to be executed */ /* format the custom_sql */ safe_sql = format_custom_sql(profile->custom_sql, cb_struct, digits_copy); if (!safe_sql) { switch_core_hash_destroy(&cb_struct->dedup_hash); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_ERROR, "Unable to format SQL\n"); return SWITCH_STATUS_GENERR; } SWITCH_STANDARD_STREAM(sql_stream); sql_stream.write_function(&sql_stream, safe_sql); if (safe_sql != profile->custom_sql) { /* channel_expand_variables returned the same string to us, no need to free */ switch_safe_free(safe_sql); } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(cb_struct->session), SWITCH_LOG_DEBUG, "SQL: %s\n", (char *)sql_stream.data); lookup_status = lcr_execute_sql_callback((char *)sql_stream.data, route_add_callback, cb_struct); switch_safe_free(sql_stream.data); switch_core_hash_destroy(&cb_struct->dedup_hash); if (lookup_status) { return SWITCH_STATUS_SUCCESS; } else { return SWITCH_STATUS_GENERR; } } static switch_bool_t test_profile(char *lcr_profile) { callback_t routes = { 0 }; switch_memory_pool_t *pool = NULL; switch_event_t *event = NULL; switch_bool_t r; switch_core_new_memory_pool(&pool); switch_event_create(&event, SWITCH_EVENT_MESSAGE); routes.event = event; routes.pool = pool; if (!(routes.profile = locate_profile(lcr_profile))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown profile: %s\n", lcr_profile); return SWITCH_FALSE; } routes.lookup_number = "15555551212"; routes.cid = "18005551212"; lcr_destroy(routes.head); r = (lcr_do_lookup(&routes) == SWITCH_STATUS_SUCCESS) ? SWITCH_TRUE : SWITCH_FALSE; switch_event_destroy(&event); return r; } static switch_status_t lcr_load_config() { char *cf = "lcr.conf"; switch_stream_handle_t sql_stream = { 0 }; switch_xml_t cfg, xml, settings, param, x_profile, x_profiles; switch_status_t status = SWITCH_STATUS_SUCCESS; profile_t *profile = NULL; switch_cache_db_handle_t *dbh = NULL; if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf); return SWITCH_STATUS_TERM; } if ((settings = switch_xml_child(cfg, "settings"))) { for (param = switch_xml_child(settings, "param"); param; param = param->next) { char *var = NULL; char *val = NULL; var = (char *) switch_xml_attr_soft(param, "name"); val = (char *) switch_xml_attr_soft(param, "value"); if (!strcasecmp(var, "odbc-dsn") && !zstr(val)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "odbc_dsn is %s\n", val); switch_safe_free(globals.odbc_dsn); globals.odbc_dsn = strdup(val); } } } /* initialize sql here, 'cause we need to verify custom_sql for each profile below */ if (globals.odbc_dsn) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG , "dsn is \"%s\"\n" , globals.odbc_dsn ); if (!(dbh = lcr_get_db_handle())) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot Open ODBC Database!\n"); switch_goto_status(SWITCH_STATUS_FALSE, done); } } if (set_db_random() == SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Database RANDOM function set to %s\n", db_random); } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to determine database RANDOM function\n"); }; switch_core_hash_init(&globals.profile_hash, globals.pool); if ((x_profiles = switch_xml_child(cfg, "profiles"))) { for (x_profile = switch_xml_child(x_profiles, "profile"); x_profile; x_profile = x_profile->next) { char *name = (char *) switch_xml_attr_soft(x_profile, "name"); char *comma = ", "; switch_stream_handle_t order_by = { 0 }; switch_stream_handle_t *thisorder = NULL; char *reorder_by_rate = NULL; char *quote_in_list = NULL; char *single_bridge = NULL; char *info_in_headers = NULL; char *enable_sip_redir = NULL; char *id_s = NULL; char *custom_sql = NULL; char *export_fields = NULL; char *limit_type = NULL; int argc, x = 0; char *argv[32] = { 0 }; SWITCH_STANDARD_STREAM(order_by); for (param = switch_xml_child(x_profile, "param"); param; param = param->next) { char *var, *val; var = (char *) switch_xml_attr_soft(param, "name"); val = (char *) switch_xml_attr_soft(param, "value"); if (!strcasecmp(var, "order_by") && !zstr(val)) { thisorder = &order_by; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "param val is %s\n", val); if ((argc = switch_separate_string(val, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) { for (x=0; xwrite_function(thisorder, "%s quality DESC", comma); } else if (!strcasecmp(argv[x], "reliability")) { thisorder->write_function(thisorder, "%s reliability DESC", comma); } else if (!strcasecmp(argv[x], "rate")) { thisorder->write_function(thisorder, "%s ${lcr_rate_field}", comma); } else { thisorder->write_function(thisorder, "%s %s", comma, argv[x]); } } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "arg #%d is empty\n", x); } } } else { if (!strcasecmp(val, "quality")) { thisorder->write_function(thisorder, "%s quality DESC", comma); } else if (!strcasecmp(val, "reliability")) { thisorder->write_function(thisorder, "%s reliability DESC", comma); } else { thisorder->write_function(thisorder, "%s %s", comma, val); } } } else if (!strcasecmp(var, "id") && !zstr(val)) { id_s = val; } else if (!strcasecmp(var, "custom_sql") && !zstr(val)) { custom_sql = val; } else if (!strcasecmp(var, "reorder_by_rate") && !zstr(val)) { reorder_by_rate = val; } else if (!strcasecmp(var, "info_in_headers") && !zstr(val)) { info_in_headers = val; } else if (!strcasecmp(var, "quote_in_list") && !zstr(val)) { quote_in_list = val; } else if (!strcasecmp(var, "single_bridge") && !zstr(val)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Single bridge mode set to %s.\n", val); single_bridge = val; } else if (!strcasecmp(var, "export_fields") && !zstr(val)) { export_fields = val; } else if (!strcasecmp(var, "limit_type") && !zstr(val)) { limit_type = val; } else if (!strcasecmp(var, "enable_sip_redir") && !zstr(val)) { enable_sip_redir = val; } } if (zstr(name)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No name specified.\n"); } else { profile = switch_core_alloc(globals.pool, sizeof(*profile)); memset(profile, 0, sizeof(profile_t)); profile->name = switch_core_strdup(globals.pool, name); if (!zstr((char *)order_by.data)) { profile->order_by = switch_core_strdup(globals.pool, (char *)order_by.data); } else { /* default to rate */ profile->order_by = ", ${lcr_rate_field}"; } if (!zstr(id_s)) { profile->id = (uint16_t)atoi(id_s); } /* SWITCH_STANDARD_STREAM doesn't use pools. but we only have to free sql_stream.data */ SWITCH_STANDARD_STREAM(sql_stream); if (zstr(custom_sql)) { /* use default sql */ /* Checking for codec field, adding if needed */ if (db_check("SELECT codec FROM carrier_gateway LIMIT 1") == SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "codec field defined.\n"); } else { if (db_check("ALTER TABLE carrier_gateway add codec varchar(255);") == SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "adding codec field your lcr carrier_gateway database schema.\n"); } else { return SWITCH_FALSE; } } /* Checking for cid field, adding if needed */ if (db_check("SELECT cid FROM lcr LIMIT 1") == SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "cid field defined.\n"); } else { if (db_check("ALTER TABLE lcr add cid varchar(32);") == SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "adding cid field to your lcr database schema.\n"); } else { return SWITCH_FALSE; } } if (db_check("SELECT lrn FROM lcr LIMIT 1") != SWITCH_TRUE) { if (db_check("ALTER TABLE lcr ADD lrn BOOLEAN NOT NULL DEFAULT false")) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "adding lrn field to your lcr database schema.\n"); } else { return SWITCH_FALSE; } } sql_stream.write_function(&sql_stream, "SELECT l.digits AS lcr_digits, c.carrier_name AS lcr_carrier_name, l.${lcr_rate_field} AS lcr_rate_field, \ cg.prefix AS lcr_gw_prefix, cg.suffix AS lcr_gw_suffix, l.lead_strip AS lcr_lead_strip, \ l.trail_strip AS lcr_trail_strip, l.prefix AS lcr_prefix, l.suffix AS lcr_suffix, \ cg.codec AS lcr_codec, l.cid AS lcr_cid "); sql_stream.write_function(&sql_stream, "FROM lcr l JOIN carriers c ON l.carrier_id=c.id \ JOIN carrier_gateway cg ON c.id=cg.carrier_id \ WHERE c.enabled = '1' AND cg.enabled = '1' AND l.enabled = '1' AND (\ (digits IN (${lcr_query_expanded_digits}) AND lrn = false) OR \ (digits IN (${lcr_query_expanded_lrn_digits}) AND lrn = true)"); sql_stream.write_function(&sql_stream, ") AND CURRENT_TIMESTAMP BETWEEN date_start AND date_end "); if (profile->id > 0) { sql_stream.write_function(&sql_stream, "AND lcr_profile=%d ", profile->id); } sql_stream.write_function(&sql_stream, "ORDER BY digits DESC%s", profile->order_by); if (db_random) { sql_stream.write_function(&sql_stream, ", %s", db_random); } sql_stream.write_function(&sql_stream, ";"); custom_sql = sql_stream.data; } profile->profile_has_intralata = db_check("SELECT intralata_rate FROM lcr LIMIT 1"); if (profile->profile_has_intralata != SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "no \"intralata_rate\" field found in the \"lcr\" table, routing by intralata rates will be disabled until the field is added and mod_lcr is reloaded\n" ); } profile->profile_has_intrastate = db_check("SELECT intrastate_rate FROM lcr LIMIT 1"); if (profile->profile_has_intrastate != SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "no \"intrastate_rate\" field found in the \"lcr\" table, routing by intrastate rates will be disabled until the field is added and mod_lcr is reloaded\n" ); } profile->profile_has_npanxx = db_check("SELECT npa, nxx, state FROM npa_nxx_company_ocn LIMIT 1"); if (profile->profile_has_npanxx != SWITCH_TRUE) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "no \"npa_nxx_company_ocn\" table found in the \"lcr\" database, automatic intrastate detection will be disabled until the table is added and mod_lcr is reloaded\n" ); } if (switch_string_var_check_const(custom_sql) || switch_string_has_escaped_data(custom_sql)) { profile->custom_sql_has_vars = SWITCH_TRUE; } if (strstr(custom_sql, "%")) { profile->custom_sql_has_percent = SWITCH_TRUE; } profile->custom_sql = switch_core_strdup(globals.pool, (char *)custom_sql); if (!zstr(reorder_by_rate)) { profile->reorder_by_rate = switch_true(reorder_by_rate); } if (!zstr(info_in_headers)) { profile->info_in_headers = switch_true(info_in_headers); } if (!zstr(enable_sip_redir)) { profile->enable_sip_redir = switch_true(enable_sip_redir); } if (!zstr(quote_in_list)) { profile->quote_in_list = switch_true(quote_in_list); } if (!zstr(single_bridge)) { profile->single_bridge = switch_true(single_bridge); } if (!zstr(export_fields)) { int argc2 = 0; char *argv2[50] = { 0 }; char **argvdup = NULL; char *dup = switch_core_strdup(globals.pool, export_fields); argc2 = switch_separate_string(dup, ',', argv2, (sizeof(argv2) / sizeof(argv2[0]))); profile->export_fields_str = switch_core_strdup(globals.pool, export_fields); profile->export_fields_cnt = argc2; argvdup = switch_core_alloc(globals.pool, sizeof(argv2)); memcpy(argvdup, argv2, sizeof(argv2)); profile->export_fields = argvdup; } if (!zstr(limit_type)) { if (!strcasecmp(limit_type, "hash")) { profile->limit_type = "hash"; } else { profile->limit_type = "db"; } } else { profile->limit_type = "db"; } switch_core_hash_insert(globals.profile_hash, profile->name, profile); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Loaded lcr profile %s.\n", profile->name); /* test the profile */ if (profile->custom_sql_has_vars) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "custom_sql has channel vars, skipping verification and assuming valid profile: %s.\n", profile->name); if (!strcasecmp(profile->name, "default")) { globals.default_profile = profile; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Setting user defined default profile: %s.\n", profile->name); } } else if (test_profile(profile->name) == SWITCH_TRUE) { if (!strcasecmp(profile->name, "default")) { globals.default_profile = profile; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Setting user defined default profile: %s.\n", profile->name); } } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Removing INVALID Profile %s.\n", profile->name); switch_core_hash_delete(globals.profile_hash, profile->name); } } switch_safe_free(order_by.data); switch_safe_free(sql_stream.data); } } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "No lcr profiles defined.\n"); } /* define default profile */ if (!globals.default_profile) { profile = switch_core_alloc(globals.pool, sizeof(*profile)); memset(profile, 0, sizeof(profile_t)); profile->name = "global_default"; profile->order_by = ", rate"; globals.default_profile = profile; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Setting system defined default profile."); } done: switch_cache_db_release_db_handle(&dbh); switch_xml_free(xml); return status; } /* fake chan_lcr */ switch_endpoint_interface_t *lcr_endpoint_interface; static switch_call_cause_t lcr_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, switch_caller_profile_t *outbound_profile, switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause); switch_io_routines_t lcr_io_routines = { /*.outgoing_channel */ lcr_outgoing_channel }; static switch_call_cause_t lcr_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, switch_caller_profile_t *outbound_profile, switch_core_session_t **new_session, switch_memory_pool_t **new_pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause) { switch_call_cause_t cause = SWITCH_CAUSE_NONE; char *dest = NULL; switch_originate_flag_t myflags = SOF_NONE; const char *cid_name_override = NULL; const char *cid_num_override = NULL; switch_channel_t *new_channel = NULL; unsigned int timelimit = 60; const char *skip, *var; switch_memory_pool_t *pool = NULL; callback_t routes = { 0 }; lcr_route cur_route = { 0 }; char *lcr_profile = NULL; switch_event_t *event = NULL; const char *intrastate = NULL; const char *intralata = NULL; switch_core_session_t *mysession = NULL, *locked_session = NULL; switch_channel_t *channel = NULL; int argc; char *argv[32] = { 0 }; char *mydata = NULL; switch_core_new_memory_pool(&pool); routes.pool = pool; if (!outbound_profile->destination_number) { goto done; } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Entering lcr endpoint for %s\n", outbound_profile->destination_number); mydata = switch_core_strdup(pool, outbound_profile->destination_number); if ((argc = switch_separate_string(mydata, '/', argv, (sizeof(argv) / sizeof(argv[0]))))) { if (argc > 1) { lcr_profile = switch_core_strdup(pool, argv[0]); dest = switch_core_strdup(pool, argv[1]); } } if (!dest) { dest = outbound_profile->destination_number; } if (var_event && (skip = switch_event_get_header(var_event, "lcr_recurse_variables")) && switch_false(skip)) { if ((var = switch_event_get_header(var_event, SWITCH_CALL_TIMEOUT_VARIABLE)) || (var = switch_event_get_header(var_event, "leg_timeout"))) { timelimit = atoi(var); } var_event = NULL; } if (session) { mysession = session; channel = switch_core_session_get_channel(session); if ((var = switch_channel_get_variable(channel, SWITCH_CALL_TIMEOUT_VARIABLE)) || (var = switch_event_get_header(var_event, "leg_timeout"))) { timelimit = atoi(var); } routes.session = session; intrastate = switch_channel_get_variable(channel, "intrastate"); intralata = switch_channel_get_variable(channel, "intralata"); cid_name_override = switch_channel_get_variable(channel, "origination_caller_id_name"); cid_num_override = switch_channel_get_variable(channel, "origination_caller_id_number"); if (zstr(cid_name_override)) { cid_name_override = switch_channel_get_variable(channel, "effective_caller_id_name"); } if (zstr(cid_num_override)) { cid_num_override = switch_channel_get_variable(channel, "effective_caller_id_number"); } if ((var = switch_channel_get_variable(channel, SWITCH_CALL_TIMEOUT_VARIABLE)) || (var = switch_event_get_header(var_event, "leg_timeout"))) { timelimit = atoi(var); } } else if (var_event) { char *session_uuid = switch_event_get_header(var_event, "ent_originate_aleg_uuid"); if (session_uuid) { mysession = locked_session = switch_core_session_locate(session_uuid); } cid_name_override = switch_event_get_header(var_event, "origination_caller_id_name"); cid_num_override = switch_event_get_header(var_event, "origination_caller_id_number"); if (zstr(cid_name_override)) { cid_name_override = switch_event_get_header(var_event, "effective_caller_id_name"); } if (zstr(cid_num_override)) { cid_num_override = switch_event_get_header(var_event, "caller_id_number"); } if ((var = switch_event_get_header(var_event, SWITCH_CALL_TIMEOUT_VARIABLE)) || (var = switch_event_get_header(var_event, "leg_timeout"))) { timelimit = atoi(var); } intrastate = switch_event_get_header(var_event, "intrastate"); intralata = switch_event_get_header(var_event, "intralata"); //switch_event_dup(&event, var_event); routes.event = var_event; } else { switch_event_create(&event, SWITCH_EVENT_MESSAGE); routes.event = event; } routes.lookup_number = dest; routes.cid = (char *) cid_num_override; if ((flags & SOF_FORKED_DIAL)) { myflags |= SOF_NOBLOCK; } if (!(routes.profile = locate_profile(lcr_profile))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown profile: %s\n", lcr_profile); goto done; } if (!zstr(intralata) && !strcasecmp((char *)intralata, "true")) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Select routes based on intralata rates\n"); routes.intralata = SWITCH_FALSE; } else if (!zstr(intrastate) && !strcasecmp((char *)intrastate, "true")) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Select routes based on intrastate rates\n"); routes.intrastate = SWITCH_TRUE; } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Select routes based on interstate rates\n"); routes.intrastate = SWITCH_FALSE; } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "LCR Lookup on %s\n", dest); if (lcr_do_lookup(&routes) == SWITCH_STATUS_SUCCESS) { if (channel) { if (zstr(switch_channel_get_variable(channel, "import"))) { switch_channel_set_variable(channel, "import", "lcr_carrier,lcr_rate,lcr_user_rate"); } else { const char *tmp = switch_channel_get_variable(channel, "import"); if (!strstr(tmp, "lcr_carrier,lcr_rate,lcr_user_rate")) { switch_channel_set_variable_printf(channel, "import", "%s,lcr_carrier,lcr_rate,lcr_user_rate", tmp); } } } for (cur_route = routes.head; cur_route; cur_route = cur_route->next) { switch_bool_t pop_limit = SWITCH_FALSE; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Trying route: %s\n", cur_route->dialstring); if (mysession && cur_route->limit_realm && cur_route->limit_id) { if (switch_limit_incr(routes.profile->limit_type, mysession, cur_route->limit_realm, cur_route->limit_id, cur_route->limit_max, 0) == SWITCH_STATUS_SUCCESS) { pop_limit = SWITCH_TRUE; } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Limit exceeded for route %s, session: %s\n", cur_route->dialstring, mysession ? "true" : "false"); continue; } } if (switch_ivr_originate(session, new_session, &cause, cur_route->dialstring, timelimit, NULL, cid_name_override, cid_num_override, NULL, var_event, myflags, cancel_cause) == SWITCH_STATUS_SUCCESS) { const char *context; switch_caller_profile_t *cp; new_channel = switch_core_session_get_channel(*new_session); if ((context = switch_channel_get_variable(new_channel, "lcr_context"))) { if ((cp = switch_channel_get_caller_profile(new_channel))) { cp->context = switch_core_strdup(cp->pool, context); } } switch_core_session_rwunlock(*new_session); break; } /* did not connect, release limit */ if (pop_limit) { switch_limit_release(routes.profile->limit_type, mysession, cur_route->limit_realm, cur_route->limit_id); } if (cause == SWITCH_CAUSE_LOSE_RACE || cause == SWITCH_CAUSE_ORIGINATOR_CANCEL) { break; } } } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "LCR lookup failed for %s\n", dest); } done: if (event) { switch_event_destroy(&event); } if (locked_session) { switch_core_session_rwunlock(locked_session); } lcr_destroy(routes.head); switch_core_destroy_memory_pool(&pool); if (cause == SWITCH_CAUSE_NONE) { cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; } return cause; } SWITCH_STANDARD_DIALPLAN(lcr_dialplan_hunt) { switch_caller_extension_t *extension = NULL; switch_channel_t *channel = switch_core_session_get_channel(session); callback_t routes = { 0 }; lcr_route cur_route = { 0 }; switch_memory_pool_t *pool = NULL; switch_event_t *event = NULL; const char *intrastate = NULL; const char *intralata = NULL; const char *lrn = NULL; if (session) { pool = switch_core_session_get_pool(session); routes.session = session; } else { switch_core_new_memory_pool(&pool); switch_event_create(&event, SWITCH_EVENT_MESSAGE); routes.event = event; } routes.pool = pool; intrastate = switch_channel_get_variable(channel, "intrastate"); intralata = switch_channel_get_variable(channel, "intralata"); lrn = switch_channel_get_variable(channel, "lrn"); routes.lrn_number = (char *) lrn; switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "intrastate channel var is [%s]\n", intrastate); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "intralata channel var is [%s]\n", intralata); if (!zstr(intralata) && !strcasecmp((char *)intralata, "true")) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Select routes based on intralata rates\n"); routes.intralata = SWITCH_FALSE; } else if (!zstr(intrastate) && !strcasecmp((char *)intrastate, "true")) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Select routes based on intrastate rates\n"); routes.intrastate = SWITCH_TRUE; } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Select routes based on interstate rates\n"); routes.intrastate = SWITCH_FALSE; } if (!caller_profile) { caller_profile = switch_channel_get_caller_profile(channel); } if (!(routes.profile = locate_profile(caller_profile->context))) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Unknown profile: %s\n", caller_profile->context); goto end; } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "LCR Lookup on %s using profile %s\n", caller_profile->destination_number, caller_profile->context); routes.lookup_number = caller_profile->destination_number; if (caller_profile) { routes.cid = (char *) switch_channel_get_variable(channel, "effective_caller_id_number"); if (!routes.cid) { routes.cid = (char *) caller_profile->caller_id_number; } } if (lcr_do_lookup(&routes) == SWITCH_STATUS_SUCCESS) { if ((extension = switch_caller_extension_new(session, caller_profile->destination_number, caller_profile->destination_number)) == 0) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "memory error!\n"); goto end; } switch_channel_set_variable(channel, SWITCH_CONTINUE_ON_FAILURE_VARIABLE, "true"); switch_channel_set_variable(channel, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true"); if (zstr(switch_channel_get_variable(channel, "import"))) { switch_channel_set_variable(channel, "import", "lcr_carrier,lcr_rate,lcr_user_rate"); } else { const char *tmp = switch_channel_get_variable(channel, "import"); if (!strstr(tmp, "lcr_carrier,lcr_rate,lcr_user_rate")) { switch_channel_set_variable_printf(channel, "import", "%s,lcr_carrier,lcr_rate,lcr_user_rate", tmp); } } for (cur_route = routes.head; cur_route; cur_route = cur_route->next) { char *app = NULL; char *argc = NULL; if (cur_route->limit_realm && cur_route->limit_id) { app = "limit_execute"; argc = switch_core_sprintf(pool, "%s %s %s %d bridge %s", routes.profile->limit_type, cur_route->limit_realm, cur_route->limit_id, cur_route->limit_max, cur_route->dialstring); } else { app = "bridge"; argc = cur_route->dialstring; } switch_caller_extension_add_application(session, extension, app, argc); } } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "LCR lookup failed for %s using profile %s\n", caller_profile->destination_number, caller_profile->context); } end: lcr_destroy(routes.head); if (event) { switch_event_destroy(&event); } if (!session) { switch_core_destroy_memory_pool(&pool); } return extension; } void str_repeat(size_t how_many, char *what, switch_stream_handle_t *str_stream) { size_t i; /*switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "repeating %d of '%s'\n", (int)how_many, what);*/ for (i=0; iwrite_function(str_stream, "%s", what); } } SWITCH_STANDARD_APP(lcr_app_function) { int argc = 0; char *argv[32] = { 0 }; char *mydata = NULL; char *dest = NULL; char vbuf[1024] = ""; uint32_t cnt = 1; char *lcr_profile = NULL; switch_channel_t *channel = switch_core_session_get_channel(session); switch_caller_profile_t *caller_profile = NULL; callback_t routes = { 0 }; lcr_route cur_route = { 0 }; switch_memory_pool_t *pool; switch_event_t *event; const char *intra = NULL; const char *lrn = NULL; if (!(mydata = switch_core_session_strdup(session, data))) { return; } if (session) { pool = switch_core_session_get_pool(session); routes.session = session; } else { switch_core_new_memory_pool(&pool); switch_event_create(&event, SWITCH_EVENT_MESSAGE); routes.event = event; } routes.pool = pool; lrn = switch_channel_get_variable(channel, "lrn"); routes.lrn_number = (char *) lrn; intra = switch_channel_get_variable(channel, "intrastate"); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "intrastate channel var is [%s]\n", zstr(intra) ? "undef" : intra); if (zstr(intra) || strcasecmp((char *)intra, "true")) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Select routes based on interstate rates\n"); routes.intrastate = SWITCH_FALSE; } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Select routes based on intrastate rates\n"); routes.intrastate = SWITCH_TRUE; } if (!caller_profile) { if (!(caller_profile = switch_channel_get_caller_profile(channel))) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Unable to locate caller_profile\n"); } } if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) { dest = argv[0]; if (argc > 1) { lcr_profile = argv[1]; } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "LCR Lookup on %s using profile %s\n", dest, lcr_profile); routes.lookup_number = dest; if (caller_profile) { routes.cid = (char *) switch_channel_get_variable(channel, "effective_caller_id_number"); if (!routes.cid) { routes.cid = (char *) caller_profile->caller_id_number; } } if (!(routes.profile = locate_profile(lcr_profile))) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Unknown profile: %s\n", lcr_profile); goto end; } if (lcr_do_lookup(&routes) == SWITCH_STATUS_SUCCESS) { switch_stream_handle_t dig_stream = { 0 }; SWITCH_STANDARD_STREAM(dig_stream); for (cur_route = routes.head; cur_route; cur_route = cur_route->next) { switch_snprintf(vbuf, sizeof(vbuf), "lcr_route_%d", cnt); switch_channel_set_variable(channel, vbuf, cur_route->dialstring); switch_snprintf(vbuf, sizeof(vbuf), "lcr_rate_%d", cnt); switch_channel_set_variable(channel, vbuf, cur_route->rate_str); switch_snprintf(vbuf, sizeof(vbuf), "lcr_carrier_%d", cnt); switch_channel_set_variable(channel, vbuf, cur_route->carrier_name); switch_snprintf(vbuf, sizeof(vbuf), "lcr_codec_%d", cnt); switch_channel_set_variable(channel, vbuf, cur_route->codec); if (cur_route->next) { if (routes.profile->enable_sip_redir) { dig_stream.write_function(&dig_stream, "%s,", cur_route->dialstring); } else { dig_stream.write_function(&dig_stream, "%s|", cur_route->dialstring); } } else { dig_stream.write_function(&dig_stream, "%s", cur_route->dialstring); } cnt++; } switch_snprintf(vbuf, sizeof(vbuf), "%d", cnt - 1); switch_channel_set_variable(channel, "lcr_route_count", vbuf); switch_channel_set_variable(channel, "lcr_auto_route", (char *)dig_stream.data); if (zstr(switch_channel_get_variable(channel, "import"))) { switch_channel_set_variable(channel, "import", "lcr_carrier,lcr_rate,lcr_user_rate"); } else { const char *tmp = switch_channel_get_variable(channel, "import"); if (!strstr(tmp, "lcr_carrier,lcr_rate,lcr_user_rate")) { switch_channel_set_variable_printf(channel, "import", "%s,lcr_carrier,lcr_rate,lcr_user_rate", tmp); } } free(dig_stream.data); } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "LCR lookup failed for %s\n", dest); } } end: lcr_destroy(routes.head); if (routes.event) { switch_event_destroy(&event); } if (!session) { switch_core_destroy_memory_pool(&pool); } } static void write_data(switch_stream_handle_t *stream, switch_bool_t as_xml, const char *key, const char *data, int indent, int maxlen) { if (!data) { data = ""; } if (as_xml) { str_repeat(indent*2, " ", stream); stream->write_function(stream, "<%s>%s\n", key, data, key); } else { stream->write_function(stream, " | %s", data); str_repeat((maxlen - strlen(data)), " ", stream); } } SWITCH_STANDARD_API(dialplan_lcr_function) { char *argv[32] = { 0 }; int argc; char *mydata = NULL; char *lcr_profile = NULL; lcr_route current = NULL; max_obj_t maximum_lengths = { 0 }; callback_t cb_struct = { 0 }; switch_memory_pool_t *pool = NULL; switch_event_t *event; switch_status_t lookup_status = SWITCH_STATUS_SUCCESS; switch_bool_t as_xml = SWITCH_FALSE; char *event_str = NULL; switch_xml_t event_xml = NULL; int rowcount = 0; if (zstr(cmd)) { goto usage; } switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG , "data passed to lcr is [%s]\n", cmd ); if (session) { pool = switch_core_session_get_pool(session); cb_struct.session = session; } else { switch_core_new_memory_pool(&pool); switch_event_create(&event, SWITCH_EVENT_MESSAGE); cb_struct.event = event; } cb_struct.pool = pool; mydata = switch_core_strdup(pool, cmd); if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) { switch_assert(argv[0] != NULL); cb_struct.lookup_number = switch_core_strdup(pool, argv[0]); if (argc > 1) { lcr_profile = argv[1]; } if (argc > 2) { int i; for (i = 2; i < argc; i++) { if (!strcasecmp(argv[i], "intrastate")) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Select routes based on intrastate rates\n"); cb_struct.intrastate = SWITCH_TRUE; } else if (!strcasecmp(argv[i], "lrn")) { i++; if (argv[i]) { cb_struct.lrn_number = argv[i]; switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "LRN number [%s]\n", cb_struct.lrn_number); } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "you must pass a LRN number to use lrn\n"); } } else if (!strcasecmp(argv[i], "as")) { i++; if (argv[i] && !strcasecmp(argv[i], "xml")) { as_xml = SWITCH_TRUE; } else { goto usage; } } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set Caller ID to [%s]\n", argv[i]); /* the only other option we have right now is caller id */ cb_struct.cid = switch_core_strdup(pool, argv[i]); } } } if (zstr(cb_struct.cid)) { cb_struct.cid = "18005551212"; switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING , "Using default CID [%s]\n", cb_struct.cid ); } if (!(cb_struct.profile = locate_profile(lcr_profile))) { stream->write_function(stream, "-ERR Unknown profile: %s\n", lcr_profile); goto end; } lookup_status = lcr_do_lookup(&cb_struct); if (cb_struct.head != NULL) { size_t len; if (as_xml) { stream->write_function(stream, "\n"); } else { process_max_lengths(&maximum_lengths, cb_struct.head, cb_struct.lookup_number); stream->write_function(stream, " | %s", headers[LCR_HEADERS_DIGITS]); if ((len = (maximum_lengths.digit_str - strlen(headers[LCR_HEADERS_DIGITS]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " | %s", headers[LCR_HEADERS_CARRIER]); if ((len = (maximum_lengths.carrier_name - strlen(headers[LCR_HEADERS_CARRIER]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " | %s", headers[LCR_HEADERS_RATE]); if ((len = (maximum_lengths.rate - strlen(headers[LCR_HEADERS_RATE]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " | %s", headers[LCR_HEADERS_CODEC]); if ((len = (maximum_lengths.codec - strlen(headers[LCR_HEADERS_CODEC]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " | %s", headers[LCR_HEADERS_CID]); if ((len = (maximum_lengths.cid - strlen(headers[LCR_HEADERS_CID]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " | %s", headers[LCR_HEADERS_LIMIT]); if ((len = (maximum_lengths.limit - strlen(headers[LCR_HEADERS_LIMIT]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " | %s", headers[LCR_HEADERS_DIALSTRING]); if ((len = (maximum_lengths.dialstring - strlen(headers[LCR_HEADERS_DIALSTRING]))) > 0) { str_repeat(len, " ", stream); } stream->write_function(stream, " |\n"); } current = cb_struct.head; while (current) { //dialstring = get_bridge_data(pool, cb_struct.lookup_number, cb_struct.cid, current, cb_struct.profile, cb_struct.session); rowcount++; if (as_xml) { stream->write_function(stream, " \n", rowcount); } write_data(stream, as_xml, "prefix", current->digit_str, 2, maximum_lengths.digit_str); write_data(stream, as_xml, "carrier_name", current->carrier_name, 2, maximum_lengths.carrier_name); write_data(stream, as_xml, "rate", current->rate_str, 2, maximum_lengths.rate); if (current->codec) { write_data(stream, as_xml, "codec", current->codec, 2, maximum_lengths.codec); } else { write_data(stream, as_xml, "codec", "", 2, maximum_lengths.codec); } if (current->cid) { write_data(stream, as_xml, "cid", current->cid, 2, maximum_lengths.cid); } else { write_data(stream, as_xml, "cid", "", 2, maximum_lengths.cid); } if (current->limit_realm && current->limit_id) { char *str = NULL; str = switch_core_sprintf(pool, "%s %s %d", current->limit_realm, current->limit_id, current->limit_max); write_data(stream, as_xml, "limit", str, 2, maximum_lengths.limit); } else { write_data(stream, as_xml, "limit", "", 2, maximum_lengths.limit); } write_data(stream, as_xml, "dialstring", current->dialstring, 2, maximum_lengths.dialstring); if (as_xml) { event_xml = switch_event_xmlize(current->fields, SWITCH_VA_NONE); event_str = switch_xml_toxml(event_xml, SWITCH_FALSE); stream->write_function(stream, "%s", event_str); switch_xml_free(event_xml); switch_safe_free(event_str); } if (as_xml) { stream->write_function(stream, " \n"); } else { stream->write_function(stream, " |\n"); } current = current->next; } if (as_xml) { stream->write_function(stream, "\n"); } } else { if (lookup_status == SWITCH_STATUS_SUCCESS) { if (as_xml) { stream->write_function(stream, "\n\n"); } else { stream->write_function(stream, "No Routes To Display\n"); } } else { stream->write_function(stream, "-ERR Error looking up routes\n"); } } } end: lcr_destroy(cb_struct.head); if (!session) { if (pool) { switch_core_destroy_memory_pool(&pool); } } return SWITCH_STATUS_SUCCESS; usage: stream->write_function(stream, "USAGE: %s\n", LCR_SYNTAX); goto end; } SWITCH_STANDARD_API(dialplan_lcr_admin_function) { char *argv[32] = { 0 }; int argc; char *mydata = NULL; switch_hash_index_t *hi; void *val; profile_t *profile; if (zstr(cmd)) { goto usage; } mydata = strdup(cmd); if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) { if (argc < 2) { goto usage; } switch_assert(argv[0]); if (!strcasecmp(argv[0], "show") && !strcasecmp(argv[1], "profiles")) { for (hi = switch_hash_first(NULL, globals.profile_hash); hi; hi = switch_hash_next(hi)) { switch_hash_this(hi, NULL, NULL, &val); profile = (profile_t *) val; stream->write_function(stream, "Name:\t\t%s\n", profile->name); if (zstr(profile->custom_sql)) { stream->write_function(stream, " ID:\t\t%d\n", profile->id); stream->write_function(stream, " order by:\t%s\n", profile->order_by); } else { stream->write_function(stream, " custom sql:\t%s\n", profile->custom_sql); stream->write_function(stream, " has %%:\t\t%s\n", profile->custom_sql_has_percent ? "true" : "false"); stream->write_function(stream, " has vars:\t%s\n", profile->custom_sql_has_vars ? "true" : "false"); } stream->write_function(stream, " has intrastate:\t%s\n", profile->profile_has_intrastate ? "true" : "false"); stream->write_function(stream, " has intralata:\t%s\n", profile->profile_has_intralata ? "true" : "false"); stream->write_function(stream, " has npanxx:\t%s\n", profile->profile_has_npanxx ? "true" : "false"); stream->write_function(stream, " Reorder rate:\t%s\n", profile->reorder_by_rate ? "enabled" : "disabled"); stream->write_function(stream, " Info in headers:\t%s\n", profile->info_in_headers ? "enabled" : "disabled"); stream->write_function(stream, " Quote IN() List:\t%s\n", profile->quote_in_list ? "enabled" : "disabled"); stream->write_function(stream, " Single Bridge:\t%s\n", profile->single_bridge ? "enabled" : "disabled"); stream->write_function(stream, " Sip Redirection Mode:\t%s\n", profile->enable_sip_redir ? "enabled" : "disabled"); stream->write_function(stream, " Import fields:\t%s\n", profile->export_fields_str ? profile->export_fields_str : "(null)"); stream->write_function(stream, " Limit type:\t%s\n", profile->limit_type); stream->write_function(stream, "\n"); } } else { goto usage; } } switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; usage: switch_safe_free(mydata); stream->write_function(stream, "-ERR %s\n", LCR_ADMIN_SYNTAX); return SWITCH_STATUS_SUCCESS; } SWITCH_MODULE_LOAD_FUNCTION(mod_lcr_load) { switch_api_interface_t *dialplan_lcr_api_interface; switch_api_interface_t *dialplan_lcr_api_admin_interface; switch_application_interface_t *app_interface; switch_dialplan_interface_t *dp_interface; *module_interface = switch_loadable_module_create_module_interface(pool, modname); globals.pool = pool; if (switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, globals.pool) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to initialize mutex\n"); } if (lcr_load_config() != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to load lcr config file\n"); return SWITCH_STATUS_FALSE; } SWITCH_ADD_API(dialplan_lcr_api_interface, "lcr", "Least Cost Routing Module", dialplan_lcr_function, LCR_SYNTAX); SWITCH_ADD_API(dialplan_lcr_api_admin_interface, "lcr_admin", "Least Cost Routing Module Admin", dialplan_lcr_admin_function, LCR_ADMIN_SYNTAX); SWITCH_ADD_APP(app_interface, "lcr", "Perform an LCR lookup", "Perform an LCR lookup", lcr_app_function, "", SAF_SUPPORT_NOMEDIA | SAF_ROUTING_EXEC); SWITCH_ADD_DIALPLAN(dp_interface, "lcr", lcr_dialplan_hunt); lcr_endpoint_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE); lcr_endpoint_interface->interface_name = "lcr"; lcr_endpoint_interface->io_routines = &lcr_io_routines; /* indicate that the module should continue to be loaded */ return SWITCH_STATUS_SUCCESS; } SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_lcr_shutdown) { switch_core_hash_destroy(&globals.profile_hash); 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: */