+#include <switch.h>
#include "freeswitch_perl.h"
+#include "mod_perl_extra.h"
+
+static STRLEN n_a;
Session::Session() : CoreSession()
{
-
+ cb_function = cb_arg = hangup_func_str = NULL;
+ hh = mark = 0;
}
Session::Session(char *uuid) : CoreSession(uuid)
{
-
+ cb_function = cb_arg = hangup_func_str = NULL;
+ hh = mark = 0;
}
Session::Session(switch_core_session_t *new_session) : CoreSession(new_session)
{
-
+ cb_function = cb_arg = hangup_func_str = NULL;
+ hh = mark = 0;
}
-
-Session::~Session()
+static switch_status_t perl_hanguphook(switch_core_session_t *session_hungup);
+Session::~Session()
{
-
+ switch_safe_free(cb_function);
+ switch_safe_free(cb_arg);
+ switch_safe_free(hangup_func_str);
+ switch_core_event_hook_remove_state_change(session, perl_hanguphook);
}
-
bool Session::begin_allow_threads()
{
+ do_hangup_hook();
return true;
}
bool Session::end_allow_threads()
{
+ do_hangup_hook();
return true;
}
+void Session::setPERL(PerlInterpreter *pi)
+{
+ my_perl = pi;
+}
+
+PerlInterpreter *Session::getPERL()
+{
+ if (!my_perl) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Doh!\n");
+ }
+ return my_perl;
+}
+
+
+bool Session::ready() {
+ bool r;
+
+ sanity_check(false);
+ r = switch_channel_ready(channel) != 0;
+ do_hangup_hook();
+
+ return r;
+}
+
void Session::check_hangup_hook()
{
+ if (hangup_func_str && (hook_state == CS_HANGUP || hook_state == CS_RING)) {
+ hh++;
+ }
}
-switch_status_t Session::run_dtmf_callback(void *input, switch_input_type_t itype)
+void Session::do_hangup_hook()
{
- return SWITCH_STATUS_FALSE;
+ if (hh && !mark) {
+ const char *err = NULL;
+ mark++;
+ char *code;
+ if (!getPERL()) {
+ return;
+ }
+
+ code = switch_mprintf("%s(%s)", hangup_func_str, hook_state == CS_HANGUP ? "hangup" : "transfer");
+ Perl_eval_pv(my_perl, code, TRUE);
+ free(code);
+ }
+}
+
+static switch_status_t perl_hanguphook(switch_core_session_t *session_hungup)
+{
+ switch_channel_t *channel = switch_core_session_get_channel(session_hungup);
+ CoreSession *coresession = NULL;
+ switch_channel_state_t state = switch_channel_get_state(channel);
+
+ if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) {
+ if (coresession->hook_state != state) {
+ coresession->hook_state = state;
+ coresession->check_hangup_hook();
+ }
+ }
+
+ return SWITCH_STATUS_SUCCESS;
}
-#if 0
-int Session::answer() {}
-int Session::preAnswer() {}
-void Session::hangup(char *cause) {}
-void Session::setVariable(char *var, char *val) {}
-const char *Session::getVariable(char *var) {}
-int Session::recordFile(char *file_name, int max_len, int silence_threshold, int silence_secs) {}
-void Session::setCallerData(char *var, char *val) {}
-int Session::originate(CoreSession *a_leg_session, char *dest, int timeout) {}
-void Session::setDTMFCallback(void *cbfunc, char *funcargs) {}
-int Session::speak(char *text) {}
-void Session::set_tts_parms(char *tts_name, char *voice_name) {}
-int Session::collectDigits(int timeout) {}
-int Session::getDigits(char *dtmf_buf,
- switch_size_t buflen,
- switch_size_t maxdigits,
- char *terminators,
- char *terminator,
- int timeout) {}
-
-int Session::transfer(char *extensions, char *dialplan, char *context) {}
-int Session::playAndGetDigits(int min_digits,
- int max_digits,
- int max_tries,
- int timeout,
- char *terminators,
- char *audio_files,
- char *bad_input_audio_files,
- char *dtmf_buf,
- char *digits_regex) {}
-
-int Session::streamFile(char *file, int starting_sample_count) {}
-int Session::flushEvents() {}
-int Session::flushDigits() {}
-int Session::setAutoHangup(bool val) {}
-void Session::setHangupHook(void *hangup_func) {}
-bool Session::ready() {}
-void Session::execute(char *app, char *data) {}
-char* Session::get_uuid() {}
-const switch_input_args_t& Session::get_cb_args() {}
-
-#endif
+void Session::setHangupHook(char *func) {
+
+ sanity_check_noreturn;
+
+ switch_safe_free(hangup_func_str);
+
+ if (func) {
+ hangup_func_str = strdup(func);
+ switch_channel_set_private(channel, "CoreSession", this);
+ hook_state = switch_channel_get_state(channel);
+ switch_core_event_hook_add_state_change(session, perl_hanguphook);
+ }
+}
+
+void Session::setInputCallback(char *cbfunc, char *funcargs) {
+
+ sanity_check_noreturn;
+
+ switch_safe_free(cb_function);
+ if (cbfunc) {
+ cb_function = strdup(cbfunc);
+ }
+
+ switch_safe_free(cb_arg);
+ if (funcargs) {
+ cb_arg = strdup(funcargs);
+ }
+
+ args.buf = this;
+ switch_channel_set_private(channel, "CoreSession", this);
+
+ args.input_callback = dtmf_callback;
+ ap = &args;
+}
+
+switch_status_t Session::run_dtmf_callback(void *input, switch_input_type_t itype)
+{
+ const char *ret;
+
+ if (!getPERL()) {
+ return SWITCH_STATUS_FALSE;;
+ }
+
+ switch (itype) {
+ case SWITCH_INPUT_TYPE_DTMF:
+ {
+ switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
+ char str[32] = "";
+ int arg_count = 2;
+ HV *hash;
+ SV *this_sv;
+ char *code;
+
+ if (!(hash = get_hv("__dtmf", TRUE))) {
+ abort();
+ }
+
+ str[0] = dtmf->digit;
+ this_sv = newSV(strlen(str)+1);
+ sv_setpv(this_sv, str);
+ hv_store(hash, "digit", 5, this_sv, 0);
+
+ switch_snprintf(str, sizeof(str), "%d", dtmf->duration);
+ this_sv = newSV(strlen(str)+1);
+ sv_setpv(this_sv, str);
+ hv_store(hash, "duration", 8, this_sv, 0);
+
+ if (cb_arg) {
+ //this_sv = get_sv(cb_arg, TRUE); DOH!
+ }
+
+ code = switch_mprintf("%s('dtmf', \\%__dtmf, %s);", cb_function, switch_str_nil(cb_arg));
+ Perl_eval_pv(my_perl, code, TRUE);
+ free(code);
+
+ return process_callback_result(SvPV(get_sv(cb_function, FALSE), n_a));
+ }
+ break;
+ case SWITCH_INPUT_TYPE_EVENT:
+ {
+ switch_event_t *event = (switch_event_t *) input;
+ int arg_count = 2;
+ char *code;
+
+ mod_perl_conjure_event(my_perl, event, "__Input_Event__");
+
+ code = switch_mprintf("%s('event', $__Input_Event__, %s);", cb_function, switch_str_nil(cb_arg));
+ Perl_eval_pv(my_perl, code, TRUE);
+ free(code);
+
+
+ return process_callback_result((char *)ret);
+ }
+ break;
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
char *xml_handler;
} globals;
-static int Perl_safe_eval(PerlInterpreter *my_perl, const char *string, int tf)
+
+
+static int Perl_safe_eval(PerlInterpreter *my_perl, const char *string)
{
char *err = NULL;
Perl_eval_pv(my_perl, string, FALSE);
if ((err = SvPV(get_sv("@", TRUE), n_a)) && !switch_strlen_zero(err)) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s\n", err);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "[%s]\n%s\n", string, err);
return -1;
}
return 0;
}
+
+
+static int perl_parse_and_execute(PerlInterpreter *my_perl, char *input_code, char *setup_code)
+{
+ int error = 0;
+
+ if (switch_strlen_zero(input_code)) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No code to execute!\n");
+ return -1;
+ }
+
+ if (setup_code) {
+ error = Perl_safe_eval(my_perl, setup_code);
+ if (error) {
+ return error;
+ }
+ }
+
+ if (*input_code == '~') {
+ char *buff = input_code + 1;
+ error = Perl_safe_eval(my_perl, buff);
+ } else {
+ char *args = strchr(input_code, ' ');
+ if (args) {
+ char *code = NULL;
+ int x, argc;
+ char *argv[128] = { 0 };
+ *args++ = '\0';
+
+ if ((argc = switch_separate_string(args, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
+ switch_stream_handle_t stream = { 0 };
+ SWITCH_STANDARD_STREAM(stream);
+
+ stream.write_function(&stream, " @ARGV = ( ");
+ for (x = 0; x < argc; x++) {
+ stream.write_function(&stream, "'%s'%s", argv[x], x == argc-1 ? "" : ", ");
+ }
+ stream.write_function(&stream, " );");
+ code = stream.data;
+ } else {
+ code = switch_mprintf("ARGV = ();");
+ }
+
+ if (code) {
+ error = Perl_safe_eval(my_perl, code);
+ switch_safe_free(code);
+ }
+ }
+ if (!error) {
+ char *file = input_code;
+
+ if (!switch_is_file_path(file)) {
+ file = switch_mprintf("require '%s/%s';\n", SWITCH_GLOBAL_dirs.script_dir, file);
+ switch_assert(file);
+ } else {
+ file = switch_mprintf("require '%s';\n", file);
+ switch_assert(file);
+ }
+ error = Perl_safe_eval(my_perl, file);
+ switch_safe_free(file);
+ }
+ }
+
+ return error;
+}
+
static void destroy_perl(PerlInterpreter ** to_destroy)
{
perl_destruct(*to_destroy);
return my_perl;
}
+#if 0
static perl_parse_and_execute (PerlInterpreter *my_perl, char *input_code, char *setup_code)
{
int error = 0;
if (*input_code == '~') {
char *buff = input_code + 1;
perl_parse(my_perl, xs_init, 3, embedding, NULL);
- if (setup_code) Perl_safe_eval(my_perl, setup_code, FALSE);
- Perl_safe_eval(my_perl, buff, TRUE);
+ if (setup_code) Perl_safe_eval(my_perl, setup_code);
+ Perl_safe_eval(my_perl, buff);
} else {
int argc = 0;
char *argv[128] = { 0 };
argc += switch_separate_string(input_code, ' ', &argv[1], (sizeof(argv) / sizeof(argv[0])) - 1);
if (!perl_parse(my_perl, xs_init, argc, argv, (char **)NULL)) {
if (setup_code) {
- if (!Perl_safe_eval(my_perl, setup_code, FALSE)) {
+ if (!Perl_safe_eval(my_perl, setup_code)) {
perl_run(my_perl);
}
}
}
}
+#endif
static void perl_function(switch_core_session_t *session, char *data)
{
char *uuid = switch_core_session_get_uuid(session);
PerlInterpreter *my_perl = clone_perl();
-
char code[1024];
+
+ perl_parse(my_perl, xs_init, 3, embedding, NULL);
+ Perl_safe_eval(my_perl, code);
+
switch_snprintf(code, sizeof(code),
"use lib '%s/perl';\n"
"use freeswitch;\n"
uuid);
perl_parse_and_execute(my_perl, data, code);
- Perl_safe_eval(my_perl, "undef $session;", FALSE);
- Perl_safe_eval(my_perl, "undef (*);", FALSE);
+ Perl_safe_eval(my_perl, "undef $session;");
+ Perl_safe_eval(my_perl, "undef (*);");
destroy_perl(&my_perl);
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_perl_shutdown)
{
if (globals.my_perl) {
- perl_destruct(globals.my_perl);
perl_free(globals.my_perl);
globals.my_perl = NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Unallocated perl interpreter.\n");
return SWITCH_STATUS_SUCCESS;
}
+struct perl_o {
+ switch_stream_handle_t *stream;
+ switch_core_session_t *session;
+ char *cmd;
+ int d;
+};
+
static void *SWITCH_THREAD_FUNC perl_thread_run(switch_thread_t *thread, void *obj)
{
- char *input_code = (char *) obj;
PerlInterpreter *my_perl = clone_perl();
char code[1024];
+ SV *sv = NULL;
+ char *uuid = NULL;
+ struct perl_o *po = (struct perl_o *) obj;
+ char *cmd = po->cmd;
+ switch_stream_handle_t *stream = po->stream;
+ switch_core_session_t *session = po->session;
+ if (session) {
+ uuid = switch_core_session_get_uuid(session);
+ }
+
switch_snprintf(code, sizeof(code),
- "use lib '%s/perl';\n"
- "use freeswitch;\n"
- ,
- SWITCH_GLOBAL_dirs.base_dir
- );
+ "use lib '%s/perl';\n"
+ "use freeswitch;\n"
+ "$SWITCH_ENV{UUID} = \"%s\";\n"
+ ,
+
+ SWITCH_GLOBAL_dirs.base_dir,
+ switch_str_nil(uuid)
+ );
+
+ perl_parse(my_perl, xs_init, 3, embedding, NULL);
+ Perl_safe_eval(my_perl, code);
+
+ if (uuid) {
+ switch_snprintf(code, sizeof(code), "$session = new freeswitch::Session(\"%s\")", uuid);
+ Perl_safe_eval(my_perl, code);
+ }
- perl_parse_and_execute(my_perl, input_code, code);
+ if (cmd) {
+ if (stream) {
+ mod_perl_conjure_stream(my_perl, stream, "stream");
+ if (stream->event) {
+ mod_perl_conjure_event(my_perl, stream->event, "env");
+ }
+ }
+ //Perl_safe_eval(my_perl, cmd);
+ perl_parse_and_execute(my_perl, cmd, NULL);
+ }
- if (input_code) {
- free(input_code);
+ if (uuid) {
+ switch_snprintf(code, sizeof(code), "undef $session;", uuid);
+ Perl_safe_eval(my_perl, code);
}
- Perl_safe_eval(my_perl, "undef(*);", FALSE);
+ Perl_safe_eval(my_perl, "undef(*);");
destroy_perl(&my_perl);
+ switch_safe_free(cmd);
+
+ if (po->d) {
+ free(po);
+ }
+
return NULL;
}
{
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
+ struct perl_o *po;
+ po = malloc(sizeof(*po));
+ memset(po, 0, sizeof(*po));
+ po->cmd = strdup(text);
+ po->d = 1;
+
switch_threadattr_create(&thd_attr, globals.pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_thread_create(&thread, thd_attr, perl_thread_run, strdup(text), globals.pool);
+ switch_thread_create(&thread, thd_attr, perl_thread_run, po, globals.pool);
return 0;
}
SWITCH_STANDARD_API(perl_api_function) {
- PerlInterpreter *my_perl = clone_perl();
- char code[1024];
- SV *sv = NULL;
- char *uuid = NULL;
-
- if (session) {
- uuid = switch_core_session_get_uuid(session);
- }
-
- switch_snprintf(code, sizeof(code),
- "use lib '%s/perl';\n"
- "use freeswitch;\n"
- "$SWITCH_ENV{UUID} = \"%s\";\n"
- "use IO::String;\n"
- "$handle = IO::String->new($__OUT);\n"
- "select($handle);"
- ,
-
- SWITCH_GLOBAL_dirs.base_dir,
- switch_str_nil(uuid)
- );
-
- perl_parse(my_perl, xs_init, 3, embedding, NULL);
- Perl_safe_eval(my_perl, code, FALSE);
-
- if (uuid) {
- switch_snprintf(code, sizeof(code), "$session = new freeswitch::Session(\"%s\")", uuid);
- Perl_safe_eval(my_perl, code, FALSE);
- }
-
- if (cmd) {
- Perl_safe_eval(my_perl, cmd, FALSE);
- }
-
- stream->write_function(stream, "%s", switch_str_nil(SvPV(get_sv("__OUT", FALSE), n_a)));
-
- if (uuid) {
- switch_snprintf(code, sizeof(code), "undef $session;", uuid);
- Perl_safe_eval(my_perl, code, FALSE);
- }
-
- Perl_safe_eval(my_perl, "undef(*);", FALSE);
- destroy_perl(&my_perl);
-
- return SWITCH_STATUS_SUCCESS;
+ struct perl_o po = { 0 };
+ po.cmd = strdup(cmd);
+ po.stream = stream;
+ po.session = session;
+ perl_thread_run(NULL, &po);
}
static switch_xml_t perl_fetch(const char *section,
,
SWITCH_GLOBAL_dirs.base_dir
);
- Perl_safe_eval(my_perl, code, FALSE);
+ Perl_safe_eval(my_perl, code);
perl_run(my_perl);
str = SvPV(get_sv("XML_STRING", FALSE), n_a);
#define SWIGTYPE_p_API swig_types[0]
#define SWIGTYPE_p_CoreSession swig_types[1]
#define SWIGTYPE_p_Event swig_types[2]
-#define SWIGTYPE_p_Session swig_types[3]
-#define SWIGTYPE_p_Stream swig_types[4]
-#define SWIGTYPE_p_char swig_types[5]
-#define SWIGTYPE_p_input_callback_state swig_types[6]
-#define SWIGTYPE_p_session_flag_t swig_types[7]
-#define SWIGTYPE_p_switch_channel_state_t swig_types[8]
-#define SWIGTYPE_p_switch_channel_t swig_types[9]
-#define SWIGTYPE_p_switch_core_session_t swig_types[10]
-#define SWIGTYPE_p_switch_event_t swig_types[11]
-#define SWIGTYPE_p_switch_input_args_t swig_types[12]
-#define SWIGTYPE_p_switch_input_type_t swig_types[13]
-#define SWIGTYPE_p_switch_priority_t swig_types[14]
-#define SWIGTYPE_p_switch_status_t swig_types[15]
-#define SWIGTYPE_p_switch_stream_handle_t swig_types[16]
-#define SWIGTYPE_p_void swig_types[17]
-static swig_type_info *swig_types[19];
-static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
+#define SWIGTYPE_p_PerlInterpreter swig_types[3]
+#define SWIGTYPE_p_Session swig_types[4]
+#define SWIGTYPE_p_Stream swig_types[5]
+#define SWIGTYPE_p_char swig_types[6]
+#define SWIGTYPE_p_input_callback_state swig_types[7]
+#define SWIGTYPE_p_session_flag_t swig_types[8]
+#define SWIGTYPE_p_switch_channel_state_t swig_types[9]
+#define SWIGTYPE_p_switch_channel_t swig_types[10]
+#define SWIGTYPE_p_switch_core_session_t swig_types[11]
+#define SWIGTYPE_p_switch_event_t swig_types[12]
+#define SWIGTYPE_p_switch_input_args_t swig_types[13]
+#define SWIGTYPE_p_switch_input_type_t swig_types[14]
+#define SWIGTYPE_p_switch_priority_t swig_types[15]
+#define SWIGTYPE_p_switch_size_t swig_types[16]
+#define SWIGTYPE_p_switch_status_t swig_types[17]
+#define SWIGTYPE_p_switch_stream_handle_t swig_types[18]
+#define SWIGTYPE_p_void swig_types[19]
+static swig_type_info *swig_types[21];
+static swig_module_info swig_module = {swig_types, 20, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
XS(_wrap_CoreSession_getDigits) {
{
CoreSession *arg1 = (CoreSession *) 0 ;
- int arg2 ;
+ switch_size_t arg2 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int arg5 ;
char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_getDigits" "', argument " "1"" of type '" "CoreSession *""'");
}
arg1 = reinterpret_cast< CoreSession * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_getDigits" "', argument " "2"" of type '" "int""'");
- }
- arg2 = static_cast< int >(val2);
+ {
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_switch_size_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_getDigits" "', argument " "2"" of type '" "switch_size_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoreSession_getDigits" "', argument " "2"" of type '" "switch_size_t""'");
+ } else {
+ arg2 = *(reinterpret_cast< switch_size_t * >(argp2));
+ }
+ }
res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_getDigits" "', argument " "3"" of type '" "char *""'");
result = (char *)(arg1)->getDigits(arg2,arg3,arg4,arg5);
ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
-
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
XSRETURN(argvi);
fail:
-
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
if ((items < 0) || (items > 0)) {
SWIG_croak("Usage: new_Session();");
}
- result = (Session *)new Session();
+ result = (Session *)new Session(); result->setPERL(my_perl);
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Session, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Session" "', argument " "1"" of type '" "char *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
- result = (Session *)new Session(arg1);
+ result = (Session *)new Session(arg1); result->setPERL(my_perl);
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Session, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
XSRETURN(argvi);
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Session" "', argument " "1"" of type '" "switch_core_session_t *""'");
}
arg1 = reinterpret_cast< switch_core_session_t * >(argp1);
- result = (Session *)new Session(arg1);
+ result = (Session *)new Session(arg1); result->setPERL(my_perl);
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Session, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
}
+XS(_wrap_Session_setInputCallback) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: Session_setInputCallback(self,cbfunc,funcargs);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setInputCallback" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setInputCallback" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = reinterpret_cast< char * >(buf2);
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_setInputCallback" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = reinterpret_cast< char * >(buf3);
+ (arg1)->setInputCallback(arg2,arg3);
+
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_setHangupHook) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Session_setHangupHook(self,func);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setHangupHook" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setHangupHook" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = reinterpret_cast< char * >(buf2);
+ (arg1)->setHangupHook(arg2);
+
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_ready) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Session_ready(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_ready" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ result = (bool)(arg1)->ready();
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_cb_function_set) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Session_cb_function_set(self,cb_function);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_cb_function_set" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_cb_function_set" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = reinterpret_cast< char * >(buf2);
+ if (arg1->cb_function) delete[] arg1->cb_function;
+ if (arg2) {
+ size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
+ arg1->cb_function = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
+ } else {
+ arg1->cb_function = 0;
+ }
+
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_cb_function_get) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Session_cb_function_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_cb_function_get" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ result = (char *) ((arg1)->cb_function);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_cb_arg_set) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Session_cb_arg_set(self,cb_arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_cb_arg_set" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_cb_arg_set" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = reinterpret_cast< char * >(buf2);
+ if (arg1->cb_arg) delete[] arg1->cb_arg;
+ if (arg2) {
+ size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
+ arg1->cb_arg = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
+ } else {
+ arg1->cb_arg = 0;
+ }
+
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_cb_arg_get) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Session_cb_arg_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_cb_arg_get" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ result = (char *) ((arg1)->cb_arg);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_hangup_func_str_set) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Session_hangup_func_str_set(self,hangup_func_str);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_hangup_func_str_set" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_hangup_func_str_set" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = reinterpret_cast< char * >(buf2);
+ if (arg1->hangup_func_str) delete[] arg1->hangup_func_str;
+ if (arg2) {
+ size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
+ arg1->hangup_func_str = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
+ } else {
+ arg1->hangup_func_str = 0;
+ }
+
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_hangup_func_str_get) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ char *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Session_hangup_func_str_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_hangup_func_str_get" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ result = (char *) ((arg1)->hangup_func_str);
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Session_setPERL) {
+ {
+ Session *arg1 = (Session *) 0 ;
+ PerlInterpreter *arg2 = (PerlInterpreter *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Session_setPERL(self,pi);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Session, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setPERL" "', argument " "1"" of type '" "Session *""'");
+ }
+ arg1 = reinterpret_cast< Session * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_PerlInterpreter, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setPERL" "', argument " "2"" of type '" "PerlInterpreter *""'");
+ }
+ arg2 = reinterpret_cast< PerlInterpreter * >(argp2);
+ (arg1)->setPERL(arg2);
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_API = {"_p_API", "API *", 0, 0, (void*)"freeswitch::API", 0};
static swig_type_info _swigt__p_CoreSession = {"_p_CoreSession", "CoreSession *", 0, 0, (void*)"freeswitch::CoreSession", 0};
static swig_type_info _swigt__p_Event = {"_p_Event", "Event *", 0, 0, (void*)"freeswitch::Event", 0};
+static swig_type_info _swigt__p_PerlInterpreter = {"_p_PerlInterpreter", "PerlInterpreter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Session = {"_p_Session", "Session *", 0, 0, (void*)"freeswitch::Session", 0};
static swig_type_info _swigt__p_Stream = {"_p_Stream", "Stream *", 0, 0, (void*)"freeswitch::Stream", 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_switch_input_args_t = {"_p_switch_input_args_t", "switch_input_args_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_switch_input_type_t = {"_p_switch_input_type_t", "switch_input_type_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_switch_priority_t = {"_p_switch_priority_t", "switch_priority_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_switch_size_t = {"_p_switch_size_t", "switch_size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_switch_status_t = {"_p_switch_status_t", "switch_status_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_switch_stream_handle_t = {"_p_switch_stream_handle_t", "switch_stream_handle_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
&_swigt__p_API,
&_swigt__p_CoreSession,
&_swigt__p_Event,
+ &_swigt__p_PerlInterpreter,
&_swigt__p_Session,
&_swigt__p_Stream,
&_swigt__p_char,
&_swigt__p_switch_input_args_t,
&_swigt__p_switch_input_type_t,
&_swigt__p_switch_priority_t,
+ &_swigt__p_switch_size_t,
&_swigt__p_switch_status_t,
&_swigt__p_switch_stream_handle_t,
&_swigt__p_void,
static swig_cast_info _swigc__p_API[] = { {&_swigt__p_API, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CoreSession[] = { {&_swigt__p_CoreSession, 0, 0, 0}, {&_swigt__p_Session, _p_SessionTo_p_CoreSession, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Event[] = { {&_swigt__p_Event, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlInterpreter[] = { {&_swigt__p_PerlInterpreter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Session[] = { {&_swigt__p_Session, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Stream[] = { {&_swigt__p_Stream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_switch_input_args_t[] = { {&_swigt__p_switch_input_args_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_switch_input_type_t[] = { {&_swigt__p_switch_input_type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_switch_priority_t[] = { {&_swigt__p_switch_priority_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_switch_size_t[] = { {&_swigt__p_switch_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_switch_status_t[] = { {&_swigt__p_switch_status_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_switch_stream_handle_t[] = { {&_swigt__p_switch_stream_handle_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
_swigc__p_API,
_swigc__p_CoreSession,
_swigc__p_Event,
+ _swigc__p_PerlInterpreter,
_swigc__p_Session,
_swigc__p_Stream,
_swigc__p_char,
_swigc__p_switch_input_args_t,
_swigc__p_switch_input_type_t,
_swigc__p_switch_priority_t,
+ _swigc__p_switch_size_t,
_swigc__p_switch_status_t,
_swigc__p_switch_stream_handle_t,
_swigc__p_void,
{"freeswitchc::Session_end_allow_threads", _wrap_Session_end_allow_threads},
{"freeswitchc::Session_check_hangup_hook", _wrap_Session_check_hangup_hook},
{"freeswitchc::Session_run_dtmf_callback", _wrap_Session_run_dtmf_callback},
+{"freeswitchc::Session_setInputCallback", _wrap_Session_setInputCallback},
+{"freeswitchc::Session_setHangupHook", _wrap_Session_setHangupHook},
+{"freeswitchc::Session_ready", _wrap_Session_ready},
+{"freeswitchc::Session_cb_function_set", _wrap_Session_cb_function_set},
+{"freeswitchc::Session_cb_function_get", _wrap_Session_cb_function_get},
+{"freeswitchc::Session_cb_arg_set", _wrap_Session_cb_arg_set},
+{"freeswitchc::Session_cb_arg_get", _wrap_Session_cb_arg_get},
+{"freeswitchc::Session_hangup_func_str_set", _wrap_Session_hangup_func_str_set},
+{"freeswitchc::Session_hangup_func_str_get", _wrap_Session_hangup_func_str_get},
+{"freeswitchc::Session_setPERL", _wrap_Session_setPERL},
{0,0}
};
/* -----------------------------------------------------------------------------
XSRETURN(1);
}
+#include "mod_perl_extra.c"
projects / thirdparty / freeswitch.git / commitdiff
