SWITCH_DECLARE(int) switch_config_open_file(switch_config_t *cfg, char *file_path)
{
FILE *f;
char *path = NULL;
char path_buf[1024];
if (switch_is_file_path(file_path)) {
path = file_path;
} else {
switch_snprintf(path_buf, sizeof(path_buf), "%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, file_path);
path = path_buf;
}
if (!path) {
return 0;
}
memset(cfg, 0, sizeof(*cfg));
cfg->lockto = -1;
if (!(f = fopen(path, "r"))) {
if (!switch_is_file_path(file_path)) {
int last = -1;
char *var, *val;
switch_snprintf(path_buf, sizeof(path_buf), "%s%sfreeswitch.conf", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR);
path = path_buf;
if ((f = fopen(path, "r")) == 0) {
return 0;
}
cfg->file = f;
switch_set_string(cfg->path, path);
while (switch_config_next_pair(cfg, &var, &val)) {
if (file_path && (cfg->sectno != last) && !strcmp(cfg->section, file_path)) {
cfg->lockto = cfg->sectno;
return 1;
}
}
switch_config_close_file(cfg);
memset(cfg, 0, sizeof(*cfg));
return 0;
}
return 0;
} else {
cfg->file = f;
switch_set_string(cfg->path, path);
return 1;
}
}
SWITCH_DECLARE(switch_status_t) switch_stream_write_file_contents(switch_stream_handle_t *stream, const char *path)
{
char *dpath = NULL;
FILE *fd = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
if (!switch_is_file_path(path)) {
dpath = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, path);
path = dpath;
}
if ((fd = fopen(path, "r"))) {
char *line_buf = NULL;
switch_size_t llen = 0;
while (switch_fp_read_dline(fd, &line_buf, &llen)) {
stream->write_function(stream, "%s", line_buf);
}
fclose(fd);
switch_safe_free(line_buf);
status = SWITCH_STATUS_SUCCESS;
}
switch_safe_free(dpath);
return status;
}
static void db_pick_path(const char *dbname, char *buf, switch_size_t size)
{
memset(buf, 0, size);
if (switch_is_file_path(dbname)) {
strncpy(buf, dbname, size);
} else {
switch_snprintf(buf, size, "%s%s%s.db", SWITCH_GLOBAL_dirs.db_dir, SWITCH_PATH_SEPARATOR, dbname);
}
}
SWITCH_DECLARE(switch_status_t) switch_stream_write_file_contents(switch_stream_handle_t *stream, const char *path)
{
char *dpath = NULL;
int fd;
switch_status_t status = SWITCH_STATUS_FALSE;
if (!switch_is_file_path(path)) {
dpath = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, path);
path = dpath;
}
if ((fd = open(path, O_RDONLY)) > -1) {
char buf[2048] = { 0 };
while (switch_fd_read_line(fd, buf, sizeof(buf))) {
stream->write_function(stream, "%s", buf);
}
close(fd);
status = SWITCH_STATUS_SUCCESS;
}
switch_safe_free(dpath);
return status;
}
static switch_status_t my_on_reporting(switch_core_session_t *session)
{
cJSON *json_cdr = NULL;
char *json_text = NULL;
char *path = NULL;
char *curl_json_text = NULL;
const char *logdir = NULL;
char *json_text_escaped = NULL;
int fd = -1, err_dir_index;
uint32_t cur_try;
long httpRes;
CURL *curl_handle = NULL;
switch_curl_slist_t *headers = NULL;
switch_curl_slist_t *slist = NULL;
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_FALSE;
int is_b;
const char *a_prefix = "";
if (globals.shutdown) {
return SWITCH_STATUS_SUCCESS;
}
is_b = channel && switch_channel_get_originator_caller_profile(channel);
if (!globals.log_b && is_b) {
const char *force_cdr = switch_channel_get_variable(channel, SWITCH_FORCE_PROCESS_CDR_VARIABLE);
if (!switch_true(force_cdr)) {
return SWITCH_STATUS_SUCCESS;
}
}
if (!is_b && globals.prefix_a)
a_prefix = "a_";
if (switch_ivr_generate_json_cdr(session, &json_cdr, globals.encode_values == ENCODING_DEFAULT) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Generating Data!\n");
return SWITCH_STATUS_FALSE;
}
json_text = cJSON_PrintUnformatted(json_cdr);
if (!json_text) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
goto error;
}
switch_thread_rwlock_rdlock(globals.log_path_lock);
if (!(logdir = switch_channel_get_variable(channel, "json_cdr_base"))) {
logdir = globals.log_dir;
}
if (!zstr(logdir) && (globals.log_http_and_disk || !globals.url_count)) {
path = switch_mprintf("%s%s%s%s.cdr.json", logdir, SWITCH_PATH_SEPARATOR, a_prefix, switch_core_session_get_uuid(session));
switch_thread_rwlock_unlock(globals.log_path_lock);
if (path) {
#ifdef _MSC_VER
if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) {
#else
if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) > -1) {
#endif
int wrote;
wrote = write(fd, json_text, (unsigned) strlen(json_text));
close(fd);
fd = -1;
if(wrote < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error writing [%s]\n",path);
}
} else {
char ebuf[512] = { 0 };
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error writing [%s][%s]\n",
path, switch_strerror_r(errno, ebuf, sizeof(ebuf)));
}
switch_safe_free(path);
}
} else {
switch_thread_rwlock_unlock(globals.log_path_lock);
}
/* try to post it to the web server */
if (globals.url_count) {
char *destUrl = NULL;
curl_handle = switch_curl_easy_init();
if (globals.encode) {
switch_size_t need_bytes = strlen(json_text) * 3;
json_text_escaped = malloc(need_bytes);
switch_assert(json_text_escaped);
memset(json_text_escaped, 0, need_bytes);
if (globals.encode == ENCODING_DEFAULT) {
headers = switch_curl_slist_append(headers, "Content-Type: application/x-www-form-urlencoded");
switch_url_encode(json_text, json_text_escaped, need_bytes);
} else {
headers = switch_curl_slist_append(headers, "Content-Type: application/x-www-form-base64-encoded");
switch_b64_encode((unsigned char *) json_text, need_bytes / 3, (unsigned char *) json_text_escaped, need_bytes);
}
switch_safe_free(json_text);
json_text = json_text_escaped;
if (!(curl_json_text = switch_mprintf("cdr=%s", json_text))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
goto error;
}
} else {
headers = switch_curl_slist_append(headers, "Content-Type: application/json");
curl_json_text = (char *)json_text;
}
if (!zstr(globals.cred)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_HTTPAUTH, globals.auth_scheme);
switch_curl_easy_setopt(curl_handle, CURLOPT_USERPWD, globals.cred);
}
switch_curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, headers);
switch_curl_easy_setopt(curl_handle, CURLOPT_POST, 1);
switch_curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1);
switch_curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDS, curl_json_text);
switch_curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "freeswitch-json/1.0");
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, httpCallBack);
if (globals.disable100continue) {
slist = switch_curl_slist_append(slist, "Expect:");
switch_curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, slist);
}
if (globals.ssl_cert_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLCERT, globals.ssl_cert_file);
}
if (globals.ssl_key_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLKEY, globals.ssl_key_file);
}
if (globals.ssl_key_password) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLKEYPASSWD, globals.ssl_key_password);
}
if (globals.ssl_version) {
if (!strcasecmp(globals.ssl_version, "SSLv3")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv3);
} else if (!strcasecmp(globals.ssl_version, "TLSv1")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
}
}
if (globals.ssl_cacert_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_CAINFO, globals.ssl_cacert_file);
}
/* these were used for testing, optionally they may be enabled if someone desires
switch_curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 120); // tcp timeout
switch_curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1); // 302 recursion level
*/
for (cur_try = 0; cur_try < globals.retries; cur_try++) {
if (cur_try > 0) {
switch_yield(globals.delay * 1000000);
}
destUrl = switch_mprintf("%s?uuid=%s", globals.urls[globals.url_index], switch_core_session_get_uuid(session));
switch_curl_easy_setopt(curl_handle, CURLOPT_URL, destUrl);
if (!strncasecmp(destUrl, "https", 5)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, 0);
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 0);
}
if (globals.enable_cacert_check) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, TRUE);
}
if (globals.enable_ssl_verifyhost) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 2);
}
switch_curl_easy_perform(curl_handle);
switch_curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &httpRes);
switch_safe_free(destUrl);
if (httpRes >= 200 && httpRes < 300) {
goto success;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Got error [%ld] posting to web server [%s]\n",
httpRes, globals.urls[globals.url_index]);
globals.url_index++;
switch_assert(globals.url_count <= MAX_URLS);
if (globals.url_index >= globals.url_count) {
globals.url_index = 0;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Retry will be with url [%s]\n", globals.urls[globals.url_index]);
}
}
switch_curl_easy_cleanup(curl_handle);
switch_curl_slist_free_all(headers);
switch_curl_slist_free_all(slist);
slist = NULL;
headers = NULL;
curl_handle = NULL;
/* if we are here the web post failed for some reason */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to post to web server, writing to file\n");
for (err_dir_index = 0; err_dir_index < globals.err_dir_count; err_dir_index++) {
switch_thread_rwlock_rdlock(globals.log_path_lock);
path = switch_mprintf("%s%s%s%s.cdr.json", globals.err_log_dir[err_dir_index], SWITCH_PATH_SEPARATOR, a_prefix, switch_core_session_get_uuid(session));
switch_thread_rwlock_unlock(globals.log_path_lock);
if (path) {
#ifdef _MSC_VER
if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) {
#else
if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) > -1) {
#endif
int wrote;
wrote = write(fd, json_text, (unsigned) strlen(json_text));
close(fd);
fd = -1;
if(wrote < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error writing [%s]\n",path);
}
break;
} else {
char ebuf[512] = { 0 };
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open %s! [%s]\n",
path, switch_strerror_r(errno, ebuf, sizeof(ebuf)));
}
switch_safe_free(path);
}
}
}
success:
status = SWITCH_STATUS_SUCCESS;
error:
if (curl_handle) {
switch_curl_easy_cleanup(curl_handle);
}
if (headers) {
switch_curl_slist_free_all(headers);
}
if (slist) {
switch_curl_slist_free_all(slist);
}
if (curl_json_text != json_text) {
switch_safe_free(curl_json_text);
}
cJSON_Delete(json_cdr);
switch_safe_free(json_text);
return status;
}
static void event_handler(switch_event_t *event)
{
const char *sig = switch_event_get_header(event, "Trapped-Signal");
if (sig && !strcmp(sig, "HUP")) {
if (globals.rotate) {
set_json_cdr_log_dirs();
}
}
}
static switch_state_handler_table_t state_handlers = {
/*.on_init */ NULL,
/*.on_routing */ NULL,
/*.on_execute */ NULL,
/*.on_hangup */ NULL,
/*.on_exchange_media */ NULL,
/*.on_soft_execute */ NULL,
/*.on_consume_media */ NULL,
/*.on_hibernate */ NULL,
/*.on_reset */ NULL,
/*.on_park */ NULL,
/*.on_reporting */ my_on_reporting
};
SWITCH_MODULE_LOAD_FUNCTION(mod_json_cdr_load)
{
char *cf = "json_cdr.conf";
switch_xml_t cfg, xml, settings, param;
switch_status_t status = SWITCH_STATUS_SUCCESS;
/* test global state handlers */
switch_core_add_state_handler(&state_handlers);
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
memset(&globals, 0, sizeof(globals));
if (switch_event_bind_removable(modname, SWITCH_EVENT_TRAP, SWITCH_EVENT_SUBCLASS_ANY, event_handler, NULL, &globals.node) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind!\n");
return SWITCH_STATUS_GENERR;
}
globals.log_http_and_disk = 0;
globals.log_b = 1;
globals.disable100continue = 0;
globals.pool = pool;
globals.auth_scheme = CURLAUTH_BASIC;
globals.encode_values = ENCODING_DEFAULT;
switch_thread_rwlock_create(&globals.log_path_lock, pool);
/* parse the config */
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 = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "cred") && !zstr(val)) {
globals.cred = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "url") && !zstr(val)) {
if (globals.url_count >= MAX_URLS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "maximum urls configured!\n");
} else {
globals.urls[globals.url_count++] = switch_core_strdup(globals.pool, val);
}
} else if (!strcasecmp(var, "log-http-and-disk")) {
globals.log_http_and_disk = switch_true(val);
} else if (!strcasecmp(var, "delay") && !zstr(val)) {
globals.delay = (uint32_t) atoi(val);
} else if (!strcasecmp(var, "log-b-leg")) {
globals.log_b = switch_true(val);
} else if (!strcasecmp(var, "prefix-a-leg")) {
globals.prefix_a = switch_true(val);
} else if (!strcasecmp(var, "disable-100-continue") && switch_true(val)) {
globals.disable100continue = 1;
} else if (!strcasecmp(var, "encode") && !zstr(val)) {
if (!strcasecmp(val, "base64")) {
globals.encode = ENCODING_BASE64;
} else {
globals.encode = switch_true(val) ? ENCODING_DEFAULT : ENCODING_NONE;
}
} else if (!strcasecmp(var, "retries") && !zstr(val)) {
globals.retries = (uint32_t) atoi(val);
} else if (!strcasecmp(var, "rotate") && !zstr(val)) {
globals.rotate = switch_true(val);
} else if (!strcasecmp(var, "log-dir")) {
if (zstr(val)) {
globals.base_log_dir = switch_core_sprintf(globals.pool, "%s%sjson_cdr", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR);
} else {
if (switch_is_file_path(val)) {
globals.base_log_dir = switch_core_strdup(globals.pool, val);
} else {
globals.base_log_dir = switch_core_sprintf(globals.pool, "%s%s%s", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, val);
}
}
} else if (!strcasecmp(var, "err-log-dir")) {
if (globals.err_dir_count >= MAX_ERR_DIRS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "maximum error directories configured!\n");
} else {
if (zstr(val)) {
globals.base_err_log_dir[globals.err_dir_count++] = switch_core_sprintf(globals.pool, "%s%sjson_cdr", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR);
} else {
if (switch_is_file_path(val)) {
globals.base_err_log_dir[globals.err_dir_count++] = switch_core_strdup(globals.pool, val);
} else {
globals.base_err_log_dir[globals.err_dir_count++] = switch_core_sprintf(globals.pool, "%s%s%s", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, val);
}
}
}
} else if (!strcasecmp(var, "enable-cacert-check") && switch_true(val)) {
globals.enable_cacert_check = 1;
} else if (!strcasecmp(var, "ssl-cert-path")) {
globals.ssl_cert_file = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "ssl-key-path")) {
globals.ssl_key_file = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "ssl-key-password")) {
globals.ssl_key_password = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "ssl-version")) {
globals.ssl_version = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "ssl-cacert-file")) {
globals.ssl_cacert_file = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "enable-ssl-verifyhost") && switch_true(val)) {
globals.enable_ssl_verifyhost = 1;
} else if (!strcasecmp(var, "auth-scheme")) {
if (*val == '=') {
globals.auth_scheme = 0;
val++;
}
if (!strcasecmp(val, "basic")) {
globals.auth_scheme |= CURLAUTH_BASIC;
} else if (!strcasecmp(val, "digest")) {
globals.auth_scheme |= CURLAUTH_DIGEST;
} else if (!strcasecmp(val, "NTLM")) {
globals.auth_scheme |= CURLAUTH_NTLM;
} else if (!strcasecmp(val, "GSS-NEGOTIATE")) {
globals.auth_scheme |= CURLAUTH_GSSNEGOTIATE;
} else if (!strcasecmp(val, "any")) {
globals.auth_scheme = CURLAUTH_ANY;
}
} else if (!strcasecmp(var, "encode-values") && !zstr(val)) {
globals.encode_values = switch_true(val) ? ENCODING_DEFAULT : ENCODING_NONE;
}
}
if (!globals.err_dir_count) {
if (!zstr(globals.base_log_dir)) {
globals.base_err_log_dir[globals.err_dir_count++] = switch_core_strdup(globals.pool, globals.base_log_dir);
} else {
globals.base_err_log_dir[globals.err_dir_count++] = switch_core_sprintf(globals.pool, "%s%sjson_cdr", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR);
}
}
}
if (globals.retries && !globals.delay) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Retries set but delay 0 setting to 5 seconds\n");
globals.delay = 5;
}
globals.retries++;
set_json_cdr_log_dirs();
switch_xml_free(xml);
return status;
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_json_cdr_shutdown)
{
int err_dir_index = 0;
globals.shutdown = 1;
switch_safe_free(globals.log_dir);
for (;err_dir_index < globals.err_dir_count; err_dir_index++) {
switch_safe_free(globals.err_log_dir[err_dir_index]);
}
switch_event_unbind(&globals.node);
switch_core_remove_state_handler(&state_handlers);
switch_thread_rwlock_destroy(globals.log_path_lock);
return SWITCH_STATUS_SUCCESS;
}
/*! function to load a grammar to the asr interface */
static switch_status_t pocketsphinx_asr_load_grammar(switch_asr_handle_t *ah, const char *grammar, const char *name)
{
char *jsgf, *dic, *model, *rate = NULL;
pocketsphinx_t *ps = (pocketsphinx_t *) ah->private_info;
switch_status_t status = SWITCH_STATUS_FALSE;
if (switch_test_flag(ps, PSFLAG_READY)) {
ps_end_utt(ps->ps);
switch_clear_flag(ps, PSFLAG_READY);
}
if (switch_is_file_path(grammar)) {
char *dot = strrchr(grammar, '.');
if (dot && !strcmp(dot, ".gram")) {
jsgf = strdup(grammar);
} else {
jsgf = switch_mprintf("%s.gram", grammar);
}
} else {
jsgf = switch_mprintf("%s%s%s.gram", SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_PATH_SEPARATOR, grammar);
}
if (ah->rate == 8000) {
model = switch_mprintf("%s%smodel%s%s", SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_PATH_SEPARATOR, SWITCH_PATH_SEPARATOR, globals.model8k);
} else {
model = switch_mprintf("%s%smodel%s%s", SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_PATH_SEPARATOR, SWITCH_PATH_SEPARATOR, globals.model16k);
}
dic = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_PATH_SEPARATOR, globals.dictionary);
if (switch_file_exists(dic, ah->memory_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open dictionary %s.\n", dic);
goto end;
}
if (switch_file_exists(model, ah->memory_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Can't open speech model %s.\n", model);
goto end;
}
if (switch_file_exists(jsgf, ah->memory_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Can't open grammar file %s.\n", jsgf);
goto end;
}
rate = switch_mprintf("%d", ah->rate);
switch_assert(jsgf && dic && model);
ps->config = cmd_ln_init(ps->config, ps_args(), FALSE,
"-samprate", rate,
"-hmm", model, "-jsgf", jsgf, "-lw", globals.language_weight, "-dict", dic, "-frate", "50", "-silprob", "0.005", NULL);
if (ps->config == NULL) {
status = SWITCH_STATUS_GENERR;
goto end;
}
switch_mutex_lock(ps->flag_mutex);
if (switch_test_flag(ps, PSFLAG_ALLOCATED)) {
ps_reinit(ps->ps, ps->config);
} else {
if (!(ps->ps = ps_init(ps->config))) {
switch_mutex_unlock(ps->flag_mutex);
goto end;
}
switch_set_flag(ps, PSFLAG_ALLOCATED);
}
switch_mutex_unlock(ps->flag_mutex);
ps_start_utt(ps->ps, NULL);
switch_set_flag(ps, PSFLAG_READY);
switch_safe_free(ps->grammar);
ps->grammar = strdup(grammar);
status = SWITCH_STATUS_SUCCESS;
end:
switch_safe_free(rate);
switch_safe_free(jsgf);
switch_safe_free(dic);
switch_safe_free(model);
return status;
}
static int lua_parse_and_execute(lua_State * L, char *input_code)
{
int error = 0;
if (zstr(input_code)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No code to execute!\n");
return 1;
}
while(input_code && (*input_code == ' ' || *input_code == '\n' || *input_code == '\r')) input_code++;
if (*input_code == '~') {
char *buff = input_code + 1;
error = luaL_loadbuffer(L, buff, strlen(buff), "line") || docall(L, 0, 0, 0); //lua_pcall(L, 0, 0, 0);
} else if (!strncasecmp(input_code, "#!/lua", 6)) {
char *buff = input_code + 6;
error = luaL_loadbuffer(L, buff, strlen(buff), "line") || docall(L, 0, 0, 0); //lua_pcall(L, 0, 0, 0);
} else {
char *args = strchr(input_code, ' ');
if (args) {
char *code = NULL;
int x, argc;
char *argv[128] = { 0 };
*args++ = '\0';
if ((argc = switch_separate_string(args, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
switch_stream_handle_t stream = { 0 };
SWITCH_STANDARD_STREAM(stream);
stream.write_function(&stream, " argv = {[0]='%y', ", input_code);
for (x = 0; x < argc; x++) {
stream.write_function(&stream, "'%y'%s", argv[x], x == argc - 1 ? "" : ", ");
}
stream.write_function(&stream, " };");
code = (char *) stream.data;
} else {
code = switch_mprintf("argv = {[0]='%s'};", input_code);
}
if (code) {
error = luaL_loadbuffer(L, code, strlen(code), "line") || docall(L, 0, 0, 0);
switch_safe_free(code);
}
} else {
// Force empty argv table
char *code = NULL;
code = switch_mprintf("argv = {[0]='%s'};", input_code);
error = luaL_loadbuffer(L, code, strlen(code), "line") || docall(L, 0, 0, 0);
switch_safe_free(code);
}
if (!error) {
char *file = input_code, *fdup = NULL;
if (!switch_is_file_path(file)) {
fdup = switch_mprintf("%s/%s", SWITCH_GLOBAL_dirs.script_dir, file);
switch_assert(fdup);
file = fdup;
}
error = luaL_loadfile(L, file) || docall(L, 0, 0, 0);
switch_safe_free(fdup);
}
}
if (error) {
const char *err = lua_tostring(L, -1);
if (!zstr(err)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s\n", err);
}
lua_pop(L, 1); /* pop error message from the stack */
}
return error;
}
SWITCH_DECLARE(int) switch_core_gen_certs(const char *prefix)
{
//BIO *bio_err;
X509 *x509 = NULL;
EVP_PKEY *pkey = NULL;
char *rsa = NULL, *pvt = NULL;
FILE *fp;
char *pem = NULL;
if (switch_stristr(".pem", prefix)) {
if (switch_is_file_path(prefix)) {
pem = strdup(prefix);
} else {
pem = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
}
if (switch_file_exists(pem, NULL) == SWITCH_STATUS_SUCCESS) {
goto end;
}
} else {
if (switch_is_file_path(prefix)) {
pvt = switch_mprintf("%s.key", prefix);
rsa = switch_mprintf("%s.crt", prefix);
} else {
pvt = switch_mprintf("%s%s%s.key", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
rsa = switch_mprintf("%s%s%s.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
}
if (switch_file_exists(pvt, NULL) == SWITCH_STATUS_SUCCESS || switch_file_exists(rsa, NULL) == SWITCH_STATUS_SUCCESS) {
goto end;
}
}
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
//bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);
mkcert(&x509, &pkey, 1024, 0, 36500);
//RSA_print_fp(stdout, pkey->pkey.rsa, 0);
//X509_print_fp(stdout, x509);
if (pem) {
if ((fp = fopen(pem, "w"))) {
PEM_write_PrivateKey(fp, pkey, NULL, NULL, 0, NULL, NULL);
PEM_write_X509(fp, x509);
fclose(fp);
}
} else {
if (pvt && (fp = fopen(pvt, "w"))) {
PEM_write_PrivateKey(fp, pkey, NULL, NULL, 0, NULL, NULL);
fclose(fp);
}
if (rsa && (fp = fopen(rsa, "w"))) {
PEM_write_X509(fp, x509);
fclose(fp);
}
}
X509_free(x509);
EVP_PKEY_free(pkey);
#ifndef OPENSSL_NO_ENGINE
ENGINE_cleanup();
#endif
CRYPTO_cleanup_all_ex_data();
//CRYPTO_mem_leaks(bio_err);
//BIO_free(bio_err);
end:
switch_safe_free(pvt);
switch_safe_free(rsa);
switch_safe_free(pem);
return(0);
}
switch_status_t mod_format_cdr_load_profile_xml(switch_xml_t xprofile)
{
switch_memory_pool_t *pool = NULL;
cdr_profile_t *profile = NULL;
switch_xml_t settings, param;
char *profile_name = (char *) switch_xml_attr_soft(xprofile, "name");
if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "OH OH no pool\n");
return SWITCH_STATUS_TERM;
}
profile = switch_core_alloc(pool, sizeof(cdr_profile_t));
memset(profile, 0, sizeof(cdr_profile_t));
profile->pool = pool;
profile->name = switch_core_strdup(profile->pool, profile_name);
profile->log_http_and_disk = 0;
profile->log_b = 1;
profile->disable100continue = 0;
profile->auth_scheme = CURLAUTH_BASIC;
switch_thread_rwlock_create(&profile->log_path_lock, pool);
if ((settings = switch_xml_child(xprofile, "settings"))) {
for (param = switch_xml_child(settings, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "cred") && !zstr(val)) {
profile->cred = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "format") && !zstr(val)) {
profile->format = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "url") && !zstr(val)) {
if (profile->url_count >= MAX_URLS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "maximum urls configured!\n");
} else {
profile->urls[profile->url_count++] = switch_core_strdup(profile->pool, val);
}
} else if (!strcasecmp(var, "log-http-and-disk")) {
profile->log_http_and_disk = switch_true(val);
} else if (!strcasecmp(var, "timeout")) {
int tmp = atoi(val);
if (tmp >= 0) {
profile->timeout = tmp;
} else {
profile->timeout = 0;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't set a negative timeout!\n");
}
} else if (!strcasecmp(var, "delay") && !zstr(val)) {
profile->delay = switch_atoui(val);
} else if (!strcasecmp(var, "log-b-leg")) {
profile->log_b = switch_true(val);
} else if (!strcasecmp(var, "prefix-a-leg")) {
profile->prefix_a = switch_true(val);
} else if (!strcasecmp(var, "disable-100-continue") && switch_true(val)) {
profile->disable100continue = 1;
} else if (!strcasecmp(var, "encode") && !zstr(val)) {
if (!strcasecmp(val, "base64")) {
profile->encode = ENCODING_BASE64;
} else if (!strcasecmp(val, "textxml")) {
profile->encode = ENCODING_TEXTXML;
} else if (!strcasecmp(val, "appljson")) {
profile->encode = ENCODING_APPLJSON;
} else {
profile->encode = switch_true(val) ? ENCODING_DEFAULT : ENCODING_NONE;
}
} else if (!strcasecmp(var, "retries") && !zstr(val)) {
profile->retries = switch_atoui(val);
} else if (!strcasecmp(var, "rotate") && !zstr(val)) {
profile->rotate = switch_true(val);
} else if (!strcasecmp(var, "log-dir")) {
if (zstr(val)) {
profile->base_log_dir = switch_core_sprintf(profile->pool, "%s%sformat_cdr", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR);
} else {
if (switch_is_file_path(val)) {
profile->base_log_dir = switch_core_strdup(profile->pool, val);
} else {
profile->base_log_dir = switch_core_sprintf(profile->pool, "%s%s%s", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, val);
}
}
} else if (!strcasecmp(var, "err-log-dir")) {
if (profile->err_dir_count >= MAX_ERR_DIRS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "maximum error directories configured!\n");
} else {
if (zstr(val)) {
profile->base_err_log_dir[profile->err_dir_count++] = switch_core_sprintf(profile->pool, "%s%sformat_cdr", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR);
} else {
if (switch_is_file_path(val)) {
profile->base_err_log_dir[profile->err_dir_count++] = switch_core_strdup(profile->pool, val);
} else {
profile->base_err_log_dir[profile->err_dir_count++] = switch_core_sprintf(profile->pool, "%s%s%s", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, val);
}
}
}
} else if (!strcasecmp(var, "enable-cacert-check") && switch_true(val)) {
profile->enable_cacert_check = 1;
} else if (!strcasecmp(var, "ssl-cert-path")) {
profile->ssl_cert_file = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "ssl-key-path")) {
profile->ssl_key_file = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "ssl-key-password")) {
profile->ssl_key_password = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "ssl-version")) {
profile->ssl_version = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "ssl-cacert-file")) {
profile->ssl_cacert_file = switch_core_strdup(profile->pool, val);
} else if (!strcasecmp(var, "enable-ssl-verifyhost") && switch_true(val)) {
profile->enable_ssl_verifyhost = 1;
} else if (!strcasecmp(var, "auth-scheme")) {
if (*val == '=') {
profile->auth_scheme = 0;
val++;
}
if (!strcasecmp(val, "basic")) {
profile->auth_scheme |= CURLAUTH_BASIC;
} else if (!strcasecmp(val, "digest")) {
profile->auth_scheme |= CURLAUTH_DIGEST;
} else if (!strcasecmp(val, "NTLM")) {
profile->auth_scheme |= CURLAUTH_NTLM;
} else if (!strcasecmp(val, "GSS-NEGOTIATE")) {
profile->auth_scheme |= CURLAUTH_GSSNEGOTIATE;
} else if (!strcasecmp(val, "any")) {
profile->auth_scheme = CURLAUTH_ANY;
}
} else if (!strcasecmp(var, "encode-values") && !zstr(val)) {
profile->encode_values = switch_true(val) ? ENCODING_DEFAULT : ENCODING_NONE;
}
}
if (!profile->err_dir_count) {
if (!zstr(profile->base_log_dir)) {
profile->base_err_log_dir[profile->err_dir_count++] = switch_core_strdup(profile->pool, profile->base_log_dir);
} else {
profile->base_err_log_dir[profile->err_dir_count++] = switch_core_sprintf(profile->pool, "%s%sformat_cdr",
SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR);
}
}
}
if (profile->retries && profile->delay == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Retries set but delay 0 setting to 5 seconds\n");
profile->delay = 5;
}
if ( ! profile->format || (strcasecmp(profile->format,"json") && strcasecmp(profile->format,"xml")) )
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No valid format_cdr format specified, defaulting to xml.\n");
profile->format = switch_core_strdup(profile->pool,"xml");
}
profile->retries++;
switch_mutex_lock(globals.mutex);
switch_core_hash_insert(globals.profile_hash, profile->name, profile);
switch_mutex_unlock(globals.mutex);
set_format_cdr_log_dirs(profile);
return SWITCH_STATUS_SUCCESS;
}
static int perl_parse_and_execute(PerlInterpreter * my_perl, char *input_code, char *setup_code)
{
int error = 0;
if (zstr(input_code)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No code to execute!\n");
return -1;
}
if (setup_code) {
error = Perl_safe_eval(my_perl, setup_code);
if (error) {
return error;
}
}
if (*input_code == '~') {
char *buff = input_code + 1;
error = Perl_safe_eval(my_perl, buff);
} else {
char *args = strchr(input_code, ' ');
if (args) {
char *code = NULL;
int x, argc;
char *argv[128] = { 0 };
*args++ = '\0';
if ((argc = switch_separate_string(args, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
switch_stream_handle_t stream = { 0 };
SWITCH_STANDARD_STREAM(stream);
stream.write_function(&stream, " @ARGV = ( ");
for (x = 0; x < argc; x++) {
stream.write_function(&stream, "'%s'%s", argv[x], x == argc - 1 ? "" : ", ");
}
stream.write_function(&stream, " );");
code = stream.data;
} else {
code = switch_mprintf("ARGV = ();");
}
if (code) {
error = Perl_safe_eval(my_perl, code);
switch_safe_free(code);
}
}
if (!error) {
char *file = input_code;
char *err;
if (!switch_is_file_path(file)) {
file = switch_mprintf("require '%s/%s';", SWITCH_GLOBAL_dirs.script_dir, file);
switch_assert(file);
} else {
file = switch_mprintf("require '%s';", file);
switch_assert(file);
}
error = Perl_safe_eval(my_perl, file);
switch_safe_free(file);
}
}
return error;
}
