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

3270 lines
94 KiB
C
Raw Blame History

/*
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
*
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
*
* The Initial Developer of the Original Code is
* Anthony Minessale II <anthm@freeswitch.org>
* Portions created by the Initial Developer are Copyright (C)
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Anthony Minessale II <anthm@freeswitch.org>
* Raymond Chandler <intralanman@freeswitch.org>
* Seven Du <dujinfang@gmail.com>
*
* mod_httapi.c -- HT-TAPI Hypertext Telephony API
*
*/
#include <switch.h>
#include <switch_curl.h>
SWITCH_MODULE_LOAD_FUNCTION(mod_httapi_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_httapi_shutdown);
SWITCH_MODULE_DEFINITION(mod_httapi, mod_httapi_load, mod_httapi_shutdown, NULL);
typedef struct profile_perms_s {
switch_byte_t set_params;
switch_byte_t set_vars;
switch_byte_t get_vars;
switch_byte_t extended_data;
switch_byte_t execute_apps;
switch_byte_t expand_vars;
struct {
switch_byte_t enabled;
switch_byte_t set_context;
switch_byte_t set_dp;
switch_byte_t set_cid_name;
switch_byte_t set_cid_number;
switch_byte_t full_originate;
} dial;
struct {
switch_byte_t enabled;
switch_byte_t set_profile;
} conference;
} profile_perms_t;
struct client_s;
typedef struct action_binding_s {
char *realm;
char *input;
char *action;
char *error_file;
char *match_digits;
char *strip;
struct client_s *client;
struct action_binding_s *parent;
} action_binding_t;
typedef struct client_profile_s {
char *name;
char *method;
char *url;
char *cred;
char *bind_local;
int disable100continue;
uint32_t enable_cacert_check;
char *ssl_cert_file;
char *ssl_key_file;
char *ssl_key_password;
char *ssl_version;
char *ssl_cacert_file;
uint32_t enable_ssl_verifyhost;
char *cookie_file;
switch_hash_t *vars_map;
long auth_scheme;
int timeout;
profile_perms_t perms;
char *ua;
struct {
char *use_profile;
} conference_params;
struct {
char *context;
char *dp;
switch_event_t *app_list;
int default_allow;
} dial_params;
struct {
switch_event_t *expand_var_list;
switch_event_t *set_var_list;
switch_event_t *get_var_list;
switch_event_t *api_list;
int default_allow;
} var_params;
} client_profile_t;
#define HTTAPI_MAX_API_BYTES 1024 * 1024
#define HTTAPI_MAX_FILE_BYTES 1024 * 1024 * 100
typedef struct client_s {
switch_memory_pool_t *pool;
int fd;
switch_buffer_t *buffer;
switch_size_t bytes;
switch_size_t max_bytes;
switch_event_t *headers;
switch_event_t *params;
switch_event_t *one_time_params;
client_profile_t *profile;
switch_core_session_t *session;
switch_channel_t *channel;
action_binding_t *matching_action_binding;
action_binding_t *no_matching_action_binding;
struct {
char *action;
char *name;
char *file;
} record;
int err;
long code;
} client_t;
typedef struct hash_node {
switch_hash_t *hash;
struct hash_node *next;
} hash_node_t;
static struct {
switch_memory_pool_t *pool;
hash_node_t *hash_root;
hash_node_t *hash_tail;
switch_hash_t *profile_hash;
switch_hash_t *request_hash;
switch_mutex_t *request_mutex;
switch_hash_t *parse_hash;
char cache_path[128];
int debug;
int not_found_expires;
int cache_ttl;
int abs_cache_ttl;
client_profile_t *profile;
} globals;
/* for apr_pstrcat */
#define DEFAULT_PREBUFFER_SIZE 1024 * 64
struct http_file_source;
struct http_file_context {
int samples;
switch_file_handle_t fh;
char *cache_file;
char *cache_file_base;
char *meta_file;
char *metadata;
time_t expires;
switch_file_t *lock_fd;
switch_memory_pool_t *pool;
int del_on_close;
char *dest_url;
char *ua;
switch_event_t *url_params;
struct {
char *ext;
} read;
struct {
char *file_name;
char *profile_name;
char *file;
char *method;
char *name;
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
} write;
switch_mutex_t *mutex;
switch_thread_rwlock_t *rwlock;
};
typedef struct http_file_context http_file_context_t;
typedef switch_status_t (*tag_parse_t)(const char *tag_name, client_t *client, switch_xml_t tag, const char *body);
static void bind_parser(const char *tag_name, tag_parse_t handler)
{
switch_core_hash_insert(globals.parse_hash, tag_name, (void *)(intptr_t)handler);
}
#define HTTAPI_SYNTAX "[debug_on|debug_off]"
SWITCH_STANDARD_API(httapi_api_function)
{
if (session) {
return SWITCH_STATUS_FALSE;
}
if (zstr(cmd)) {
goto usage;
}
if (!strcasecmp(cmd, "debug_on")) {
globals.debug = 1;
} else if (!strcasecmp(cmd, "debug_off")) {
globals.debug = 0;
} else {
goto usage;
}
stream->write_function(stream, "OK\n");
return SWITCH_STATUS_SUCCESS;
usage:
stream->write_function(stream, "USAGE: %s\n", HTTAPI_SYNTAX);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t digit_action_callback(switch_ivr_dmachine_match_t *match)
{
action_binding_t *action_binding = (action_binding_t *) match->user_data;
action_binding->client->matching_action_binding = action_binding;
action_binding->match_digits = switch_core_strdup(action_binding->client->pool, match->match_digits);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t digit_nomatch_action_callback(switch_ivr_dmachine_match_t *match)
{
action_binding_t *action_binding = (action_binding_t *) match->user_data;
action_binding->client->no_matching_action_binding = action_binding;
return SWITCH_STATUS_BREAK;
}
static switch_status_t parse_voicemail(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *check = switch_xml_attr(tag, "check");
const char *auth = switch_xml_attr(tag, "auth-only");
const char *profile = switch_xml_attr(tag, "profile");
const char *domain = switch_xml_attr(tag, "domain");
const char *id = switch_xml_attr_soft(tag, "id");
char *ddom = NULL;
char *str;
switch_status_t status;
if (zstr(profile)) profile = "default";
if (zstr(domain)) {
if ((ddom = switch_core_get_domain(SWITCH_TRUE))) {
domain = ddom;
}
}
if (switch_true(check)) {
check = "check";
} else {
check = "";
}
if (switch_true(auth)) {
auth = "auth_only";
check = "check";
} else {
auth = "";
}
str = switch_core_session_sprintf(client->session, "%s %s %s %s %s", check, auth, profile, domain, id);
while(*str == ' ') str++;
status = switch_core_session_execute_application(client->session, "voicemail", str);
switch_safe_free(ddom);
return status;
}
static switch_status_t parse_break(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
return SWITCH_STATUS_FALSE;
}
static void console_log(const char *level_str, const char *msg)
{
switch_log_level_t level = SWITCH_LOG_DEBUG;
if (level_str) {
level = switch_log_str2level(level_str);
if (level == SWITCH_LOG_INVALID) {
level = SWITCH_LOG_DEBUG;
}
}
switch_log_printf(SWITCH_CHANNEL_LOG, level, "%s", switch_str_nil(msg));
}
static void console_clean_log(const char *level_str, const char *msg)
{
switch_log_level_t level = SWITCH_LOG_DEBUG;
if (level_str) {
level = switch_log_str2level(level_str);
if (level == SWITCH_LOG_INVALID) {
level = SWITCH_LOG_DEBUG;
}
}
switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, level, "%s", switch_str_nil(msg));
}
static switch_status_t parse_get_var(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *var = switch_xml_attr(tag, "name");
const char *perm = switch_xml_attr(tag, "permanent");
if (zstr(var)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing name attribute!");
return SWITCH_STATUS_SUCCESS;
}
if (client->profile->perms.get_vars &&
(!client->profile->var_params.get_var_list || switch_event_check_permission_list(client->profile->var_params.get_var_list, var))) {
const char *vval = switch_channel_get_variable(client->channel, var);
if (vval) {
switch_event_add_header_string(switch_true(perm) ? client->params : client->one_time_params, SWITCH_STACK_BOTTOM, var, vval);
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "variable %s permission denied!\n", var);
return SWITCH_STATUS_FALSE;
}
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_continue(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_log(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *level = switch_xml_attr(tag, "level");
const char *clean = switch_xml_attr(tag, "clean");
if (switch_true(clean)) {
console_clean_log(level, body);
} else {
console_log(level, body);
}
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_playback(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *file = switch_xml_attr(tag, "file");
const char *name = switch_xml_attr(tag, "name");
const char *error_file = switch_xml_attr(tag, "error-file");
const char *action = switch_xml_attr(tag, "action");
const char *digit_timeout_ = switch_xml_attr(tag, "digit-timeout");
const char *input_timeout_ = switch_xml_attr(tag, "input-timeout");
const char *terminators = switch_xml_attr(tag, "terminators");
const char *tts_engine = NULL;
const char *tts_voice = NULL;
char *loops_ = (char *) switch_xml_attr(tag, "loops");
int loops = 0;
switch_status_t status = SWITCH_STATUS_FALSE;
switch_ivr_dmachine_t *dmachine = NULL;
switch_input_args_t *args = NULL, myargs = { 0 }, nullargs = { 0 };
long digit_timeout = 1500;
long input_timeout = 5000;
long tmp;
switch_xml_t bind = NULL;
int submit = 0;
int input = 0;
int speak = 0, say = 0, pause = 0, play = 0, speech = 0;
char *sub_action = NULL;
action_binding_t *top_action_binding = NULL;
const char *say_lang = NULL;
const char *say_type = NULL;
const char *say_method = NULL;
const char *say_gender = NULL;
const char *sp_engine = NULL;
const char *sp_grammar = NULL;
const char *text = NULL;
char *free_string = NULL;
if (!strcasecmp(tag_name, "say")) {
say_lang = switch_xml_attr(tag, "language");
say_type = switch_xml_attr(tag, "type");
say_method = switch_xml_attr(tag, "method");
say_gender = switch_xml_attr(tag, "gender");
text = switch_xml_attr(tag, "text");
if (zstr(text)) {
if (!zstr(file)) {
text = file;
} else if (!zstr(body)) {
text = body;
}
}
if (zstr(say_lang) || zstr(say_type) || zstr(say_method) || zstr(text)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "speak: missing required attributes or text! (language) (type) (method) \n");
return SWITCH_STATUS_FALSE;
}
say = 1;
} else if (!strcasecmp(tag_name, "speak")) {
tts_engine = switch_xml_attr(tag, "engine");
tts_voice = switch_xml_attr(tag, "voice");
text = switch_xml_attr(tag, "text");
if (zstr(text)) {
if (!zstr(file)) {
text = file;
} else if (!zstr(body)) {
text = body;
}
}
if (zstr(tts_engine)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "speak: missing engine attribute!\n");
return SWITCH_STATUS_FALSE;
}
speak = 1;
} else if (!strcasecmp(tag_name, "pause")) {
const char *ms_ = switch_xml_attr(tag, "milliseconds");
if (!zstr(ms_)) {
pause = atoi(ms_);
}
if (pause <= 0) pause = 1000;
} else if (!strcasecmp(tag_name, "playback")) {
sp_engine = switch_xml_attr(tag, "asr-engine");
sp_grammar = switch_xml_attr(tag, "asr-grammar");
if (sp_grammar && sp_engine) {
speech = 1;
} else {
play = 1;
}
} else if (!strcasecmp(tag_name, "vmname")) {
const char *id = switch_xml_attr(tag, "id");
char *cmd, *resp;
switch_stream_handle_t stream = { 0 };
char *p;
SWITCH_STANDARD_STREAM(stream);
cmd = switch_mprintf("%s|name_path", id);
switch_api_execute("vm_prefs", cmd, NULL, &stream);
resp = (char *) stream.data;
if (!zstr(resp)) {
if (switch_stristr("://", resp) || switch_file_exists(resp, NULL) == SWITCH_STATUS_SUCCESS) {
play = 1;
file = free_string = resp;
resp = NULL;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid file! [%s]\n", resp);
switch_safe_free(resp);
return SWITCH_STATUS_FALSE;
}
} else {
switch_safe_free(resp);
say_lang = switch_xml_attr(tag, "language");
say_gender = switch_xml_attr(tag, "gender");
say_type = "name_spelled";
say_method = "pronounced";
free_string = strdup(id);
if ((p = strchr(free_string, '@'))) {
*p = '\0';
}
say = 1;
text = free_string;
switch_ivr_play_file(client->session, NULL, "voicemail/vm-person.wav", &nullargs);
}
switch_safe_free(resp);
}
if (zstr(name)) name = "dialed_digits";
if (loops_) {
loops = atoi(loops_);
if (loops < 0) {
loops = -1;
}
}
if (digit_timeout_) {
tmp = atol(digit_timeout_);
if (tmp > 0) {
digit_timeout = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid digit timeout [%s]\n", digit_timeout_);
}
}
if (input_timeout_) {
tmp = atol(input_timeout_);
if (tmp > 0) {
input_timeout = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid input timeout [%s]\n", input_timeout_);
}
}
if ((bind = switch_xml_child(tag, "bind"))) {
action_binding_t *action_binding;
const char *realm = "default";
input++;
top_action_binding = switch_core_session_alloc(client->session, sizeof(*action_binding));
top_action_binding->client = client;
top_action_binding->action = (char *) action;
top_action_binding->error_file = (char *)error_file;
switch_ivr_dmachine_create(&dmachine, "HTTAPI", NULL, digit_timeout, 0,
NULL, digit_nomatch_action_callback, top_action_binding);
while(bind) {
action_binding = switch_core_session_alloc(client->session, sizeof(*action_binding));
action_binding->realm = (char *) realm;
action_binding->input = bind->txt;
action_binding->client = client;
action_binding->action = (char *) switch_xml_attr(bind, "action");
action_binding->strip = (char *) switch_xml_attr(bind, "strip");
action_binding->error_file = (char *) error_file;
action_binding->parent = top_action_binding;
switch_ivr_dmachine_bind(dmachine, action_binding->realm, action_binding->input, 0, 0, digit_action_callback, action_binding);
bind = bind->next;
}
switch_ivr_dmachine_set_realm(dmachine, realm);
if (!zstr(terminators)) {
switch_ivr_dmachine_set_terminators(dmachine, terminators);
}
myargs.dmachine = dmachine;
args = &myargs;
}
if (zstr(file) && !input) {
file = body;
}
if (zstr(file) && !(speak || say || pause)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "missing file attribute!\n");
switch_channel_hangup(client->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
do {
if (speak) {
status = switch_ivr_speak_text(client->session, tts_engine, tts_voice, (char *)text, args);
} else if (say) {
status = switch_ivr_say(client->session, (char *)text, say_lang, say_type, say_method, say_gender, args);
} else if (play) {
status = switch_ivr_play_file(client->session, NULL, file, args);
} else if (speech) {
char *result = NULL;
status = switch_ivr_play_and_detect_speech(client->session, file, sp_engine, sp_grammar, &result, input_timeout, args);
if (!zstr(result)) {
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, name, result);
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "input_type", "detected_speech");
submit = 1;
break;
}
input_timeout = 0;
} else if (pause) {
input_timeout = pause;
status = SWITCH_STATUS_SUCCESS;
}
if (!switch_channel_ready(client->channel)) {
break;
}
if (!input && !pause) {
status = switch_channel_ready(client->channel) ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
submit = 1;
break;
}
if (input_timeout && status == SWITCH_STATUS_SUCCESS) {
if ((status = switch_ivr_sleep(client->session, input_timeout, SWITCH_TRUE, args)) == SWITCH_STATUS_SUCCESS) {
status = (input || !pause) ? SWITCH_STATUS_BREAK : SWITCH_STATUS_SUCCESS;
}
}
if (status == SWITCH_STATUS_BREAK) {
if (error_file) {
switch_ivr_play_file(client->session, NULL, error_file, &nullargs);
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, name, "invalid");
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "input_type", "invalid");
}
status = SWITCH_STATUS_SUCCESS;
} else if (status == SWITCH_STATUS_FOUND) {
status = SWITCH_STATUS_SUCCESS;
submit = 1;
break;
} else if (status != SWITCH_STATUS_SUCCESS) {
break;
}
} while (loops-- > 0);
if (submit) {
if (client->matching_action_binding) {
if (client->matching_action_binding->match_digits) {
if (client->matching_action_binding->strip) {
char *pp, *p;
for(pp = client->matching_action_binding->strip; pp && *pp; pp++) {
if ((p = strchr(client->matching_action_binding->match_digits, *pp))) {
*p = '\0';
}
}
}
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, name, client->matching_action_binding->match_digits);
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "input_type", "dtmf");
}
if (client->matching_action_binding->action) {
sub_action = client->matching_action_binding->action;
} else if (client->matching_action_binding->parent && client->matching_action_binding->parent->action) {
sub_action = client->matching_action_binding->parent->action;
}
}
if (!sub_action && top_action_binding && top_action_binding->action) {
sub_action = top_action_binding->action;
}
if (sub_action && client->matching_action_binding && client->matching_action_binding->match_digits) {
if (!strncasecmp(sub_action, "dial:", 5)) {
char *context = NULL;
char *dp = NULL;
if (client->profile->perms.dial.set_context) {
context = switch_core_session_strdup(client->session, sub_action + 5);
if ((dp = strchr(context, ':'))) {
*dp++ = '\0';
if (!client->profile->perms.dial.set_dp) {
dp = NULL;
}
}
}
switch_ivr_session_transfer(client->session, client->matching_action_binding->match_digits, dp, context);
status = SWITCH_STATUS_FALSE;
} else {
switch_event_add_header_string(client->params, SWITCH_STACK_BOTTOM, "url", sub_action);
}
}
}
if (dmachine) {
switch_ivr_dmachine_destroy(&dmachine);
}
switch_safe_free(free_string);
return status;
}
static switch_status_t parse_conference(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
char *str;
char *dup, *p;
const char *profile_name = switch_xml_attr(tag, "profile");
const char *pin = switch_xml_attr(tag, "pin");
const char *flags = switch_xml_attr(tag, "flags");
if (!client->profile->perms.conference.enabled) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Permission Denied!\n");
switch_channel_hangup(client->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
dup = switch_core_session_strdup(client->session, body);
if ((p = strchr(dup, '@'))) {
*p = '\0';
}
if (zstr(profile_name) || !client->profile->perms.conference.set_profile) {
profile_name = client->profile->conference_params.use_profile;
}
str = switch_core_session_sprintf(client->session, "%s@%s", dup, profile_name);
if (!zstr(pin)) str = switch_core_session_sprintf(client->session, "%s+%s", str, pin);
if (!zstr(flags)) str = switch_core_session_sprintf(client->session, "%s+flags{%s}", str, flags);
switch_core_session_execute_application(client->session, "conference", str);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_dial(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *context = NULL;
const char *dp = NULL;
const char *cid_name = NULL;
const char *cid_number = NULL;
if (!client->profile->perms.dial.enabled) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Permission Denied!\n");
switch_channel_hangup(client->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
if (client->profile->perms.dial.set_context) {
context = switch_xml_attr(tag, "context");
}
if (client->profile->perms.dial.set_dp) {
dp = switch_xml_attr(tag, "dialplan");
}
if (client->profile->perms.dial.set_cid_name) {
cid_name = switch_xml_attr(tag, "caller-id-name");
}
if (client->profile->perms.dial.set_cid_number) {
cid_number = switch_xml_attr(tag, "caller-id-number");
}
if (client->profile->perms.dial.full_originate && strchr(body, '/')) {
char *str;
if (!cid_name) {
cid_name = switch_channel_get_variable(client->channel, "caller_id_name");
}
if (!cid_number) {
cid_number = switch_channel_get_variable(client->channel, "caller_id_number");
}
str = switch_core_session_sprintf(client->session,
"{origination_caller_id_name='%s',origination_caller_id_number='%s'}%s", cid_name, cid_number, body);
switch_core_session_execute_application(client->session, "bridge", str);
} else {
if (!zstr(cid_name)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Changing Caller-ID Name to: %s\n", cid_name);
switch_channel_set_variable(client->channel, "effective_caller_id_name", cid_name);
}
if (!zstr(cid_number)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Changing Caller-ID Number to: %s\n", cid_number);
switch_channel_set_variable(client->channel, "effective_caller_id_number", cid_number);
}
switch_ivr_session_transfer(client->session, body, dp, context);
}
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_sms(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
switch_event_t *event;
const char *from_proto = "httapi";
const char *to_proto = "sip";
const char *to = switch_xml_attr(tag, "to");
if (to && switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", from_proto);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to_proto", to_proto);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from", switch_channel_get_variable(client->channel, "caller_id_number"));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to", to);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "text/plain");
if (body) {
switch_event_add_body(event, "%s", body);
}
switch_core_chat_send(to_proto, event);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing 'to' Attribute!\n");
return SWITCH_STATUS_FALSE;
}
return SWITCH_STATUS_SUCCESS;
}
static int check_app_perm(client_t *client, const char *app_name)
{
if (!client->profile->perms.execute_apps) {
return 0;
}
return switch_event_check_permission_list(client->profile->dial_params.app_list, app_name);
}
static switch_status_t parse_execute(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *app_name = switch_xml_attr(tag, "application");
const char *data = switch_xml_attr(tag, "data");
if (zstr(data)) data = body;
if (zstr(app_name)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid app\n");
switch_channel_hangup(client->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
if (!check_app_perm(client, app_name)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Permission Denied!\n");
switch_channel_hangup(client->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
if (!client->profile->perms.expand_vars) {
const char *p;
for(p = data; p && *p; p++) {
if (*p == '$') {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Expand Variables: Permission Denied!\n");
switch_channel_hangup(client->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
}
}
switch_core_session_execute_application(client->session, app_name, data);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_hangup(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *cause_str = switch_xml_attr(tag, "cause");
switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
if (zstr(cause_str)) {
cause_str = body;
}
if (!zstr(cause_str)) {
cause = switch_channel_str2cause(cause_str);
}
switch_channel_hangup(client->channel, cause);
return SWITCH_STATUS_FALSE;
}
static switch_status_t parse_answer(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
if (!strcasecmp(tag_name, "answer")) {
const char *conf = switch_xml_attr(tag, "is-conference");
if (conf && switch_true(conf)) {
switch_channel_set_flag(client->channel, CF_CONFERENCE);
}
switch_channel_answer(client->channel);
} else if (!strcasecmp(tag_name, "preAnswer")) {
switch_channel_pre_answer(client->channel);
} else if (!strcasecmp(tag_name, "ringReady")) {
switch_channel_ring_ready(client->channel);
}
return SWITCH_STATUS_FALSE;
}
static switch_status_t parse_record_call(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *limit_ = switch_xml_attr(tag, "limit");
const char *name = switch_xml_attr(tag, "name");
const char *action = switch_xml_attr(tag, "action");
const char *record_file;
int limit = 0;
if (client->record.file) {
return SWITCH_STATUS_SUCCESS;
}
if (zstr(name)) name = "recorded_file";
if (!strncasecmp(name, "http://", 7)) {
record_file = name;
} else {
client->record.action = (char *) action;
client->record.name = (char *)name;
client->record.file = switch_core_session_sprintf(client->session, "%s%s%s.wav",
SWITCH_GLOBAL_dirs.temp_dir, SWITCH_PATH_SEPARATOR, switch_core_session_get_uuid(client->session));
record_file = client->record.file;
}
if (limit_) {
limit = atoi(limit_);
if (limit < 0) limit = 0;
}
switch_ivr_record_session(client->session, (char *)record_file, limit, NULL);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_record(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *file = switch_xml_attr(tag, "file");
const char *name = switch_xml_attr(tag, "name");
const char *error_file = switch_xml_attr(tag, "error-file");
const char *beep_file = switch_xml_attr(tag, "beep-file");
const char *action = switch_xml_attr(tag, "action");
const char *sub_action = NULL;
const char *digit_timeout_ = switch_xml_attr(tag, "digit-timeout");
const char *terminators = switch_xml_attr(tag, "terminators");
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_ivr_dmachine_t *dmachine = NULL;
switch_input_args_t *args = NULL, myargs = { 0 };
long digit_timeout = 1500;
long tmp;
int thresh = 200;
int silence_hits = 2;
int record_limit = 0;
char *tmp_record_path = NULL;
const char *v;
int rtmp;
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
char *fname = NULL;
char *p, *ext = "wav";
switch_xml_t bind;
action_binding_t *top_action_binding = NULL;
int http = 0;
switch_uuid_str(uuid_str, sizeof(uuid_str));
if (zstr(name)) name = "attached_file";
if (zstr(file)) {
return SWITCH_STATUS_FALSE;
}
fname = switch_core_strdup(client->pool, file);
for(p = fname; p && *p; p++) {
if (*p == '/' || *p == '\\' || *p == '`') {
*p = '_';
}
}
switch_assert(fname != NULL);
if ((p = strrchr(fname, '.'))) {
*p++ = '\0';
ext = p;
}
for(p = fname; p && *p; p++) {
if (*p == '.') {
*p = '_';
}
}
if (!strncasecmp(fname, "http://", 7)) {
tmp_record_path = fname;
http = 1;
} else {
tmp_record_path = switch_core_sprintf(client->pool, "%s%s%s_%s.%s",
SWITCH_GLOBAL_dirs.temp_dir, SWITCH_PATH_SEPARATOR, uuid_str, fname, ext);
}
if ((v = switch_xml_attr(tag, "limit"))) {
if ((rtmp = atoi(v)) > -1) {
record_limit = rtmp;
}
}
if ((v = switch_xml_attr(tag, "silence-hits"))) {
if ((rtmp = atoi(v)) > -1) {
silence_hits = rtmp;
}
}
if ((v = switch_xml_attr(tag, "threshold"))) {
if ((rtmp = atoi(v)) > -1) {
thresh = rtmp;
}
}
if (digit_timeout_) {
tmp = atol(digit_timeout_);
if (tmp > 0) {
digit_timeout = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid digit timeout [%s]\n", digit_timeout_);
}
}
if ((bind = switch_xml_child(tag, "bind"))) {
action_binding_t *action_binding;
const char *realm = "default";
top_action_binding = switch_core_session_alloc(client->session, sizeof(*action_binding));
top_action_binding->client = client;
top_action_binding->action = (char *) action;
top_action_binding->error_file = (char *)error_file;
switch_ivr_dmachine_create(&dmachine, "HTTAPI", NULL, digit_timeout, 0,
NULL, digit_nomatch_action_callback, top_action_binding);
while(bind) {
action_binding = switch_core_session_alloc(client->session, sizeof(*action_binding));
action_binding->realm = (char *) realm;
action_binding->input = bind->txt;
action_binding->client = client;
action_binding->action = (char *) switch_xml_attr(bind, "action");
action_binding->error_file = (char *) error_file;
action_binding->parent = top_action_binding;
switch_ivr_dmachine_bind(dmachine, action_binding->realm, action_binding->input, 0, 0, digit_action_callback, action_binding);
bind = bind->next;
}
switch_ivr_dmachine_set_realm(dmachine, realm);
if (!zstr(terminators)) {
switch_ivr_dmachine_set_terminators(dmachine, terminators);
}
myargs.dmachine = dmachine;
args = &myargs;
}
if (beep_file) {
status = switch_ivr_play_file(client->session, NULL, beep_file, args);
}
if (!switch_channel_ready(client->channel)) {
goto end;
}
if (status == SWITCH_STATUS_SUCCESS) {
switch_file_handle_t fh = { 0 };
fh.thresh = thresh;
fh.silence_hits = silence_hits;
status = switch_ivr_record_file(client->session, &fh, tmp_record_path, args, record_limit);
}
if (switch_channel_ready(client->channel)) {
status = SWITCH_STATUS_SUCCESS;
}
if (client->matching_action_binding) {
if (client->matching_action_binding->action) {
sub_action = client->matching_action_binding->action;
} else if (client->matching_action_binding->parent && client->matching_action_binding->parent->action) {
sub_action = client->matching_action_binding->parent->action;
}
}
if (!sub_action && top_action_binding && top_action_binding->action) {
sub_action = top_action_binding->action;
}
if (sub_action) {
switch_event_add_header_string(client->params, SWITCH_STACK_BOTTOM, "url", sub_action);
}
if (!http && !zstr(tmp_record_path) && switch_file_exists(tmp_record_path, client->pool) == SWITCH_STATUS_SUCCESS) {
char *key = switch_core_sprintf(client->pool, "attach_file:%s:%s.%s", name, fname, ext);
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, key, tmp_record_path);
}
end:
if (dmachine) {
switch_ivr_dmachine_destroy(&dmachine);
}
return status;
}
static switch_status_t parse_common(const char *tag_name, client_t *client, switch_xml_t tag, const char *body)
{
const char *action = switch_xml_attr(tag, "action");
const char *tmp_action = switch_xml_attr(tag, "temp-action");
if (action) {
switch_event_add_header_string(client->params, SWITCH_STACK_BOTTOM, "url", action);
}
if (tmp_action) {
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "url", tmp_action);
}
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t parse_xml(client_t *client)
{
switch_status_t status = SWITCH_STATUS_FALSE;
const void *bdata;
switch_size_t len;
int runs = 0;
if ((len = switch_buffer_peek_zerocopy(client->buffer, &bdata)) && switch_buffer_len(client->buffer) > len) {
switch_xml_t xml, tag, category;
if (globals.debug) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Debugging Return Data:\n%s\n", (char *)bdata);
}
if ((xml = switch_xml_parse_str((char *)bdata, len))) {
if (client->profile->perms.set_params) {
if ((category = switch_xml_child(xml, "params"))) {
tag = category->child;
while(tag) {
if (!zstr(tag->name)) {
char *val = tag->txt;
if (zstr(val)) {
val = NULL;
}
switch_event_add_header_string(client->params, SWITCH_STACK_BOTTOM, tag->name, val);
}
tag = tag->ordered;
}
}
}
if (client->profile->perms.set_vars) {
if ((category = switch_xml_child(xml, "variables"))) {
tag = category->child;
while(tag) {
if (!zstr(tag->name)) {
char *val = tag->txt;
if (zstr(val)) {
val = NULL;
}
if (client->profile->perms.set_vars &&
(!client->profile->var_params.set_var_list ||
switch_event_check_permission_list(client->profile->var_params.set_var_list, tag->name))) {
switch_channel_set_variable(client->channel, tag->name, val);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "variable %s permission denied!\n", tag->name);
}
}
tag = tag->ordered;
}
}
}
if ((category = switch_xml_child(xml, "work"))) {
tag = category->child;
status = SWITCH_STATUS_SUCCESS;
while(status == SWITCH_STATUS_SUCCESS && tag) {
if (!zstr(tag->name)) {
tag_parse_t handler;
if ((handler = (tag_parse_t)(intptr_t) switch_core_hash_find(globals.parse_hash, tag->name))) {
char *expanded = tag->txt;
switch_event_t *templ_data;
if (tag->txt && client->profile->perms.expand_vars) {
switch_channel_get_variables(client->channel, &templ_data);
switch_event_merge(templ_data, client->params);
expanded = switch_event_expand_headers_check(templ_data, tag->txt,
client->profile->var_params.expand_var_list,
client->profile->var_params.api_list, 0);
switch_event_destroy(&templ_data);
}
runs++;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Process Tag: [%s]\n", tag->name);
parse_common(tag->name, client, tag, expanded);
status = handler(tag->name, client, tag, expanded);
if (expanded && expanded != tag->txt) {
free(expanded);
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unsupported Tag: [%s]\n", tag->name);
status = SWITCH_STATUS_FALSE;
}
}
tag = tag->ordered;
}
}
if (!runs) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "No instructions found in result!\n");
status = SWITCH_STATUS_FALSE;
}
switch_xml_free(xml);
}
}
return status;
}
static size_t get_header_callback(void *ptr, size_t size, size_t nmemb, void *userdata)
{
size_t realsize = (size * nmemb);
char *val, *header = NULL;
client_t *client = userdata;
/* validate length... Apache and IIS won't send a header larger than 16 KB */
if (realsize == 0 || realsize > 1024 * 16) {
return realsize;
}
/* get the header, adding NULL terminator if there isn't one */
switch_zmalloc(header, realsize + 1);
strncpy(header, (char *)ptr, realsize);
if ((val = strchr(header, ':'))) {
char *cr;
*val++ = '\0';
while(*val == ' ') val++;
if ((cr = strchr(val, '\r')) || (cr = strchr(val, '\r'))) {
*cr = '\0';
}
switch_event_add_header_string(client->headers, SWITCH_STACK_BOTTOM, header, val);
}
switch_safe_free(header);
return realsize;
}
static size_t file_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
register unsigned int realsize = (unsigned int) (size * nmemb);
client_t *client = data;
client->bytes += realsize;
if (client->bytes > client->max_bytes - 1) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Oversized file detected [%d bytes]\n", (int) client->bytes);
client->err = 1;
return 0;
}
switch_buffer_write(client->buffer, ptr, realsize);
return realsize;
}
static void client_destroy(client_t **client)
{
if (client && *client) {
switch_memory_pool_t *pool;
switch_event_destroy(&(*client)->headers);
switch_event_destroy(&(*client)->params);
switch_event_destroy(&(*client)->one_time_params);
switch_buffer_destroy(&(*client)->buffer);
pool = (*client)->pool;
switch_core_destroy_memory_pool(&pool);
}
}
static void client_reset(client_t *client)
{
if (client->headers) {
switch_event_destroy(&client->headers);
}
switch_event_destroy(&client->one_time_params);
switch_event_create(&client->one_time_params, SWITCH_EVENT_CLONE);
client->one_time_params->flags |= EF_UNIQ_HEADERS;
switch_event_create(&client->headers, SWITCH_EVENT_CLONE);
switch_buffer_zero(client->buffer);
client->code = 0;
client->err = 0;
client->matching_action_binding = NULL;
client->no_matching_action_binding = NULL;
}
static client_t *client_create(switch_core_session_t *session, const char *profile_name, switch_event_t **params)
{
client_t *client;
switch_memory_pool_t *pool;
client_profile_t *profile;
if (zstr(profile_name)) {
profile_name = "default";
}
profile = (client_profile_t *) switch_core_hash_find(globals.profile_hash, profile_name);
if (!profile) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find profile [%s]\n", profile_name);
return NULL;
}
switch_core_new_memory_pool(&pool);
client = switch_core_alloc(pool, sizeof(*client));
client->pool = pool;
switch_event_create(&client->headers, SWITCH_EVENT_CLONE);
if (session) {
client->session = session;
client->channel = switch_core_session_get_channel(session);
}
client->profile = profile;
client->max_bytes = HTTAPI_MAX_API_BYTES;
switch_buffer_create_dynamic(&client->buffer, 1024, 1024, 0);
if (params && *params) {
client->params = *params;
*params = NULL;
} else {
switch_event_create(&client->params, SWITCH_EVENT_CLONE);
client->params->flags |= EF_UNIQ_HEADERS;
}
switch_event_create(&client->one_time_params, SWITCH_EVENT_CLONE);
client->one_time_params->flags |= EF_UNIQ_HEADERS;
switch_event_add_header_string(client->params, SWITCH_STACK_BOTTOM, "hostname", switch_core_get_switchname());
return client;
}
static void cleanup_attachments(client_t *client)
{
switch_event_header_t *hp;
for (hp = client->params->headers; hp; hp = hp->next) {
if (!strncasecmp(hp->name, "attach_file:", 12)) {
if (switch_file_exists(hp->value, client->pool) == SWITCH_STATUS_SUCCESS) {
unlink(hp->value);
}
}
}
}
size_t put_file_read( void *ptr, size_t size, size_t nmemb, void *userdata)
{
return fread(ptr, size, nmemb, (FILE *) userdata);
}
static switch_status_t httapi_sync(client_t *client)
{
switch_CURL *curl_handle = NULL;
char *data = NULL;
switch_curl_slist_t *headers = NULL;
char *url = NULL;
char *dynamic_url = NULL, *use_url = NULL;
const char *session_id = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
int get_style_method = 0;
char *method = NULL;
struct curl_httppost *formpost=NULL;
switch_event_t *save_params = NULL;
const char *put_file;
FILE *fd = NULL;
char *creds, *dup_creds = NULL, *ua = NULL;
if (client->one_time_params && client->one_time_params->headers) {
save_params = client->params;
switch_event_dup(&client->params, save_params);
switch_event_merge(client->params, client->one_time_params);
switch_event_destroy(&client->one_time_params);
switch_event_create(&client->one_time_params, SWITCH_EVENT_CLONE);
client->one_time_params->flags |= EF_UNIQ_HEADERS;
}
ua = switch_event_get_header(client->params, "user_agent");
if (zstr(ua)) {
ua = client->profile->ua;
}
if (!(session_id = switch_event_get_header(client->params, "HTTAPI_SESSION_ID"))) {
if (client->channel && !(session_id = switch_channel_get_variable(client->channel, "HTTAPI_SESSION_ID"))) {
session_id = switch_core_session_get_uuid(client->session);
}
}
if (client->code || client->err) {
client_reset(client);
}
if (!(method = switch_event_get_header(client->params, "method"))) {
method = client->profile->method;
}
if (!(url = switch_event_get_header(client->params, "url"))) {
url = client->profile->url;
switch_event_add_header_string(client->params, SWITCH_STACK_BOTTOM, "url", url);
}
get_style_method = method ? strcasecmp(method, "post") : 1;
switch_event_add_header_string(client->params, SWITCH_STACK_TOP, "session_id", session_id);
dynamic_url = switch_event_expand_headers(client->params, url);
if ((put_file = switch_event_get_header(client->params, "put_file"))) {
if (!(fd = fopen(put_file, "rb"))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Can't open [%s]\n", put_file);
put_file = NULL;
}
}
if (!put_file) {
switch_curl_process_form_post_params(client->params, curl_handle, &formpost);
}
if (formpost) {
get_style_method = 1;
} else {
data = switch_event_build_param_string(client->params, NULL, client->profile->vars_map);
switch_assert(data);
if (get_style_method) {
char *tmp = switch_mprintf("%s%c%s", dynamic_url, strchr(dynamic_url, '?') != NULL ? '&' : '?', data);
if (dynamic_url != url) {
free(dynamic_url);
}
dynamic_url = tmp;
}
}
if ((use_url = strchr(dynamic_url, '@'))) {
char *r, *q, *p = strstr(dynamic_url, "://");
use_url++;
if (p) {
dup_creds = strdup(p+3);
if ((q = strchr(dup_creds, '@'))) *q = '\0';
q = strdup(url);
if (q) {
r = strchr(q, '@');
if (r) {
r++;
if ((p = strstr(q, "://"))) {
*(p+3) = '\0';
}
p = switch_mprintf("%s%s", q, r);
if (p) {
free(dynamic_url);
dynamic_url = p;
}
}
free(q);
}
}
}
if ((use_url = strchr(dynamic_url, '@'))) {
char *q, *p = strstr(dynamic_url, "://");
use_url++;
dup_creds = strdup(p+3);
*p = '\0';
if ((q = strchr(dup_creds, '@'))) *q = '\0';
creds = dup_creds;
p = switch_mprintf("%s%s", p, use_url);
free(dynamic_url);
dynamic_url = p;
} else {
creds = client->profile->cred;
}
curl_handle = switch_curl_easy_init();
if (session_id) {
char *hval = switch_mprintf("HTTAPI_SESSION_ID=%s", session_id);
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIE, hval);
free(hval);
}
if (!strncasecmp(dynamic_url, "https", 5)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, 0);
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 0);
}
if (!zstr(creds)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_HTTPAUTH, client->profile->auth_scheme);
switch_curl_easy_setopt(curl_handle, CURLOPT_USERPWD, creds);
}
if (client->profile->disable100continue) {
headers = switch_curl_slist_append(headers, "Expect:");
}
if (client->profile->enable_cacert_check) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, TRUE);
}
switch_curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, headers);
if (!zstr(method)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_CUSTOMREQUEST, method);
}
if (put_file) {
curl_easy_setopt(curl_handle, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl_handle, CURLOPT_READDATA, fd);
curl_easy_setopt(curl_handle, CURLOPT_READFUNCTION, put_file_read);
} else if (formpost) {
curl_easy_setopt(curl_handle, CURLOPT_HTTPPOST, formpost);
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_POST, !get_style_method);
}
switch_curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1);
switch_curl_easy_setopt(curl_handle, CURLOPT_MAXREDIRS, 10);
if (!get_style_method && !formpost) {
switch_curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDS, data);
}
switch_curl_easy_setopt(curl_handle, CURLOPT_URL, dynamic_url);
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, file_callback);
switch_curl_easy_setopt(curl_handle, CURLOPT_HEADERFUNCTION, get_header_callback);
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) client);
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEHEADER, (void *) client);
switch_curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, ua);
switch_curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1);
if (client->profile->timeout) {
switch_curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, client->profile->timeout);
}
if (client->profile->ssl_cert_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLCERT, client->profile->ssl_cert_file);
}
if (client->profile->ssl_key_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLKEY, client->profile->ssl_key_file);
}
if (client->profile->ssl_key_password) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLKEYPASSWD, client->profile->ssl_key_password);
}
if (client->profile->ssl_version) {
if (!strcasecmp(client->profile->ssl_version, "SSLv3")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv3);
#ifdef CURL_SSLVERSION_TLSv1_1
} else if (!strcasecmp(client->profile->ssl_version, "TLSv1.1")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_1);
#endif
#ifdef CURL_SSLVERSION_TLSv1_2
} else if (!strcasecmp(client->profile->ssl_version, "TLSv1.2")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
#endif
}
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
}
if (client->profile->ssl_cacert_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_CAINFO, client->profile->ssl_cacert_file);
}
if (client->profile->enable_ssl_verifyhost) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 2);
}
if (client->profile->cookie_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIEJAR, client->profile->cookie_file);
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIEFILE, client->profile->cookie_file);
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIE, "");
}
if (client->profile->bind_local) {
curl_easy_setopt(curl_handle, CURLOPT_INTERFACE, client->profile->bind_local);
}
switch_curl_easy_perform(curl_handle);
switch_curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &client->code);
switch_curl_easy_cleanup(curl_handle);
switch_curl_slist_free_all(headers);
if (formpost) {
curl_formfree(formpost);
}
if (client->err) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error encountered! [%s]\ndata: [%s]\n", client->profile->url, data);
status = SWITCH_STATUS_FALSE;
} else {
status = SWITCH_STATUS_SUCCESS;
}
switch_safe_free(data);
switch_safe_free(dup_creds);
if (dynamic_url != url) {
switch_safe_free(dynamic_url);
}
cleanup_attachments(client);
if (save_params) {
switch_event_destroy(&client->params);
client->params = save_params;
save_params = NULL;
}
if (fd) {
fclose(fd);
}
return status;
}
#define ENABLE_PARAM_VALUE "enabled"
static switch_status_t do_config(void)
{
char *cf = "httapi.conf";
switch_xml_t cfg, xml, profiles_tag, profile_tag, param, settings, tag;
client_profile_t *profile = NULL;
int x = 0;
int need_vars_map = 0;
switch_hash_t *vars_map = 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 = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "debug")) {
globals.debug = switch_true(val);
} else if (!strcasecmp(var, "file-cache-ttl")) {
int tmp = atoi(val);
if (tmp > -1) {
globals.cache_ttl = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s]for file-cache-ttl\n", val);
}
} else if (!strcasecmp(var, "abs-file-cache-ttl")) {
int tmp = atoi(val);
if (tmp > -1) {
globals.abs_cache_ttl = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s]for file-cache-ttl\n", val);
}
} else if (!strcasecmp(var, "file-not-found-expires")) {
globals.not_found_expires = atoi(val);
if (globals.not_found_expires < 0) {
globals.not_found_expires = -1;
}
}
}
}
if (!(profiles_tag = switch_xml_child(cfg, "profiles"))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing <profiles> tag!\n");
goto done;
}
for (profile_tag = switch_xml_child(profiles_tag, "profile"); profile_tag; profile_tag = profile_tag->next) {
char *bname = (char *) switch_xml_attr_soft(profile_tag, "name");
char *url = NULL;
char *bind_local = NULL;
char *bind_cred = NULL;
char *method = NULL;
int disable100continue = 1;
int timeout = 0;
uint32_t enable_cacert_check = 0;
char *ssl_cert_file = NULL;
char *ssl_key_file = NULL;
char *ssl_key_password = NULL;
char *ssl_version = NULL;
char *ssl_cacert_file = NULL;
uint32_t enable_ssl_verifyhost = 0;
char *cookie_file = NULL;
char *ua = "mod_httapi/1.0";
hash_node_t *hash_node;
long auth_scheme = CURLAUTH_BASIC;
need_vars_map = 0;
vars_map = NULL;
if (zstr(bname)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "profile tag missing name field!\n");
continue;
}
if (switch_core_hash_find(globals.profile_hash, bname)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Profile %s already exists\n", (char *)bname);
continue;
}
if ((tag = switch_xml_child(profile_tag, "params"))) {
for (param = switch_xml_child(tag, "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, "gateway-url")) {
if (val) {
url = val;
}
} else if (!strcasecmp(var, "user-agent")) {
ua = val;
} else if (!strcasecmp(var, "gateway-credentials")) {
bind_cred = val;
} else if (!strcasecmp(var, "auth-scheme")) {
if (*val == '=') {
auth_scheme = 0;
val++;
}
if (!strcasecmp(val, "basic")) {
auth_scheme |= CURLAUTH_BASIC;
} else if (!strcasecmp(val, "digest")) {
auth_scheme |= CURLAUTH_DIGEST;
} else if (!strcasecmp(val, "NTLM")) {
auth_scheme |= CURLAUTH_NTLM;
} else if (!strcasecmp(val, "GSS-NEGOTIATE")) {
auth_scheme |= CURLAUTH_GSSNEGOTIATE;
} else if (!strcasecmp(val, "any")) {
auth_scheme = (long)CURLAUTH_ANY;
}
} else if (!strcasecmp(var, "disable-100-continue") && !switch_true(val)) {
disable100continue = 0;
} else if (!strcasecmp(var, "method")) {
method = val;
} else if (!strcasecmp(var, "timeout")) {
int tmp = atoi(val);
if (tmp >= 0) {
timeout = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't set a negative timeout!\n");
}
} else if (!strcasecmp(var, "enable-cacert-check") && switch_true(val)) {
enable_cacert_check = 1;
} else if (!strcasecmp(var, "ssl-cert-path")) {
ssl_cert_file = val;
} else if (!strcasecmp(var, "ssl-key-path")) {
ssl_key_file = val;
} else if (!strcasecmp(var, "ssl-key-password")) {
ssl_key_password = val;
} else if (!strcasecmp(var, "ssl-version")) {
ssl_version = val;
} else if (!strcasecmp(var, "ssl-cacert-file")) {
ssl_cacert_file = val;
} else if (!strcasecmp(var, "enable-ssl-verifyhost") && switch_true(val)) {
enable_ssl_verifyhost = 1;
} else if (!strcasecmp(var, "cookie-file")) {
cookie_file = val;
} else if (!strcasecmp(var, "enable-post-var")) {
if (!vars_map && need_vars_map == 0) {
if (switch_core_hash_init(&vars_map) != SWITCH_STATUS_SUCCESS) {
need_vars_map = -1;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Can't init params hash!\n");
continue;
}
need_vars_map = 1;
}
if (vars_map && val) {
if (switch_core_hash_insert(vars_map, val, ENABLE_PARAM_VALUE) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Can't add %s to params hash!\n", val);
}
}
} else if (!strcasecmp(var, "bind-local")) {
bind_local = val;
}
}
}
if (!url) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Profile has no url!\n");
if (vars_map)
switch_core_hash_destroy(&vars_map);
continue;
}
if (!(profile = switch_core_alloc(globals.pool, sizeof(*profile)))) {
if (vars_map)
switch_core_hash_destroy(&vars_map);
goto done;
}
memset(profile, 0, sizeof(*profile));
/* Defaults */
profile->ua = ua;
profile->conference_params.use_profile = "default";
profile->perms.set_params = 1;
profile->perms.conference.enabled = 1;
profile->perms.dial.enabled = 1;
if ((tag = switch_xml_child(profile_tag, "conference"))) {
for (param = switch_xml_child(tag, "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, "default-profile")) {
profile->conference_params.use_profile = switch_core_strdup(globals.pool, val);
}
}
}
if ((tag = switch_xml_child(profile_tag, "dial"))) {
for (param = switch_xml_child(tag, "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, "context")) {
profile->dial_params.context = switch_core_strdup(globals.pool, val);
} else if (!strcasecmp(var, "dialplan")) {
profile->dial_params.dp = switch_core_strdup(globals.pool, val);
}
}
}
if ((tag = switch_xml_child(profile_tag, "permissions"))) {
for (param = switch_xml_child(tag, "permission"); 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, "all")) {
switch_byte_t all = switch_true_byte(val);
memset(&profile->perms, all, sizeof(profile->perms));
} else if (!strcasecmp(var, "none")) {
switch_byte_t none = switch_true_byte(val);
memset(&profile->perms, none, sizeof(profile->perms));
} else if (!strcasecmp(var, "set-params")) {
profile->perms.set_params = switch_true_byte(val);
} else if (!strcasecmp(var, "set-vars")) {
profile->perms.set_vars = switch_true_byte(val);
if (profile->perms.set_vars) {
switch_xml_t x_list, x_var;
if ((x_list = switch_xml_child(param, "variable-list"))) {
char *var = (char *) switch_xml_attr_soft(param, "default");
profile->var_params.default_allow = (var && !strcasecmp(var, "allow"));
switch_event_create(&profile->var_params.set_var_list, SWITCH_EVENT_CLONE);
profile->var_params.set_var_list->flags |= EF_UNIQ_HEADERS;
if (profile->var_params.default_allow) {
profile->var_params.set_var_list->flags |= EF_DEFAULT_ALLOW;
}
for (x_var = switch_xml_child(x_list, "variable"); x_var; x_var = x_var->next) {
const char *name = switch_xml_attr(x_var, "name");
const char *type = switch_xml_attr(x_var, "type");
if (zstr(type)) type = profile->var_params.default_allow ? "deny" : "allow";
if (name) {
switch_event_add_header_string(profile->var_params.set_var_list, SWITCH_STACK_BOTTOM, name, type);
}
}
}
}
} else if (!strcasecmp(var, "get-vars")) {
profile->perms.get_vars = switch_true_byte(val);
if (profile->perms.get_vars) {
switch_xml_t x_list, x_var;
if ((x_list = switch_xml_child(param, "variable-list"))) {
char *var = (char *) switch_xml_attr_soft(param, "default");
profile->var_params.default_allow = (var && !strcasecmp(var, "allow"));
switch_event_create(&profile->var_params.get_var_list, SWITCH_EVENT_CLONE);
profile->var_params.get_var_list->flags |= EF_UNIQ_HEADERS;
if (profile->var_params.default_allow) {
profile->var_params.get_var_list->flags |= EF_DEFAULT_ALLOW;
}
for (x_var = switch_xml_child(x_list, "variable"); x_var; x_var = x_var->next) {
const char *name = switch_xml_attr(x_var, "name");
const char *type = switch_xml_attr(x_var, "type");
if (zstr(type)) type = profile->var_params.default_allow ? "deny" : "allow";
if (name) {
switch_event_add_header_string(profile->var_params.get_var_list, SWITCH_STACK_BOTTOM, name, type);
}
}
}
}
} else if (!strcasecmp(var, "extended-data")) {
profile->perms.extended_data = switch_true_byte(val);
} else if (!strcasecmp(var, "execute-apps")) {
profile->perms.execute_apps = switch_true_byte(val);
if (profile->perms.execute_apps) {
switch_xml_t x_list, x_app;
if ((x_list = switch_xml_child(param, "application-list"))) {
char *var = (char *) switch_xml_attr_soft(param, "default");
profile->dial_params.default_allow = (var && !strcasecmp(var, "allow"));
switch_event_create(&profile->dial_params.app_list, SWITCH_EVENT_CLONE);
profile->dial_params.app_list->flags |= EF_UNIQ_HEADERS;
if (profile->dial_params.default_allow) {
profile->dial_params.app_list->flags |= EF_DEFAULT_ALLOW;
}
for (x_app = switch_xml_child(x_list, "application"); x_app; x_app = x_app->next) {
const char *name = switch_xml_attr(x_app, "name");
const char *type = switch_xml_attr(x_app, "type");
if (zstr(type)) type = profile->dial_params.default_allow ? "deny" : "allow";
if (name) {
switch_event_add_header_string(profile->dial_params.app_list, SWITCH_STACK_BOTTOM, name, type);
}
}
}
}
} else if (!strcasecmp(var, "expand-vars")) {
profile->perms.expand_vars = switch_true_byte(val);
if (profile->perms.expand_vars) {
switch_xml_t x_list, x_var, x_api;
if ((x_list = switch_xml_child(param, "variable-list"))) {
char *var = (char *) switch_xml_attr_soft(param, "default");
profile->var_params.default_allow = (var && !strcasecmp(var, "allow"));
switch_event_create(&profile->var_params.expand_var_list, SWITCH_EVENT_CLONE);
profile->var_params.expand_var_list->flags |= EF_UNIQ_HEADERS;
if (profile->var_params.default_allow) {
profile->var_params.expand_var_list->flags |= EF_DEFAULT_ALLOW;
}
for (x_var = switch_xml_child(x_list, "variable"); x_var; x_var = x_var->next) {
const char *name = switch_xml_attr(x_var, "name");
const char *type = switch_xml_attr(x_var, "type");
if (zstr(type)) type = profile->var_params.default_allow ? "deny" : "allow";
if (name) {
switch_event_add_header_string(profile->var_params.expand_var_list, SWITCH_STACK_BOTTOM, name, type);
}
}
}
if ((x_list = switch_xml_child(param, "api-list"))) {
char *api = (char *) switch_xml_attr_soft(param, "default");
profile->var_params.default_allow = (api && !strcasecmp(api, "allow"));
switch_event_create(&profile->var_params.api_list, SWITCH_EVENT_CLONE);
profile->var_params.api_list->flags |= EF_UNIQ_HEADERS;
if (profile->var_params.default_allow) {
profile->var_params.api_list->flags |= EF_DEFAULT_ALLOW;
}
for (x_api = switch_xml_child(x_list, "api"); x_api; x_api = x_api->next) {
const char *name = switch_xml_attr(x_api, "name");
const char *type = switch_xml_attr(x_api, "type");
if (zstr(type)) type = profile->var_params.default_allow ? "deny" : "allow";
if (name) {
switch_event_add_header_string(profile->var_params.api_list, SWITCH_STACK_BOTTOM, name, type);
}
}
}
}
} else if (!strcasecmp(var, "dial")) {
profile->perms.dial.enabled = switch_true_byte(val);
} else if (!strcasecmp(var, "dial-set-context")) {
if (switch_true(val)) profile->perms.dial.enabled = SWITCH_TRUE;
profile->perms.dial.set_context = switch_true_byte(val);
} else if (!strcasecmp(var, "dial-set-dialplan")) {
if (switch_true(val)) profile->perms.dial.enabled = SWITCH_TRUE;
profile->perms.dial.set_dp = switch_true_byte(val);
} else if (!strcasecmp(var, "dial-set-cid-name")) {
if (switch_true(val)) profile->perms.dial.enabled = SWITCH_TRUE;
profile->perms.dial.set_cid_name = switch_true_byte(val);
} else if (!strcasecmp(var, "dial-set-cid-number")) {
if (switch_true(val)) profile->perms.dial.enabled = SWITCH_TRUE;
profile->perms.dial.set_cid_number = switch_true_byte(val);
} else if (!strcasecmp(var, "dial-full-originate")) {
if (switch_true(val)) profile->perms.dial.enabled = SWITCH_TRUE;
profile->perms.dial.full_originate = switch_true_byte(val);
} else if (!strcasecmp(var, "conference")) {
profile->perms.conference.enabled = switch_true_byte(val);
} else if (!strcasecmp(var, "conference-set-profile")) {
if (switch_true(val)) profile->perms.conference.enabled = SWITCH_TRUE;
profile->perms.conference.set_profile = switch_true_byte(val);
}
}
}
profile->auth_scheme = auth_scheme;
profile->timeout = timeout;
profile->url = switch_core_strdup(globals.pool, url);
switch_assert(profile->url);
if (bind_local != NULL) {
profile->bind_local = switch_core_strdup(globals.pool, bind_local);
}
if (method != NULL) {
profile->method = switch_core_strdup(globals.pool, method);
} else {
profile->method = NULL;
}
if (bind_cred) {
profile->cred = switch_core_strdup(globals.pool, bind_cred);
}
profile->disable100continue = disable100continue;
profile->enable_cacert_check = enable_cacert_check;
if (ssl_cert_file) {
profile->ssl_cert_file = switch_core_strdup(globals.pool, ssl_cert_file);
}
if (ssl_key_file) {
profile->ssl_key_file = switch_core_strdup(globals.pool, ssl_key_file);
}
if (ssl_key_password) {
profile->ssl_key_password = switch_core_strdup(globals.pool, ssl_key_password);
}
if (ssl_version) {
profile->ssl_version = switch_core_strdup(globals.pool, ssl_version);
}
if (ssl_cacert_file) {
profile->ssl_cacert_file = switch_core_strdup(globals.pool, ssl_cacert_file);
}
profile->enable_ssl_verifyhost = enable_ssl_verifyhost;
if (cookie_file) {
profile->cookie_file = switch_core_strdup(globals.pool, cookie_file);
}
profile->vars_map = vars_map;
if (vars_map) {
switch_zmalloc(hash_node, sizeof(hash_node_t));
hash_node->hash = vars_map;
hash_node->next = NULL;
if (!globals.hash_root) {
globals.hash_root = hash_node;
globals.hash_tail = globals.hash_root;
}
else {
globals.hash_tail->next = hash_node;
globals.hash_tail = globals.hash_tail->next;
}
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Profile [%s] JSON Function [%s]\n",
zstr(bname) ? "N/A" : bname, profile->url);
profile->name = switch_core_strdup(globals.pool, bname);
if (!globals.profile) globals.profile = profile;
switch_core_hash_insert(globals.profile_hash, bname, profile);
x++;
profile = NULL;
}
done:
switch_xml_free(xml);
return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}
static switch_status_t my_on_reporting(switch_core_session_t *session)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS;
client_t *client;
const char *var;
if (!(client = (client_t *) switch_channel_get_private(channel, "_HTTAPI_CLIENT_"))) {
return status;
}
switch_channel_set_private(channel, "_HTTAPI_CLIENT_", NULL);
if (client->profile->perms.extended_data) {
switch_channel_event_set_extended_data(channel, client->one_time_params);
}
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "exiting", "true");
if (client->record.file) {
char *key = switch_core_sprintf(client->pool, "attach_file:%s:%s.wav", client->record.name, switch_core_session_get_uuid(session));
switch_ivr_stop_record_session(client->session, client->record.file);
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, key, client->record.file);
}
var = switch_event_get_header(client->params, "url");
if (var && client->record.action) {
if (strcmp(var, client->record.action)) {
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "url", client->record.action);
httapi_sync(client);
if (client->profile->perms.extended_data) {
switch_channel_event_set_extended_data(channel, client->one_time_params);
}
switch_event_add_header_string(client->one_time_params, SWITCH_STACK_BOTTOM, "exiting", "true");
}
}
httapi_sync(client);
client_destroy(&client);
return status;
}
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,
/*.on_destroy */ NULL,
SSH_FLAG_STICKY
};
SWITCH_STANDARD_APP(httapi_function)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
char *parsed = NULL;
const char *profile_name = NULL, *url = NULL;
client_t *client;
switch_event_t *params = NULL;
uint32_t loops = 0, all_extended = 0;
switch_caller_profile_t *caller_profile;
if (!zstr(data)) {
switch_event_create_brackets((char *)data, '{', '}', ',', &params, &parsed, SWITCH_TRUE);
if (params) {
url = parsed;
} else {
url = data;
}
if (!zstr(url) && switch_stristr("://", url)) {
if (!params) {
switch_event_create(&params, SWITCH_EVENT_CLONE);
params->flags |= EF_UNIQ_HEADERS;
}
switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "url", url);
}
}
if ((client = (client_t *) switch_channel_get_private(channel, "_HTTAPI_CLIENT_"))) {
client_reset(client);
if (params) {
switch_event_merge(client->params, params);
switch_event_destroy(&params);
}
} else {
if (params) {
profile_name = switch_event_get_header(params, "httapi_profile");
}
if (zstr(profile_name) && !(profile_name = switch_channel_get_variable(channel, "httapi_profile"))) {
profile_name = "default";
}
if ((client = client_create(session, profile_name, &params))) {
switch_channel_set_private(channel, "_HTTAPI_CLIENT_", client);
switch_channel_add_state_handler(channel, &state_handlers);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find suitable profile\n");
switch_event_destroy(&params);
return;
}
}
if (client->profile->perms.extended_data) {
all_extended = switch_true(switch_event_get_header(client->params, "full_channel_data_on_every_req"));
}
if ((caller_profile = switch_channel_get_caller_profile(channel))) {
switch_caller_profile_event_set_data(caller_profile, "Caller", client->params);
}
while(switch_channel_ready(channel)) {
switch_status_t status = SWITCH_STATUS_FALSE;
if (client->profile->perms.extended_data && (!loops++ || all_extended)) {
switch_channel_event_set_extended_data(channel, client->one_time_params);
}
if ((status = httapi_sync(client)) == SWITCH_STATUS_SUCCESS) {
if (client->code == 200) {
const char *ct = switch_event_get_header(client->headers, "content-type");
if (switch_stristr("text/xml", ct)) {
char *zero = "\0";
switch_buffer_write(client->buffer, zero, 1);
status = parse_xml(client);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Received unsupported content-type %s\n", ct);
break;
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Received HTTP response: %ld.\n", client->code);
break;
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error %d!\n", client->err);
}
if (status == SWITCH_STATUS_TERM) {
httapi_sync(client);
}
if (status != SWITCH_STATUS_SUCCESS) {
break;
}
}
switch_safe_free(parsed);
}
/* HTTP FILE INTERFACE */
static const char *find_ext(const char *in)
{
const char *p = in + (strlen(in) - 1);
while(p >= in && *p) {
if (*p == '/') return NULL;
if (*p == '.') return (p+1);
p--;
}
return NULL;
}
static char *load_cache_data(http_file_context_t *context, const char *url)
{
const char *ext = NULL;
char *dext = NULL, *p;
char digest[SWITCH_MD5_DIGEST_STRING_SIZE] = { 0 };
char meta_buffer[1024] = "";
int fd;
switch_ssize_t bytes;
switch_md5_string(digest, (void *) url, strlen(url));
if (context->url_params) {
ext = switch_event_get_header(context->url_params, "ext");
}
if (zstr(ext)) {
ext = find_ext(url);
}
if (ext && (p = strchr(ext, '?'))) {
dext = strdup(ext);
if ((p = strchr(dext, '?'))) {
*p = '\0';
ext = dext;
} else switch_safe_free(dext);
}
context->cache_file_base = switch_core_sprintf(context->pool, "%s%s%s", globals.cache_path, SWITCH_PATH_SEPARATOR, digest);
context->meta_file = switch_core_sprintf(context->pool, "%s%s%s.meta", globals.cache_path, SWITCH_PATH_SEPARATOR, digest);
if (switch_file_exists(context->meta_file, context->pool) == SWITCH_STATUS_SUCCESS && ((fd = open(context->meta_file, O_RDONLY, 0)) > -1)) {
if ((bytes = read(fd, meta_buffer, sizeof(meta_buffer))) > 0) {
char *p;
if ((p = strchr(meta_buffer, ':'))) {
*p++ = '\0';
if (context->expires != 1) {
context->expires = (time_t) atol(meta_buffer);
}
context->metadata = switch_core_strdup(context->pool, p);
}
if ((p = strrchr(context->metadata, ':'))) {
p++;
if (!zstr(p)) {
ext = p;
}
}
}
close(fd);
}
context->cache_file = switch_core_sprintf(context->pool, "%s%s%s%s%s", globals.cache_path, SWITCH_PATH_SEPARATOR, digest, ext ? "." : "", ext ? ext : "");
switch_safe_free(dext);
return context->cache_file;
}
static size_t save_file_callback(void *ptr, size_t size, size_t nmemb, void *data)
{
register unsigned int realsize = (unsigned int) (size * nmemb);
client_t *client = data;
int x, wrote = 0, sanity = 1000;
unsigned char *buffer = (unsigned char *) ptr;
client->bytes += realsize;
if (client->bytes > client->max_bytes) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Oversized file detected [%d bytes]\n", (int) client->bytes);
client->err = 1;
return 0;
}
do {
x = write(client->fd, buffer + wrote, realsize - wrote);
if (x > 0) {
wrote += x;
} else {
switch_cond_next();
}
} while ((unsigned)wrote != realsize && (x == -1 && (errno == EAGAIN || errno == EINTR)) && --sanity);
if (wrote != (int) realsize) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Short write! fd:%d %d out of %d [%s]\n", client->fd, wrote, realsize, strerror(errno));
}
return wrote;
}
static switch_status_t fetch_cache_data(http_file_context_t *context, const char *url, switch_event_t **headers, const char *save_path, const char **err_msg)
{
switch_CURL *curl_handle = NULL;
client_t *client = NULL;
long code;
switch_status_t status = SWITCH_STATUS_FALSE;
char *dup_creds = NULL, *dynamic_url = NULL, *use_url;
char *ua = NULL;
const char *profile_name = NULL;
int tries = 10;
if (context->url_params) {
profile_name = switch_event_get_header(context->url_params, "profile_name");
}
if (zstr(profile_name)) {
if (globals.profile) profile_name = globals.profile->name;
}
if (zstr(profile_name)) {
profile_name = "default";
}
if (!(client = client_create(NULL, profile_name, NULL))) {
if (err_msg) {
*err_msg = "httapi profile configuration not found";
}
return SWITCH_STATUS_FALSE;
}
client->fd = -1;
if (save_path) {
while(--tries && (client->fd == 0 || client->fd == -1)) {
client->fd = open(save_path, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);
}
if (client->fd < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "ERROR OPENING FILE %s [%s]\n", save_path, strerror(errno));
if (err_msg) {
*err_msg = "Failed to open cache save file";
}
return SWITCH_STATUS_FALSE;
}
}
if (context->url_params) {
ua = switch_event_get_header(context->url_params, "user_agent");
}
if (zstr(ua)) {
ua = "mod_httapi/1.0";
}
if ((use_url = strchr(url, '@'))) {
char *r, *q, *p = strstr(url, "://");
use_url++;
dup_creds = strdup(p+3);
if ((q = strchr(dup_creds, '@'))) *q = '\0';
q = strdup(url);
r = strchr(q, '@');
r++;
if ((p = strstr(q, "://"))) {
*(p+3) = '\0';
}
p = switch_mprintf("%s%s", q, r);
dynamic_url = p;
free(q);
url = dynamic_url;
}
curl_handle = switch_curl_easy_init();
switch_curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1);
switch_curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1);
if (!strncasecmp(url, "https", 5)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, 0);
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 0);
}
client->max_bytes = HTTAPI_MAX_FILE_BYTES;
switch_curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1);
switch_curl_easy_setopt(curl_handle, CURLOPT_MAXREDIRS, 10);
switch_curl_easy_setopt(curl_handle, CURLOPT_URL, url);
if (client->profile->timeout) {
switch_curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, client->profile->timeout);
}
if (client->profile->ssl_cert_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLCERT, client->profile->ssl_cert_file);
}
if (client->profile->ssl_key_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLKEY, client->profile->ssl_key_file);
}
if (client->profile->ssl_key_password) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLKEYPASSWD, client->profile->ssl_key_password);
}
if (client->profile->ssl_version) {
if (!strcasecmp(client->profile->ssl_version, "SSLv3")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv3);
#ifdef CURL_SSLVERSION_TLSv1_1
} else if (!strcasecmp(client->profile->ssl_version, "TLSv1.1")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_1);
#endif
#ifdef CURL_SSLVERSION_TLSv1_2
} else if (!strcasecmp(client->profile->ssl_version, "TLSv1.2")) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
#endif
}
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
}
if (client->profile->ssl_cacert_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_CAINFO, client->profile->ssl_cacert_file);
}
if (client->profile->enable_ssl_verifyhost) {
switch_curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 2);
}
if (client->profile->cookie_file) {
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIEJAR, client->profile->cookie_file);
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIEFILE, client->profile->cookie_file);
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_COOKIE, "");
}
if (client->profile->bind_local) {
curl_easy_setopt(curl_handle, CURLOPT_INTERFACE, client->profile->bind_local);
}
if (save_path) {
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, save_file_callback);
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) client);
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_HEADER, 1);
switch_curl_easy_setopt(curl_handle, CURLOPT_NOBODY, 1);
}
if (headers) {
if (!client->headers) {
switch_event_create(&client->headers, SWITCH_EVENT_CLONE);
}
if (save_path) {
switch_curl_easy_setopt(curl_handle, CURLOPT_HEADERFUNCTION, get_header_callback);
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEHEADER, (void *) client);
} else {
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, get_header_callback);
switch_curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) client);
}
}
if (!zstr(dup_creds)) {
switch_curl_easy_setopt(curl_handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
switch_curl_easy_setopt(curl_handle, CURLOPT_USERPWD, dup_creds);
}
switch_curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, ua);
switch_curl_easy_perform(curl_handle);
switch_curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &code);
switch_curl_easy_cleanup(curl_handle);
if (client->fd > -1) {
close(client->fd);
client->fd = -1;
}
if (headers && client->headers) {
switch_event_add_header(client->headers, SWITCH_STACK_BOTTOM, "http-response-code", "%ld", code);
*headers = client->headers;
client->headers = NULL;
}
switch(code) {
case 200:
if (save_path) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "caching: url:%s to %s (%" SWITCH_SIZE_T_FMT " bytes)\n", url, save_path, client->bytes);
}
status = SWITCH_STATUS_SUCCESS;
break;
case 404:
status = SWITCH_STATUS_NOTFOUND;
if (err_msg) {
*err_msg = "response code = 404";
}
break;
default:
if (err_msg) {
*err_msg = "response code != 200";
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "caching: url:%s to %s failed with HTTP response code %d\n", url, save_path, (int)code);
status = SWITCH_STATUS_FALSE;
break;
}
switch_safe_free(dynamic_url);
switch_safe_free(dup_creds);
client_destroy(&client);
return status;
}
static switch_status_t write_meta_file(http_file_context_t *context, const char *data, switch_event_t *headers)
{
int fd;
switch_status_t status = SWITCH_STATUS_SUCCESS;
char write_data[1024];
if ((fd = open(context->meta_file, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) < 0) {
return SWITCH_STATUS_FALSE;
}
if (!zstr(data)) {
int ttl = globals.cache_ttl, abs_cache_ttl = globals.abs_cache_ttl;
const char *cc;
const char *p;
int x;
if (context->url_params) {
if ((cc = switch_event_get_header(context->url_params, "abs_cache_control"))) {
x = atoi(cc);
if (x > 0) {
abs_cache_ttl = x;
}
} else if ((cc = switch_event_get_header(context->url_params, "cache_control"))) {
x = atoi(cc);
if (x > 0) {
ttl = x;
}
}
}
if (abs_cache_ttl) {
ttl = abs_cache_ttl;
} else if (headers && (cc = switch_event_get_header(headers, "Cache-Control"))) {
if ((p = switch_stristr("max-age=", cc))) {
p += 8;
if (!zstr(p)) {
x = atoi(p);
if (x < ttl) {
ttl = x;
}
}
}
if (switch_stristr("no-cache", cc) || switch_stristr("no-store", cc)) {
context->del_on_close = 1;
}
}
switch_snprintf(write_data, sizeof(write_data),
"%" TIME_T_FMT ":%s",
switch_epoch_time_now(NULL) + ttl,
data);
status = write(fd, write_data, (int)strlen(write_data) + 1) > 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}
close(fd);
return status;
}
static void lock_file(http_file_context_t *context, switch_bool_t lock)
{
void *x = NULL;
if (lock) {
do {
switch_mutex_lock(globals.request_mutex);
if ((x = switch_core_hash_find(globals.request_hash, context->dest_url))) {
switch_mutex_unlock(globals.request_mutex);
switch_yield(100000);
}
} while(x);
switch_core_hash_insert(globals.request_hash, context->dest_url, (void *)1);
switch_mutex_unlock(globals.request_mutex);
} else {
switch_mutex_lock(globals.request_mutex);
switch_core_hash_delete(globals.request_hash, context->dest_url);
switch_mutex_unlock(globals.request_mutex);
}
return;
}
static switch_status_t locate_url_file(http_file_context_t *context, const char *url)
{
switch_event_t *headers = NULL;
int unreachable = 0;
switch_status_t status = SWITCH_STATUS_FALSE;
time_t now = switch_epoch_time_now(NULL);
char *metadata;
const char *ext = NULL;
const char *err_msg = NULL;
load_cache_data(context, url);
if (context->expires > 1 && now < context->expires) {
return SWITCH_STATUS_SUCCESS;
}
if (context->url_params) {
ext = switch_event_get_header(context->url_params, "ext");
}
if (zstr(ext)) {
ext = find_ext(context->cache_file);
}
if (!context->url_params || !switch_true(switch_event_get_header(context->url_params, "nohead"))) {
const char *ct = NULL;
const char *newext = NULL;
if ((status = fetch_cache_data(context, url, &headers, NULL, NULL)) != SWITCH_STATUS_SUCCESS) {
if (status == SWITCH_STATUS_NOTFOUND) {
unreachable = 2;
if (now - context->expires < globals.not_found_expires) {
switch_goto_status(SWITCH_STATUS_SUCCESS, end);
}
} else {
unreachable = 1;
}
}
if (zstr(ext) && headers && (ct = switch_event_get_header(headers, "content-type"))) {
newext = switch_core_mime_type2ext(ct);
}
if (newext) {
ext = newext;
context->cache_file = switch_core_sprintf(context->pool, "%s.%s", context->cache_file, newext);
}
if (switch_file_exists(context->cache_file, context->pool) != SWITCH_STATUS_SUCCESS && unreachable) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "File at url [%s] is unreachable!\n", url);
status = SWITCH_STATUS_NOTFOUND;
goto end;
}
if (!unreachable && !zstr(context->metadata)) {
metadata = switch_core_sprintf(context->pool, "%s:%s:%s:%s:%s",
url,
switch_event_get_header_nil(headers, "last-modified"),
switch_event_get_header_nil(headers, "etag"),
switch_event_get_header_nil(headers, "content-length"),
ext
);
if (!strcmp(metadata, context->metadata)) {
write_meta_file(context, metadata, headers);
switch_goto_status(SWITCH_STATUS_SUCCESS, end);
}
}
switch_event_destroy(&headers);
}
if ((status = fetch_cache_data(context, url, &headers, context->cache_file, &err_msg)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error fetching file at URL \"%s\" (%s)\n", url, err_msg ? err_msg : "");
goto end;
}
metadata = switch_core_sprintf(context->pool, "%s:%s:%s:%s:%s",
url,
switch_event_get_header_nil(headers, "last-modified"),
switch_event_get_header_nil(headers, "etag"),
switch_event_get_header_nil(headers, "content-length"),
ext
);
write_meta_file(context, metadata, headers);
if (switch_file_exists(context->cache_file, context->pool) == SWITCH_STATUS_SUCCESS) {
status = SWITCH_STATUS_SUCCESS;
}
end:
if (status != SWITCH_STATUS_SUCCESS) {
unlink(context->meta_file);
unlink(context->cache_file);
}
switch_event_destroy(&headers);
return status;
}
static switch_status_t http_file_file_seek(switch_file_handle_t *handle, unsigned int *cur_sample, int64_t samples, int whence)
{
http_file_context_t *context = handle->private_info;
if (!handle->seekable) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "File is not seekable\n");
return SWITCH_STATUS_NOTIMPL;
}
return switch_core_file_seek(&context->fh, cur_sample, samples, whence);
}
static switch_status_t file_open(switch_file_handle_t *handle, const char *path, int is_https)
{
http_file_context_t *context;
char *parsed = NULL, *pdup = NULL;
const char *pa = NULL;
switch_status_t status;
if (!strncmp(path, "http://", 7)) {
pa = path + 7;
} else if (!strncmp(path, "https://", 8)) {
pa = path + 8;
is_https = 1;
} else {
pa = path;
}
context = switch_core_alloc(handle->memory_pool, sizeof(*context));
context->pool = handle->memory_pool;
pdup = switch_core_strdup(context->pool, pa);
switch_event_create_brackets(pdup, '(', ')', ',', &context->url_params, &parsed, SWITCH_FALSE);
if (context->url_params) {
const char *var;
context->ua = switch_event_get_header(context->url_params, "ua");
if ((var = switch_event_get_header(context->url_params, "cache")) && !switch_true(var)) {
context->expires = 1;
}
}
if (parsed) pa = parsed;
if (is_https) {
context->dest_url = switch_core_sprintf(context->pool, "https://%s", pa);
} else {
context->dest_url = switch_core_sprintf(context->pool, "http://%s", pa);
}
if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
char *ext;
context->fh.channels = handle->channels;
context->fh.native_rate = handle->native_rate;
context->fh.samples = handle->samples;
context->fh.samplerate = handle->samplerate;
context->fh.prefix = handle->prefix;
if (context->url_params) {
context->write.file_name = switch_event_get_header(context->url_params, "file");
context->write.profile_name = switch_event_get_header(context->url_params, "profile");
context->write.method = switch_event_get_header(context->url_params, "method");
context->write.name = switch_event_get_header(context->url_params, "name");
}
if (!context->write.file_name) {
char *p;
if ((p = strrchr(context->dest_url, '/'))) {
p++;
context->write.file_name = switch_core_strdup(context->pool, p);
}
}
if (!context->write.file_name) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No file name specified.\n");
return SWITCH_STATUS_GENERR;
}
if ((ext = strrchr(context->write.file_name, '.'))) {
ext++;
} else {
ext = "wav";
}
if (!context->write.profile_name) context->write.profile_name = "default";
if (!context->write.method) context->write.method = !strcasecmp(ext, "cgi") ? "post" : "put";
if (!context->write.name) context->write.name = "recorded_file";
switch_uuid_str(context->write.uuid_str, sizeof(context->write.uuid_str));
context->write.file = switch_core_sprintf(context->pool, "%s%s%s_%s",
SWITCH_GLOBAL_dirs.temp_dir, SWITCH_PATH_SEPARATOR, context->write.uuid_str, context->write.file_name);
if (switch_core_file_open(&context->fh, context->write.file, handle->channels, handle->samplerate, handle->flags, NULL) != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_GENERR;
}
} else {
if (context->url_params) {
context->read.ext = switch_event_get_header(context->url_params, "ext");
}
lock_file(context, SWITCH_TRUE);
status = locate_url_file(context, context->dest_url);
lock_file(context, SWITCH_FALSE);
if (status != SWITCH_STATUS_SUCCESS) {
return status;
}
if ((status = switch_core_file_open(&context->fh,
context->cache_file,
handle->channels,
handle->samplerate,
handle->flags, NULL)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid cache file %s opening url %s Discarding file.\n", context->cache_file, path);
unlink(context->cache_file);
unlink(context->meta_file);
return status;
}
if (switch_test_flag(&context->fh, SWITCH_FILE_FLAG_VIDEO)) {
switch_set_flag(handle, SWITCH_FILE_FLAG_VIDEO);
} else {
switch_clear_flag(handle, SWITCH_FILE_FLAG_VIDEO);
}
}
handle->private_info = context;
handle->samples = context->fh.samples;
handle->format = context->fh.format;
handle->sections = context->fh.sections;
handle->seekable = context->fh.seekable;
handle->speed = context->fh.speed;
handle->interval = context->fh.interval;
handle->channels = context->fh.channels;
handle->cur_channels = context->fh.real_channels;
handle->flags |= SWITCH_FILE_NOMUX;
if (switch_test_flag((&context->fh), SWITCH_FILE_NATIVE)) {
switch_set_flag_locked(handle, SWITCH_FILE_NATIVE);
} else {
switch_clear_flag_locked(handle, SWITCH_FILE_NATIVE);
}
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t http_file_file_open(switch_file_handle_t *handle, const char *path) {
return file_open(handle, path, 0);
}
static switch_status_t https_file_file_open(switch_file_handle_t *handle, const char *path) {
return file_open(handle, path, 1);
}
static switch_status_t http_file_file_close(switch_file_handle_t *handle)
{
http_file_context_t *context = handle->private_info;
if (switch_test_flag((&context->fh), SWITCH_FILE_OPEN)) {
switch_core_file_close(&context->fh);
}
if (context->write.file) {
client_t *client;
switch_event_t *params;
char *key;
switch_event_create(&params, SWITCH_EVENT_CLONE);
params->flags |= EF_UNIQ_HEADERS;
if (!strcasecmp(context->write.method, "put")) {
switch_event_add_header(params, SWITCH_STACK_BOTTOM, "put_file", "%s", context->write.file);
} else {
key = switch_core_sprintf(context->pool, "attach_file:%s:%s", context->write.name, context->write.file_name);
switch_event_add_header(params, SWITCH_STACK_BOTTOM, key, "%s", context->write.file);
}
switch_event_add_header(params, SWITCH_STACK_BOTTOM, "url", "%s", context->dest_url);
switch_event_add_header(params, SWITCH_STACK_BOTTOM, "file_driver", "true");
switch_event_add_header(params, SWITCH_STACK_BOTTOM, "HTTAPI_SESSION_ID", "%s", context->write.uuid_str);
if ((client = client_create(NULL, context->write.profile_name, &params))) {
httapi_sync(client);
client_destroy(&client);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find suitable profile\n");
switch_event_destroy(&params);
}
unlink(context->write.file);
return SWITCH_STATUS_SUCCESS;
}
if (context->del_on_close) {
if (context->cache_file) {
unlink(context->cache_file);
unlink(context->meta_file);
}
}
if (context->url_params) {
switch_event_destroy(&context->url_params);
}
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t http_file_read_video(switch_file_handle_t *handle, switch_frame_t *frame, switch_video_read_flag_t flags)
{
http_file_context_t *context = handle->private_info;
return switch_core_file_read_video(&context->fh, frame, flags);
}
static switch_status_t http_file_write_video(switch_file_handle_t *handle, switch_frame_t *frame)
{
http_file_context_t *context = handle->private_info;
return switch_core_file_write_video(&context->fh, frame);
}
static switch_status_t http_file_write(switch_file_handle_t *handle, void *data, size_t *len)
{
http_file_context_t *context = handle->private_info;
return switch_core_file_write(&context->fh, data, len);
}
static switch_status_t http_file_file_read(switch_file_handle_t *handle, void *data, size_t *len)
{
http_file_context_t *context = handle->private_info;
switch_status_t status;
if (context->samples > 0) {
if (*len > (size_t) context->samples) {
*len = context->samples;
}
context->samples -= (int)*len;
memset(data, 255, *len *2);
status = SWITCH_STATUS_SUCCESS;
} else {
status = switch_core_file_read(&context->fh, data, len);
}
return status;
}
/* Registration */
static char *http_file_supported_formats[SWITCH_MAX_CODECS] = { 0 };
static char *https_file_supported_formats[SWITCH_MAX_CODECS] = { 0 };
/* /HTTP FILE INTERFACE */
SWITCH_MODULE_LOAD_FUNCTION(mod_httapi_load)
{
switch_api_interface_t *httapi_api_interface;
switch_application_interface_t *app_interface;
switch_file_interface_t *http_file_interface;
switch_file_interface_t *https_file_interface;
/* connect my internal structure to the blank pointer passed to me */
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
memset(&globals, 0, sizeof(globals));
globals.pool = pool;
globals.hash_root = NULL;
globals.hash_tail = NULL;
globals.cache_ttl = 300;
globals.not_found_expires = 300;
switch_mutex_init(&globals.request_mutex, SWITCH_MUTEX_NESTED, pool);
http_file_supported_formats[0] = "http";
http_file_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_FILE_INTERFACE);
http_file_interface->interface_name = modname;
http_file_interface->extens = http_file_supported_formats;
http_file_interface->file_open = http_file_file_open;
http_file_interface->file_close = http_file_file_close;
http_file_interface->file_read = http_file_file_read;
http_file_interface->file_write = http_file_write;
http_file_interface->file_seek = http_file_file_seek;
http_file_interface->file_read_video = http_file_read_video;
http_file_interface->file_write_video = http_file_write_video;
https_file_supported_formats[0] = "https";
https_file_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_FILE_INTERFACE);
https_file_interface->interface_name = modname;
https_file_interface->extens = https_file_supported_formats;
https_file_interface->file_open = https_file_file_open;
https_file_interface->file_close = http_file_file_close;
https_file_interface->file_read = http_file_file_read;
https_file_interface->file_write = http_file_write;
https_file_interface->file_seek = http_file_file_seek;
https_file_interface->file_read_video = http_file_read_video;
https_file_interface->file_write_video = http_file_write_video;
switch_snprintf(globals.cache_path, sizeof(globals.cache_path), "%s%shttp_file_cache", SWITCH_GLOBAL_dirs.storage_dir, SWITCH_PATH_SEPARATOR);
switch_dir_make_recursive(globals.cache_path, SWITCH_DEFAULT_DIR_PERMS, pool);
switch_core_hash_init(&globals.profile_hash);
switch_core_hash_init(&globals.request_hash);
switch_core_hash_init_case(&globals.parse_hash, SWITCH_FALSE);
bind_parser("execute", parse_execute);
bind_parser("sms", parse_sms);
bind_parser("dial", parse_dial);
bind_parser("pause", parse_playback);
bind_parser("answer", parse_answer);
bind_parser("preAnswer", parse_answer);
bind_parser("ringReady", parse_answer);
bind_parser("hangup", parse_hangup);
bind_parser("record", parse_record);
bind_parser("recordCall", parse_record_call);
bind_parser("playback", parse_playback);
bind_parser("vmName", parse_playback);
bind_parser("speak", parse_playback);
bind_parser("say", parse_playback);
bind_parser("conference", parse_conference);
bind_parser("break", parse_break);
bind_parser("log", parse_log);
bind_parser("continue", parse_continue);
bind_parser("getVariable", parse_get_var);
bind_parser("voicemail", parse_voicemail);
if (do_config() != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
}
SWITCH_ADD_API(httapi_api_interface, "httapi",
"HT-TAPI Hypertext Telephony API", httapi_api_function, HTTAPI_SYNTAX);
SWITCH_ADD_APP(app_interface, "httapi",
"HT-TAPI Hypertext Telephony API",
"HT-TAPI Hypertext Telephony API", httapi_function, "{<param1>=<val1>}", SAF_SUPPORT_NOMEDIA);
switch_console_set_complete("add httapi debug_on");
switch_console_set_complete("add httapi debug_off");
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_httapi_shutdown)
{
hash_node_t *ptr = NULL;
client_profile_t *profile;
switch_hash_index_t *hi;
void *val;
const void *vvar;
for (hi = switch_core_hash_first(globals.profile_hash); hi; hi = switch_core_hash_next(&hi)) {
switch_core_hash_this(hi, &vvar, NULL, &val);
profile = (client_profile_t *) val;
switch_event_destroy(&profile->dial_params.app_list);
switch_event_destroy(&profile->var_params.expand_var_list);
switch_event_destroy(&profile->var_params.set_var_list);
switch_event_destroy(&profile->var_params.get_var_list);
}
switch_core_hash_destroy(&globals.profile_hash);
switch_core_hash_destroy(&globals.parse_hash);
switch_core_hash_destroy(&globals.request_hash);
while (globals.hash_root) {
ptr = globals.hash_root;
switch_core_hash_destroy(&ptr->hash);
globals.hash_root = ptr->next;
switch_safe_free(ptr);
}
return SWITCH_STATUS_SUCCESS;
}
/* For Emacs:
* Local Variables:
* mode:c
* indent-tabs-mode:t
* tab-width:4
* c-basic-offset:4
* End:
* For VIM:
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
*/
View Git Blame Copy Permalink