SWITCH_DECLARE(int) CoreSession::insertFile(const char *file, const char *insert_file, int sample_point)
{
switch_status_t status;
this_check(-1);
sanity_check(-1);
status = switch_ivr_insert_file(session, file, insert_file, (switch_size_t)sample_point);
return status == SWITCH_STATUS_SUCCESS ? 1 : 0;
}
SWITCH_DECLARE(int) CoreSession::answer()
{
switch_status_t status;
this_check(-1);
sanity_check(-1);
status = switch_channel_answer(channel);
return status == SWITCH_STATUS_SUCCESS ? 1 : 0;
}
SWITCH_DECLARE(switch_status_t) CoreSession::process_callback_result(char *result)
{
this_check(SWITCH_STATUS_FALSE);
sanity_check(SWITCH_STATUS_FALSE);
return switch_ivr_process_fh(session, result, fhp);
}
SWITCH_DECLARE(int) CoreSession::collectDigits(int digit_timeout, int abs_timeout) {
this_check(-1);
sanity_check(-1);
begin_allow_threads();
switch_ivr_collect_digits_callback(session, ap, digit_timeout, abs_timeout);
end_allow_threads();
return SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(const char *) API::execute(const char *cmd, const char *arg)
{
switch_stream_handle_t stream = { 0 };
this_check("");
SWITCH_STANDARD_STREAM(stream);
switch_api_execute(cmd, arg, NULL, &stream);
switch_safe_free(last_data);
last_data = (char *) stream.data;
return last_data;
}
const char *ESLevent::getHeader(const char *header_name)
{
this_check("");
if (event) {
return esl_event_get_header(event, header_name);
} else {
esl_log(ESL_LOG_ERROR, "Trying to getHeader an event that does not exist!\n");
}
return NULL;
}
SWITCH_DECLARE(const char *)Event::getHeader(const char *header_name)
{
this_check("");
if (event) {
return switch_event_get_header(event, header_name);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to getHeader an event that does not exist!\n");
}
return NULL;
}
SWITCH_DECLARE(bool) CoreSession::bridged() {
this_check(false);
if (!session) {
return false;
}
sanity_check(false);
return (switch_channel_up(channel) && switch_channel_test_flag(channel, CF_BRIDGED));
}
SWITCH_DECLARE(const char *) CoreSession::getState()
{
this_check(NULL);
if (channel) {
return switch_channel_state_name(switch_channel_get_state(channel));
}
return "ERROR";
}
SWITCH_DECLARE(int) CoreSession::transfer(char *extension, char *dialplan, char *context)
{
switch_status_t status;
this_check(-1);
sanity_check(-1);
begin_allow_threads();
status = switch_ivr_session_transfer(session, extension, dialplan, context);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "transfer result: %d\n", status);
end_allow_threads();
return status == SWITCH_STATUS_SUCCESS ? 1 : 0;
}
SWITCH_DECLARE(bool) CoreSession::ready() {
this_check(false);
if (!session) {
return false;
}
sanity_check(false);
return switch_channel_ready(channel) != 0;
}
bool ESLevent::delHeader(const char *header_name)
{
this_check(false);
if (event) {
return esl_event_del_header(event, header_name) == ESL_SUCCESS ? true : false;
} else {
esl_log(ESL_LOG_ERROR, "Trying to delHeader an event that does not exist!\n");
}
return false;
}
SWITCH_DECLARE(const char *)Event::getType(void)
{
this_check("");
if (event) {
return switch_event_name(event->event_id);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to getType an event that does not exist!\n");
}
return (char *) "invalid";
}
bool ESLevent::addBody(const char *value)
{
this_check(false);
if (event) {
return esl_event_add_body(event, "%s", value) == ESL_SUCCESS ? true : false;
} else {
esl_log(ESL_LOG_ERROR, "Trying to addBody an event that does not exist!\n");
}
return false;
}
SWITCH_DECLARE(bool) Event::addBody(const char *value)
{
this_check(false);
if (event) {
return switch_event_add_body(event, "%s", value) == SWITCH_STATUS_SUCCESS ? true : false;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to addBody an event that does not exist!\n");
}
return false;
}
SWITCH_DECLARE(bool) Event::delHeader(const char *header_name)
{
this_check(false);
if (event) {
return switch_event_del_header(event, header_name) == SWITCH_STATUS_SUCCESS ? true : false;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to delHeader an event that does not exist!\n");
}
return false;
}
SWITCH_DECLARE(bool) Event::addHeader(const char *header_name, const char *value)
{
this_check(false);
if (event) {
return switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, value) == SWITCH_STATUS_SUCCESS ? true : false;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
}
return false;
}
SWITCH_DECLARE(bool) Event::setPriority(switch_priority_t priority)
{
this_check(false);
if (event) {
switch_event_set_priority(event, priority);
return true;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to setPriority an event that does not exist!\n");
}
return false;
}
const char *ESLevent::getType(void)
{
this_check("");
if (event) {
return esl_event_name(event->event_id);
} else {
esl_log(ESL_LOG_ERROR, "Trying to getType an event that does not exist!\n");
}
return (char *) "invalid";
}
bool ESLevent::setPriority(esl_priority_t priority)
{
this_check(false);
if (event) {
esl_event_set_priority(event, priority);
return true;
} else {
esl_log(ESL_LOG_ERROR, "Trying to setPriority an event that does not exist!\n");
}
return false;
}
bool ESLevent::addHeader(const char *header_name, const char *value)
{
this_check(false);
if (event) {
return esl_event_add_header_string(event, ESL_STACK_BOTTOM, header_name, value) == ESL_SUCCESS ? true : false;
} else {
esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
}
return false;
}
SWITCH_DECLARE(char *)Event::getBody(void)
{
this_check((char *)"");
if (event) {
return switch_event_get_body(event);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to getBody an event that does not exist!\n");
}
return NULL;
}
char *ESLevent::getBody(void)
{
this_check((char *)"");
if (event) {
return esl_event_get_body(event);
} else {
esl_log(ESL_LOG_ERROR, "Trying to getBody an event that does not exist!\n");
}
return NULL;
}
SWITCH_DECLARE(int) CoreSession::sleep(int ms, int sync) {
switch_status_t status;
this_check(-1);
sanity_check(-1);
begin_allow_threads();
status = switch_ivr_sleep(session, ms, (switch_bool_t) sync, ap);
end_allow_threads();
return status == SWITCH_STATUS_SUCCESS ? 1 : 0;
}
SWITCH_DECLARE(int) CoreSession::originate(CoreSession *a_leg_session, char *dest, int timeout, switch_state_handler_table_t *handlers)
{
switch_core_session_t *aleg_core_session = NULL;
this_check(0);
cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
if (a_leg_session != NULL) {
aleg_core_session = a_leg_session->session;
}
// this session has no valid switch_core_session_t at this point, and therefore
// no valid channel. since the threadstate is stored in the channel, and there
// is none, if we try to call begin_alllow_threads it will fail miserably.
// use the 'a leg session' to do the thread swapping stuff.
if (a_leg_session) a_leg_session->begin_allow_threads();
if (switch_ivr_originate(aleg_core_session,
&session,
&cause,
dest,
timeout,
handlers,
NULL,
NULL,
NULL,
NULL,
SOF_NONE,
NULL) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Error Creating Outgoing Channel! [%s]\n", dest);
goto failed;
}
if (a_leg_session) a_leg_session->end_allow_threads();
channel = switch_core_session_get_channel(session);
allocated = 1;
switch_safe_free(uuid);
uuid = strdup(switch_core_session_get_uuid(session));
switch_channel_set_state(switch_core_session_get_channel(session), CS_SOFT_EXECUTE);
return SWITCH_STATUS_SUCCESS;
failed:
if (a_leg_session) a_leg_session->end_allow_threads();
return SWITCH_STATUS_FALSE;
}
SWITCH_DECLARE(int) CoreSession::setAutoHangup(bool val)
{
this_check(-1);
sanity_check(-1);
if (!session) {
return SWITCH_STATUS_FALSE;
}
if (val) {
switch_set_flag(this, S_HUP);
} else {
switch_clear_flag(this, S_HUP);
}
return SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(const char *) API::execute(const char *cmd, const char *arg)
{
switch_stream_handle_t stream = { 0 };
this_check("");
SWITCH_STANDARD_STREAM(stream);
if (zstr(cmd)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No application specified\n");
stream.write_function(&stream, "-ERR No application specified");
} else {
switch_api_execute(cmd, arg, session, &stream);
}
return (char *) stream.data;
}
SWITCH_DECLARE(int) CoreSession::flushEvents()
{
switch_event_t *event;
this_check(-1);
sanity_check(-1);
if (!session) {
return SWITCH_STATUS_FALSE;
}
while (switch_core_session_dequeue_event(session, &event, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
switch_event_destroy(&event);
}
return SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(char *) CoreSession::getXMLCDR()
{
switch_xml_t cdr;
this_check((char *)"");
sanity_check((char *)"");
switch_safe_free(xml_cdr_text);
if (switch_ivr_generate_xml_cdr(session, &cdr) == SWITCH_STATUS_SUCCESS) {
xml_cdr_text = switch_xml_toxml(cdr, SWITCH_FALSE);
switch_xml_free(cdr);
}
return (char *) (xml_cdr_text ? xml_cdr_text : "");
}
const char *ESLevent::serialize(const char *format)
{
this_check("");
esl_safe_free(serialized_string);
if (!event) {
return "";
}
if (esl_event_serialize(event, &serialized_string, ESL_TRUE) == ESL_SUCCESS) {
return serialized_string;
}
return "";
}