[Freeswitch-svn] [commit] r8241 - freeswitch/trunk/src/mod/languages/mod_perl

Freeswitch SVN anthm at freeswitch.org
Thu May 1 18:56:15 EDT 2008


Author: anthm
Date: Thu May  1 18:56:14 2008
New Revision: 8241

Added:
   freeswitch/trunk/src/mod/languages/mod_perl/hack.diff
   freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_extra.c
   freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_extra.h
Modified:
   freeswitch/trunk/src/mod/languages/mod_perl/Makefile
   freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm
   freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.cpp
   freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.h
   freeswitch/trunk/src/mod/languages/mod_perl/mod_perl.c
   freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp

Log:
adding callback stuff, still gotta test it

Modified: freeswitch/trunk/src/mod/languages/mod_perl/Makefile
==============================================================================
--- freeswitch/trunk/src/mod/languages/mod_perl/Makefile	(original)
+++ freeswitch/trunk/src/mod/languages/mod_perl/Makefile	Thu May  1 18:56:14 2008
@@ -15,6 +15,10 @@
 
 mod_perl_wrap.cpp:
 	swig -static -shadow -perl5 -c++ -DMULTIPLICITY -I../../../../src/include -o mod_perl_wrap.cpp freeswitch.i
+	echo "#include \"mod_perl_extra.c\"" >> mod_perl_wrap.cpp
+	patch -s -p0 -i hack.diff
+
+
 
 freeswitch.$(DYNAMIC_LIB_EXTEN): $(LOCAL_OBJS) $(LOCAL_LIBADD)
 	$(LINK) $(SOLINK) -o freeswitch.$(DYNAMIC_LIB_EXTEN)  $(LOCAL_OBJS) $(LOCAL_LIBADD) $(LDFLAGS)

Modified: freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm
==============================================================================
--- freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm	(original)
+++ freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm	Thu May  1 18:56:14 2008
@@ -333,6 +333,16 @@
 *end_allow_threads = *freeswitchc::Session_end_allow_threads;
 *check_hangup_hook = *freeswitchc::Session_check_hangup_hook;
 *run_dtmf_callback = *freeswitchc::Session_run_dtmf_callback;
+*setInputCallback = *freeswitchc::Session_setInputCallback;
+*setHangupHook = *freeswitchc::Session_setHangupHook;
+*ready = *freeswitchc::Session_ready;
+*swig_cb_function_get = *freeswitchc::Session_cb_function_get;
+*swig_cb_function_set = *freeswitchc::Session_cb_function_set;
+*swig_cb_arg_get = *freeswitchc::Session_cb_arg_get;
+*swig_cb_arg_set = *freeswitchc::Session_cb_arg_set;
+*swig_hangup_func_str_get = *freeswitchc::Session_hangup_func_str_get;
+*swig_hangup_func_str_set = *freeswitchc::Session_hangup_func_str_set;
+*setPERL = *freeswitchc::Session_setPERL;
 sub DISOWN {
     my $self = shift;
     my $ptr = tied(%$self);

Modified: freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.cpp
==============================================================================
--- freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.cpp	(original)
+++ freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.cpp	Thu May  1 18:56:14 2008
@@ -1,85 +1,206 @@
+#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 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() {}
+	if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) {
+		if (coresession->hook_state != state) {
+			coresession->hook_state = state;
+			coresession->check_hangup_hook();
+		}
+	}
 
-#endif
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+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;
+}

Modified: freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.h
==============================================================================
--- freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.h	(original)
+++ freeswitch/trunk/src/mod/languages/mod_perl/freeswitch_perl.h	Thu May  1 18:56:14 2008
@@ -1,22 +1,48 @@
-#ifndef FREESWITCH_PYTHON_H
-#define FREESWITCH_PYTHON_H
+#ifndef FREESWITCH_LUA_H
+#define FREESWITCH_LUA_H
 
-#include <switch_cpp.h>
+extern "C" {
+#ifdef __ICC
+#pragma warning (disable:1419)
+#endif
+#ifdef _MSC_VER
+#include <perlibs.h>
+#pragma comment(lib, PERL_LIB)
+#endif
+
+#include <EXTERN.h>
+#include <perl.h>
+#include <switch.h>
+}
 
+#include <switch_cpp.h>
 
 class Session : public CoreSession {
  private:
+	virtual void do_hangup_hook();
+	PerlInterpreter *getPERL();
+	PerlInterpreter *my_perl;
+	int hh;
+	int mark;
  public:
     Session();
     Session(char *uuid);
     Session(switch_core_session_t *session);
     ~Session();        
-
+	
 	virtual bool begin_allow_threads();
 	virtual bool end_allow_threads();
 	virtual void check_hangup_hook();
-	virtual switch_status_t run_dtmf_callback(void *input, switch_input_type_t itype);
 
+	virtual switch_status_t run_dtmf_callback(void *input, switch_input_type_t itype);
+	void setInputCallback(char *cbfunc, char *funcargs);
+	void setHangupHook(char *func);
+	bool ready();
+	
+	char *cb_function;
+	char *cb_arg;
+	char *hangup_func_str;
+	void setPERL(PerlInterpreter *pi);
 };
 
 #endif

Added: freeswitch/trunk/src/mod/languages/mod_perl/hack.diff
==============================================================================
--- (empty file)
+++ freeswitch/trunk/src/mod/languages/mod_perl/hack.diff	Thu May  1 18:56:14 2008
@@ -0,0 +1,30 @@
+--- mod_perl_wrap.cpp	2008-05-01 18:05:28.000000000 -0400
++++ old.cpp	2008-05-01 18:05:51.000000000 -0400
+
+@@ -6293,7 +6293,7 @@
+     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:
+@@ -6320,7 +6320,7 @@
+       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);
+@@ -6348,7 +6348,7 @@
+       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);

Modified: freeswitch/trunk/src/mod/languages/mod_perl/mod_perl.c
==============================================================================
--- freeswitch/trunk/src/mod/languages/mod_perl/mod_perl.c	(original)
+++ freeswitch/trunk/src/mod/languages/mod_perl/mod_perl.c	Thu May  1 18:56:14 2008
@@ -56,19 +56,87 @@
 	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);
@@ -83,6 +151,7 @@
 	return my_perl;
 }
 
+#if 0
 static perl_parse_and_execute (PerlInterpreter *my_perl, char *input_code, char *setup_code)
 {
 	int error = 0;
@@ -90,8 +159,8 @@
 	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 };
@@ -102,7 +171,7 @@
 		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);
 				}
 			}
@@ -115,13 +184,17 @@
 
 	}
 }
+#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"
@@ -133,15 +206,14 @@
 			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");
@@ -149,28 +221,71 @@
 	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);
 
-	perl_parse_and_execute(my_perl, input_code, code);
+	if (uuid) {
+		switch_snprintf(code, sizeof(code), "$session = new freeswitch::Session(\"%s\")", uuid);
+		Perl_safe_eval(my_perl, 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;
 }
 
@@ -178,11 +293,17 @@
 {
 	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;
 }
@@ -195,51 +316,11 @@
 
 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, 
@@ -326,7 +407,7 @@
 						,
 						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);

Added: freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_extra.c
==============================================================================
--- (empty file)
+++ freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_extra.c	Thu May  1 18:56:14 2008
@@ -0,0 +1,27 @@
+SWITCH_BEGIN_EXTERN_C
+
+
+void mod_perl_conjure_event(PerlInterpreter *my_perl, switch_event_t *event, const char *name)
+{
+    Event *result = 0 ;
+	SV *sv;
+	PERL_SET_CONTEXT(my_perl);
+	sv =  sv_2mortal(get_sv(name, TRUE));
+	result = (Event *)new Event(event);
+	SWIG_Perl_MakePtr(sv, result, SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW);
+}
+
+
+void mod_perl_conjure_stream(PerlInterpreter *my_perl, switch_stream_handle_t *stream, const char *name)
+{
+    Stream *result = 0 ;
+	SV *sv;
+	PERL_SET_CONTEXT(my_perl);
+	sv =  sv_2mortal(get_sv(name, TRUE));
+	result = (Stream *)new Stream(stream);
+	SWIG_Perl_MakePtr(sv, result, SWIGTYPE_p_Stream, SWIG_OWNER | SWIG_SHADOW);
+}
+
+
+
+SWITCH_END_EXTERN_C

Added: freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_extra.h
==============================================================================
--- (empty file)
+++ freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_extra.h	Thu May  1 18:56:14 2008
@@ -0,0 +1,9 @@
+#ifndef MOD_PERL_EXTRA
+#define MOD_PERL_EXTRA
+SWITCH_BEGIN_EXTERN_C
+
+void mod_perl_conjure_event(PerlInterpreter *my_perl, switch_event_t *event, const char *name);
+void mod_perl_conjure_stream(PerlInterpreter *my_perl, switch_stream_handle_t *stream, const char *name);
+
+SWITCH_END_EXTERN_C
+#endif

Modified: freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp
==============================================================================
--- freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp	(original)
+++ freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp	Thu May  1 18:56:14 2008
@@ -1449,23 +1449,25 @@
 #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)
 
@@ -5222,15 +5224,15 @@
 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 ;
@@ -5250,11 +5252,17 @@
       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 *""'");
@@ -5273,14 +5281,12 @@
     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;
     
@@ -6288,7 +6294,7 @@
     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:
@@ -6315,7 +6321,7 @@
       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);
@@ -6343,7 +6349,7 @@
       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);
@@ -6586,6 +6592,374 @@
 }
 
 
+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) -------- */
 
@@ -6595,6 +6969,7 @@
 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};
@@ -6607,6 +6982,7 @@
 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};
@@ -6615,6 +6991,7 @@
   &_swigt__p_API,
   &_swigt__p_CoreSession,
   &_swigt__p_Event,
+  &_swigt__p_PerlInterpreter,
   &_swigt__p_Session,
   &_swigt__p_Stream,
   &_swigt__p_char,
@@ -6627,6 +7004,7 @@
   &_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,
@@ -6635,6 +7013,7 @@
 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}};
@@ -6647,6 +7026,7 @@
 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}};
@@ -6655,6 +7035,7 @@
   _swigc__p_API,
   _swigc__p_CoreSession,
   _swigc__p_Event,
+  _swigc__p_PerlInterpreter,
   _swigc__p_Session,
   _swigc__p_Stream,
   _swigc__p_char,
@@ -6667,6 +7048,7 @@
   _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,
@@ -6777,6 +7159,16 @@
 {"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}
 };
 /* -----------------------------------------------------------------------------
@@ -7096,3 +7488,4 @@
   XSRETURN(1);
 }
 
+#include "mod_perl_extra.c"



More information about the Freeswitch-svn mailing list