[Freeswitch-svn] [commit] r2769 - in freeswitch/branches/mishehu/src: . dotnet dotnet/Marshaling dotnet/Marshaling/Types dotnet/Switch dotnet/Types include mod/applications/mod_commands mod/endpoints/mod_iax mod/endpoints/mod_sofia mod/endpoints/mod_wanpipe mod/event_handlers/mod_cdr mod/event_handlers/mod_event_socket mod/languages/mod_perl mod/languages/mod_php mod/languages/mod_python mod/languages/mod_ruby

Freeswitch SVN mishehu at freeswitch.org
Wed Sep 20 19:16:26 EDT 2006


Author: mishehu
Date: Wed Sep 20 19:16:25 2006
New Revision: 2769

Added:
   freeswitch/branches/mishehu/src/dotnet/Ivr.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Ivr.cs
   freeswitch/branches/mishehu/src/dotnet/Log.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Log.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/CodecMarshaler.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/CodecMarshaler.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/SpeechHandleMarshaler.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/SpeechHandleMarshaler.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/StateHandlerTableMarshaler.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/StateHandlerTableMarshaler.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/TimerMarshaler.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/TimerMarshaler.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/SpeechHandleMarshal.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/Types/SpeechHandleMarshal.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/StateHandlerTableMarshal.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/Types/StateHandlerTableMarshal.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/TimerMarshal.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Marshaling/Types/TimerMarshal.cs
   freeswitch/branches/mishehu/src/dotnet/Switch/Event.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Switch/Event.cs
   freeswitch/branches/mishehu/src/dotnet/Switch/Log.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Switch/Log.cs
   freeswitch/branches/mishehu/src/dotnet/Types/Codec.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/Codec.cs
   freeswitch/branches/mishehu/src/dotnet/Types/EventCallback.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/EventCallback.cs
   freeswitch/branches/mishehu/src/dotnet/Types/EventType.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/EventType.cs
   freeswitch/branches/mishehu/src/dotnet/Types/LogLevel.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/LogLevel.cs
   freeswitch/branches/mishehu/src/dotnet/Types/SpeechHandle.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/SpeechHandle.cs
   freeswitch/branches/mishehu/src/dotnet/Types/StateHandlerTable.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/StateHandlerTable.cs
   freeswitch/branches/mishehu/src/dotnet/Types/Timer.cs
      - copied unchanged from r2768, /freeswitch/trunk/src/dotnet/Types/Timer.cs
   freeswitch/branches/mishehu/src/switch_swig.c
      - copied unchanged from r2768, /freeswitch/trunk/src/switch_swig.c
   freeswitch/branches/mishehu/src/switch_swig.i
      - copied unchanged from r2768, /freeswitch/trunk/src/switch_swig.i
Removed:
   freeswitch/branches/mishehu/src/mod/languages/mod_perl/switch_swig.c
   freeswitch/branches/mishehu/src/mod/languages/mod_perl/switch_swig.i
   freeswitch/branches/mishehu/src/mod/languages/mod_php/switch_swig.c
   freeswitch/branches/mishehu/src/mod/languages/mod_php/switch_swig.i
   freeswitch/branches/mishehu/src/mod/languages/mod_python/switch_swig.c
   freeswitch/branches/mishehu/src/mod/languages/mod_python/switch_swig.i
   freeswitch/branches/mishehu/src/mod/languages/mod_ruby/switch_swig.c
Modified:
   freeswitch/branches/mishehu/src/dotnet/Common.cs
   freeswitch/branches/mishehu/src/dotnet/FreeSwitch.NET.csproj
   freeswitch/branches/mishehu/src/dotnet/Makefile
   freeswitch/branches/mishehu/src/dotnet/Marshaling/CoreSessionMarshaler.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/CodecMarshal.cs
   freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/StreamHandleMarshal.cs
   freeswitch/branches/mishehu/src/dotnet/Module.cs
   freeswitch/branches/mishehu/src/dotnet/Switch/Channel.cs
   freeswitch/branches/mishehu/src/dotnet/Switch/Ivr.cs
   freeswitch/branches/mishehu/src/dotnet/Types/Channel.cs
   freeswitch/branches/mishehu/src/dotnet/Types/CoreSession.cs
   freeswitch/branches/mishehu/src/dotnet/Types/Event.cs
   freeswitch/branches/mishehu/src/dotnet/Types/InputCallbackFunction.cs
   freeswitch/branches/mishehu/src/dotnet/Types/LoadableModuleInterface.cs
   freeswitch/branches/mishehu/src/dotnet/Types/Module.cs
   freeswitch/branches/mishehu/src/dotnet/Types/StreamHandle.cs
   freeswitch/branches/mishehu/src/include/switch_channel.h
   freeswitch/branches/mishehu/src/include/switch_core.h
   freeswitch/branches/mishehu/src/include/switch_ivr.h
   freeswitch/branches/mishehu/src/include/switch_types.h
   freeswitch/branches/mishehu/src/mod/applications/mod_commands/mod_commands.c
   freeswitch/branches/mishehu/src/mod/endpoints/mod_iax/mod_iax.c
   freeswitch/branches/mishehu/src/mod/endpoints/mod_sofia/mod_sofia.c
   freeswitch/branches/mishehu/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c
   freeswitch/branches/mishehu/src/mod/event_handlers/mod_cdr/schema.sql
   freeswitch/branches/mishehu/src/mod/event_handlers/mod_event_socket/mod_event_socket.c
   freeswitch/branches/mishehu/src/mod/languages/mod_perl/Makefile
   freeswitch/branches/mishehu/src/mod/languages/mod_perl/fs_perl.pm
   freeswitch/branches/mishehu/src/mod/languages/mod_perl/switch_swig_wrap.c
   freeswitch/branches/mishehu/src/mod/languages/mod_php/Makefile
   freeswitch/branches/mishehu/src/mod/languages/mod_python/Makefile
   freeswitch/branches/mishehu/src/mod/languages/mod_ruby/Makefile
   freeswitch/branches/mishehu/src/mod/languages/mod_ruby/mod_ruby.c
   freeswitch/branches/mishehu/src/switch.c
   freeswitch/branches/mishehu/src/switch_buffer.c
   freeswitch/branches/mishehu/src/switch_channel.c
   freeswitch/branches/mishehu/src/switch_console.c
   freeswitch/branches/mishehu/src/switch_core.c
   freeswitch/branches/mishehu/src/switch_ivr.c
   freeswitch/branches/mishehu/src/switch_rtp.c

Log:
Made a minor fix to schema.sql, merged to trunk r2768.

Modified: freeswitch/branches/mishehu/src/dotnet/Common.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Common.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Common.cs	Wed Sep 20 19:16:25 2006
@@ -32,7 +32,7 @@
 using System;
 using System.Reflection;
 
-namespace FreeSwitch.NET
+namespace FreeSwitch
 {
     public class Common
     {

Modified: freeswitch/branches/mishehu/src/dotnet/FreeSwitch.NET.csproj
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/FreeSwitch.NET.csproj	(original)
+++ freeswitch/branches/mishehu/src/dotnet/FreeSwitch.NET.csproj	Wed Sep 20 19:16:25 2006
@@ -7,8 +7,8 @@
     <ProjectGuid>{251CAABC-16C3-4593-A491-603B908094E0}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>FreeSwitch.NET</RootNamespace>
-    <AssemblyName>Freeswitch</AssemblyName>
+    <RootNamespace>FreeSwitch</RootNamespace>
+    <AssemblyName>FreeSwitch.NET</AssemblyName>
     <StartupObject>
     </StartupObject>
     <SignAssembly>true</SignAssembly>
@@ -42,11 +42,17 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Common.cs" />
+    <Compile Include="Log.cs" />
+    <Compile Include="Ivr.cs" />
     <Compile Include="Marshaling\BufferMarshaler.cs" />
     <Compile Include="Marshaling\CallerExtensionMarshaler.cs" />
     <Compile Include="Marshaling\CallerProfileMarshaler.cs" />
     <Compile Include="Marshaling\ChannelMarshaler.cs" />
     <Compile Include="Marshaling\ChannelTimetableMarshaler.cs" />
+    <Compile Include="Marshaling\CodecMarshaler.cs" />
+    <Compile Include="Marshaling\StateHandlerTableMarshaler.cs" />
+    <Compile Include="Marshaling\TimerMarshaler.cs" />
+    <Compile Include="Marshaling\SpeechHandleMarshaler.cs" />
     <Compile Include="Marshaling\StreamHandleMarshaler.cs" />
     <Compile Include="Marshaling\CoreSessionMarshaler.cs" />
     <Compile Include="Marshaling\EventMarshaler.cs" />
@@ -65,6 +71,9 @@
     <Compile Include="Marshaling\Types\CodecInterfaceMarshal.cs" />
     <Compile Include="Marshaling\Types\CodecMarshal.cs" />
     <Compile Include="Marshaling\Types\CodecTypeMarshal.cs" />
+    <Compile Include="Marshaling\Types\StateHandlerTableMarshal.cs" />
+    <Compile Include="Marshaling\Types\TimerMarshal.cs" />
+    <Compile Include="Marshaling\Types\SpeechHandleMarshal.cs" />
     <Compile Include="Marshaling\Types\StreamHandleMarshal.cs" />
     <Compile Include="Marshaling\Types\TypesMarshal.cs" />
     <Compile Include="Marshaling\Types\FileHandleMarshal.cs" />
@@ -79,6 +88,8 @@
     <Compile Include="Switch\CallerProfile.cs" />
     <Compile Include="Switch\Channel.cs" />
     <Compile Include="Switch\Console.cs" />
+    <Compile Include="Switch\Log.cs" />
+    <Compile Include="Switch\Event.cs" />
     <Compile Include="Switch\StreamHandle.cs" />
     <Compile Include="Switch\CoreSession.cs" />
     <Compile Include="Switch\Ivr.cs" />
@@ -96,6 +107,13 @@
     <Compile Include="Modules\Application.cs" />
     <Compile Include="Types\ApplicationFunction.cs" />
     <Compile Include="Types\CallCause.cs" />
+    <Compile Include="Types\Codec.cs" />
+    <Compile Include="Types\LogLevel.cs" />
+    <Compile Include="Types\StateHandlerTable.cs" />
+    <Compile Include="Types\Timer.cs" />
+    <Compile Include="Types\SpeechHandle.cs" />
+    <Compile Include="Types\EventCallback.cs" />
+    <Compile Include="Types\EventType.cs" />
     <Compile Include="Types\InputCallbackFunction.cs" />
     <Compile Include="Types\InputType.cs" />
     <Compile Include="Types\ModuleInterfaces.cs" />

Modified: freeswitch/branches/mishehu/src/dotnet/Makefile
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Makefile	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Makefile	Wed Sep 20 19:16:25 2006
@@ -2,7 +2,7 @@
 
 $(MODNAME).so:
 	/usr/local/freeswitch/bin/gmcs -debug -unsafe -t:library -keyfile:public.snk \
-	-out:FreeSwitch.dll -reference:Mono.Posix.dll \
+	-out:FreeSwitch.NET.dll -reference:Mono.Posix.dll \
 	Properties/AssemblyInfo.cs \
 	Marshaling/Types/ApiInterfaceMarshal.cs \
 	Marshaling/Types/ApplicationInterfaceMarshal.cs \
@@ -24,26 +24,35 @@
 	Marshaling/Types/IOEventHooksMarshal.cs \
 	Marshaling/Types/LoadableModuleInterfaceMarshal.cs \
 	Marshaling/Types/LoadableModuleMarshal.cs \
+	Marshaling/Types/SpeechHandleMarshal.cs \
+	Marshaling/Types/StateHandlerTableMarshal.cs \
 	Marshaling/Types/StreamHandleMarshal.cs \
 	Marshaling/Types/TypesMarshal.cs \
+	Marshaling/Types/TimerMarshal.cs \
 	Marshaling/BufferMarshaler.cs \
 	Marshaling/CallerExtensionMarshaler.cs \
 	Marshaling/CallerProfileMarshaler.cs \
 	Marshaling/ChannelMarshaler.cs \
 	Marshaling/ChannelTimetableMarshaler.cs \
+	Marshaling/CodecMarshaler.cs \
 	Marshaling/CoreSessionMarshaler.cs \
 	Marshaling/EventMarshaler.cs \
 	Marshaling/FileHandleMarshaler.cs \
 	Marshaling/MemoryPoolMarshaler.cs \
+	Marshaling/SpeechHandleMarshaler.cs \
+	Marshaling/StateHandlerTableMarshaler.cs \
 	Marshaling/StreamHandleMarshaler.cs \
+	Marshaling/TimerMarshaler.cs \
 	Modules/Api.cs \
 	Modules/Application.cs \
 	Switch/CallerProfile.cs \
 	Switch/Channel.cs \
 	Switch/Console.cs \
 	Switch/CoreSession.cs \
+	Switch/Event.cs \
 	Switch/Ivr.cs \
 	Switch/LoadableModule.cs \
+	Switch/Log.cs \
 	Switch/StreamHandle.cs \
 	Types/ApiFunction.cs \
 	Types/ApplicationFunction.cs \
@@ -56,24 +65,33 @@
 	Types/ChannelFlag.cs \
 	Types/ChannelState.cs \
 	Types/ChannelTimetable.cs \
+	Types/Codec.cs \
 	Types/CoreSession.cs \
 	Types/DtmfCallbackFunction.cs \
 	Types/InputCallbackFunction.cs \
 	Types/InputType.cs \
 	Types/Event.cs \
+	Types/EventCallback.cs \
+	Types/EventType.cs \
 	Types/FileHandle.cs \
 	Types/LoadableModule.cs \
 	Types/LoadableModuleInterface.cs \
+	Types/LogLevel.cs \
 	Types/MemoryPool.cs \
 	Types/Module.cs \
 	Types/Status.cs \
+	Types/SpeechHandle.cs \
+	Types/StateHandlerTable.cs \
 	Types/StreamHandle.cs \
 	Types/TextChannel.cs \
+	Types/Timer.cs \
 	Common.cs \
 	Module.cs \
+	Ivr.cs \
+	Log.cs \
 	
 clean:
 	rm -fr *.dll
 
 install:
-	cp -f FreeSwitch.dll /usr/local/freeswitch/lib/
+	cp -f FreeSwitch.NET.dll /usr/local/freeswitch/lib/

Modified: freeswitch/branches/mishehu/src/dotnet/Marshaling/CoreSessionMarshaler.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Marshaling/CoreSessionMarshaler.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Marshaling/CoreSessionMarshaler.cs	Wed Sep 20 19:16:25 2006
@@ -61,14 +61,36 @@
         public IntPtr MarshalManagedToNative(object obj)
         {
             CoreSession coreSession = (CoreSession)obj;
-            
-            return coreSession.marshaledObject.Handle;
+
+            Console.WriteLine("CoreSession: Marshalling Managed to Native");
+
+            if (coreSession.marshaledObject.Handle != IntPtr.Zero)
+            {
+
+                Console.WriteLine("Returning: 0x{0:x}", coreSession.marshaledObject.Handle.ToInt32());
+                return coreSession.marshaledObject.Handle;
+            }
+            else
+            {
+                CoreSessionMarshal coreSessionMarshal = new CoreSessionMarshal();
+                IntPtr coreSessionPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(CoreSessionMarshal)));
+
+                Marshal.StructureToPtr(coreSessionMarshal, coreSessionPtr, true);
+
+                coreSession.marshaledObject = new HandleRef(coreSessionMarshal, coreSessionPtr);
+
+                Console.WriteLine("CoreSession: NO OBJECT EXISTS OMG");
+                Console.WriteLine("Returning: 0x{0:x}", coreSession.marshaledObject.Handle.ToInt32());
+                return coreSession.marshaledObject.Handle;
+            }
         }
 
         public object MarshalNativeToManaged(IntPtr coreSessionPtr)
         {
             CoreSessionMarshal coreSessionMarshal = new CoreSessionMarshal();
             CoreSession        coreSession        = new CoreSession();
+
+            Console.WriteLine("CoreSession: Marshalling Native to Managed");
 
             Marshal.PtrToStructure(coreSessionPtr, coreSessionMarshal);
 

Modified: freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/CodecMarshal.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/CodecMarshal.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/CodecMarshal.cs	Wed Sep 20 19:16:25 2006
@@ -38,9 +38,9 @@
     {
         internal IntPtr codec_interface;
         internal IntPtr implementation;
-        //internal CodecSettingsMarshal codec_settings;
+        internal IntPtr codec_settings;
         internal UInt32 flags;
-        //internal MemoryPoolMarshal memory_pool;
+        internal IntPtr memory_pool;
         internal IntPtr private_info;
     }
 }

Modified: freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/StreamHandleMarshal.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/StreamHandleMarshal.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Marshaling/Types/StreamHandleMarshal.cs	Wed Sep 20 19:16:25 2006
@@ -43,6 +43,8 @@
         internal IntPtr end;
         internal int    data_size;
         internal int    data_len;
+        internal int    alloc_len;
+        internal int    alloc_chunk;
         internal IntPtr _event;
     }
 }

Modified: freeswitch/branches/mishehu/src/dotnet/Module.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Module.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Module.cs	Wed Sep 20 19:16:25 2006
@@ -34,12 +34,11 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text;
-using FreeSwitch.NET;
 using FreeSwitch.Types;
 using FreeSwitch.Modules;
 using FreeSwitch.Marshaling.Types;
 
-namespace FreeSwitch.NET
+namespace FreeSwitch
 {
     /// <summary>
     /// Base class for all Freeswitch.NET modules
@@ -92,20 +91,26 @@
             /* Set the module_name field of the LoadableModuleInterface */
             module_interface.module_name = Marshal.StringToHGlobalAnsi(filename);
 
-            /* Grab the first ApiInterface in our array and add a pointer to this in our ModuleInterface*/
-            Api apiIndex = (Api)apiInterfaces[0];
-            
-            module_interface.api_interface = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ApiInterfaceMarshal)));
-            
-            Marshal.StructureToPtr(apiIndex.handle.Wrapper, module_interface.api_interface, true);
-            
-            /* For each Application interface */
-            Application applicationIndex = (Application)applicationInterfaces[0];
-            
-            module_interface.application_interface = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ApplicationInterfaceMarshal)));
-            
-            Marshal.StructureToPtr(applicationIndex.handle.Wrapper, module_interface.application_interface, true);                
+            if (apiInterfaces.Count > 0)
+            {
+                /* Grab the first ApiInterface in our array and add a pointer to this in our ModuleInterface*/
+                Api apiIndex = (Api)apiInterfaces[0];
 
+                module_interface.api_interface = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ApiInterfaceMarshal)));
+
+                Marshal.StructureToPtr(apiIndex.handle.Wrapper, module_interface.api_interface, true);
+            }
+
+            if (applicationInterfaces.Count > 0)
+            {
+                /* For each Application interface */
+                Application applicationIndex = (Application)applicationInterfaces[0];
+
+                module_interface.application_interface = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ApplicationInterfaceMarshal)));
+
+                Marshal.StructureToPtr(applicationIndex.handle.Wrapper, module_interface.application_interface, true);
+            }
+
             /* Finally, marshal the moduleinterface class and return */
             Marshal.StructureToPtr(module_interface, module, true);
                         
@@ -200,6 +205,10 @@
                                                         module.module_shutdown);
         }
 
-        
+        public string Name
+        {
+            set { name = value; }
+            get { return name; }
+        }
 	}
 }	

Modified: freeswitch/branches/mishehu/src/dotnet/Switch/Channel.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Switch/Channel.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Switch/Channel.cs	Wed Sep 20 19:16:25 2006
@@ -85,6 +85,15 @@
                 Channel channel);
 
         [DllImport("freeswitch")]
+        [return: MarshalAs(UnmanagedType.LPStr)]
+        public extern static
+            string switch_channel_get_variable(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(ChannelMarshaler))]
+                Channel channel,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string varname);
+
+        [DllImport("freeswitch")]
         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CallerProfileMarshaler))]
         public extern static
             CallerProfile switch_channel_get_originator_caller_profile(

Modified: freeswitch/branches/mishehu/src/dotnet/Switch/Ivr.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Switch/Ivr.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Switch/Ivr.cs	Wed Sep 20 19:16:25 2006
@@ -41,11 +41,66 @@
     public partial class Switch
     {
         [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_sleep(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                UInt32 ms);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_park(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_collect_digits_callback(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                InputCallbackFunction dtmfCallback,
+                IntPtr buf,
+                uint buflen);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_collect_digits_count(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string buffer,
+                uint buflen,
+                uint maxdigits,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string terminators,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string terminator,
+                uint timeout);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_record_session(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string file,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileHandleMarshaler))]
+                FileHandle fh);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_stop_record_session(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string file);
+
+        [DllImport("freeswitch")]
         extern public static
             Status switch_ivr_play_file(
-                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CoreSessionMarshaler))]
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
                 CoreSession session,
-                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(FileHandleMarshaler))]
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileHandleMarshaler))]
                 FileHandle fh,
                 [MarshalAs(UnmanagedType.LPStr)]
                 string file,
@@ -57,26 +112,91 @@
 
         [DllImport("freeswitch")]
         public extern static
+            Status switch_ivr_record_file(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileHandleMarshaler))]
+                FileHandle fh,
+                IntPtr file,
+                InputCallbackFunction input_callback,
+                IntPtr buf,
+                uint buflen);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_speak_text_handle(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(SpeechHandleMarshaler))]
+                SpeechHandle sh,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CodecMarshaler))]
+                Codec codec,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(TimerMarshaler))]
+                Timer timer,
+                InputCallbackFunction dtmfCallback,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string text,
+                IntPtr buf,
+                uint buflen);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_speak_text(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string tts_name,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string voice_name,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string timer_name,
+                uint rate,
+                InputCallbackFunction dtmfCallback,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string text,
+                IntPtr buf,
+                uint buflen);
+
+        [DllImport("freeswitch")]
+        public extern static
+            Status switch_ivr_originate(
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                CoreSession session,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+                ref CoreSession bleg,
+                IntPtr cause,
+                IntPtr bridgeto,
+                UInt32 timelimit_sec,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(StateHandlerTableMarshaler))]
+                StateHandlerTable table,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string cid_name_override,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string cid_num_override,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CallerProfileMarshaler))]
+                CallerProfile caller_profile_override);
+
+        [DllImport("freeswitch")]
+        public extern static
             Status switch_ivr_multi_threaded_bridge(
                 [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
                 CoreSession session,
                 [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
                 CoreSession peer_session,
-                uint timelimit,
-                IntPtr dtmf_callback,
+                InputCallbackFunction dtmfCallback,
                 IntPtr session_data,
                 IntPtr peer_session_data);
 
         [DllImport("freeswitch")]
         public extern static
-            Status switch_ivr_record_file(
+            Status switch_ivr_session_transfer(
                 [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
                 CoreSession session,
-                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileHandleMarshaler))]
-                FileHandle fh,
-                IntPtr file,
-                InputCallbackFunction input_callback,
-                IntPtr buf,
-                uint buflen);
+                [MarshalAs(UnmanagedType.LPStr)]
+                string extension,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string dialplan,
+                [MarshalAs(UnmanagedType.LPStr)]
+                string context);
     }
 }

Modified: freeswitch/branches/mishehu/src/dotnet/Types/Channel.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/Channel.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/Channel.cs	Wed Sep 20 19:16:25 2006
@@ -219,5 +219,15 @@
         {
             return Switch.switch_channel_answer(this);
         }
+
+        public ChannelState Hangup(CallCause cause)
+        {
+            return Switch.switch_channel_perform_hangup(this, "file", "func", 666, cause);
+        }
+
+        public string GetVariable(string varname)
+        {
+            return Switch.switch_channel_get_variable(this, varname);
+        }
     }
 }

Modified: freeswitch/branches/mishehu/src/dotnet/Types/CoreSession.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/CoreSession.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/CoreSession.cs	Wed Sep 20 19:16:25 2006
@@ -109,7 +109,7 @@
             get
             {
                 CoreSessionMarshal coreSessionMarshal = (CoreSessionMarshal)marshaledObject.Wrapper;
-
+                 
                 if (coreSessionMarshal.thread_running <= 0)
                     return false;
                 else

Modified: freeswitch/branches/mishehu/src/dotnet/Types/Event.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/Event.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/Event.cs	Wed Sep 20 19:16:25 2006
@@ -101,20 +101,4 @@
         public string Name;
         public string Value;
     }
-
-    public enum EventType
-    {
-        SWITCH_EVENT_CUSTOM,
-        SWITCH_EVENT_CHANNEL_STATE,
-        SWITCH_EVENT_CHANNEL_ANSWER,
-        SWITCH_EVENT_CHANNEL_HANGUP,
-        SWITCH_EVENT_API,
-        SWITCH_EVENT_LOG,
-        SWITCH_EVENT_INBOUND_CHAN,
-        SWITCH_EVENT_OUTBOUND_CHAN,
-        SWITCH_EVENT_STARTUP,
-        SWITCH_EVENT_SHUTDOWN,
-        SWITCH_EVENT_ALL
-    }
-
 }

Modified: freeswitch/branches/mishehu/src/dotnet/Types/InputCallbackFunction.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/InputCallbackFunction.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/InputCallbackFunction.cs	Wed Sep 20 19:16:25 2006
@@ -36,7 +36,7 @@
 namespace FreeSwitch.Types
 {
     public delegate Status InputCallbackFunction(
-        [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StreamHandleMarshaler))]
+        [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CoreSessionMarshaler))]
         CoreSession session,
         [MarshalAs(UnmanagedType.LPStr)]
         string input,

Modified: freeswitch/branches/mishehu/src/dotnet/Types/LoadableModuleInterface.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/LoadableModuleInterface.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/LoadableModuleInterface.cs	Wed Sep 20 19:16:25 2006
@@ -37,11 +37,7 @@
 
 namespace FreeSwitch.Types
 {
-    public delegate Status WriteFunction(
-        [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StreamHandleMarshaler))]
-        StreamHandle streamHandle,
-        [MarshalAs(UnmanagedType.LPStr)]
-        string fmt);
+
 
     //public delegate void ModuleLoad();
 

Modified: freeswitch/branches/mishehu/src/dotnet/Types/Module.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/Module.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/Module.cs	Wed Sep 20 19:16:25 2006
@@ -49,11 +49,13 @@
             CoreSession session,
             [MarshalAs(UnmanagedType.LPStr)]
             string data);
-
+    
     public delegate Status
         ApiFunction(
             [MarshalAs(UnmanagedType.LPStr)]
-            string command,
+            string input,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(CoreSessionMarshaler))]
+            CoreSession session,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(StreamHandleMarshaler))]
             StreamHandle streamHandle);
 }

Modified: freeswitch/branches/mishehu/src/dotnet/Types/StreamHandle.cs
==============================================================================
--- freeswitch/branches/mishehu/src/dotnet/Types/StreamHandle.cs	(original)
+++ freeswitch/branches/mishehu/src/dotnet/Types/StreamHandle.cs	Wed Sep 20 19:16:25 2006
@@ -30,20 +30,26 @@
  *
  */
 using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
+using FreeSwitch.Marshaling;
 using FreeSwitch.Marshaling.Types;
 
 namespace FreeSwitch.Types
-{
+{
+    public delegate Status StreamHandleWriteFunction(
+        [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(StreamHandleMarshaler))]
+        StreamHandle streamHandle,
+        [MarshalAs(UnmanagedType.LPStr)]
+        string fmt);
+
     public class StreamHandle
     {
         internal HandleRef     marshaledObject;
-        internal WriteFunction writeFunction;
 
         public void Write(string data)
         {
             StreamHandleMarshal streamHandleMarshal = (StreamHandleMarshal)marshaledObject.Wrapper;
-            WriteFunction       writeFunction       = (WriteFunction)Marshal.GetDelegateForFunctionPointer(streamHandleMarshal.write_function, typeof(WriteFunction));
+            StreamHandleWriteFunction writeFunction = (StreamHandleWriteFunction)Marshal.GetDelegateForFunctionPointer(streamHandleMarshal.write_function, typeof(StreamHandleWriteFunction));
 
             writeFunction(this, data);
         }

Modified: freeswitch/branches/mishehu/src/include/switch_channel.h
==============================================================================
--- freeswitch/branches/mishehu/src/include/switch_channel.h	(original)
+++ freeswitch/branches/mishehu/src/include/switch_channel.h	Wed Sep 20 19:16:25 2006
@@ -71,7 +71,7 @@
   \param channel channel to test
   \return true if the channel is ready
 */
-SWITCH_DECLARE(unsigned int) switch_channel_ready(switch_channel_t *channel);
+SWITCH_DECLARE(uint8_t) switch_channel_ready(switch_channel_t *channel);
 
 
 SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_channel_t *channel,
@@ -246,6 +246,13 @@
   \param flags or'd list of flags to set
 */
 SWITCH_DECLARE(void) switch_channel_set_flag(switch_channel_t *channel, switch_channel_flag_t flags);
+
+/*!
+  \brief Set given flag(s) on a given channel to be applied on the next state change
+  \param channel channel on which to set flag(s)
+  \param flags or'd list of flags to set
+*/
+SWITCH_DECLARE(void) switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flags);
 
 /*!
   \brief Clear given flag(s) from a channel

Modified: freeswitch/branches/mishehu/src/include/switch_core.h
==============================================================================
--- freeswitch/branches/mishehu/src/include/switch_core.h	(original)
+++ freeswitch/branches/mishehu/src/include/switch_core.h	Wed Sep 20 19:16:25 2006
@@ -361,6 +361,12 @@
 SWITCH_DECLARE(void) switch_core_session_destroy(switch_core_session_t **session);
 
 /*! 
+  \brief Provide the total number of sessions
+  \return the total number of allocated sessions
+*/
+SWITCH_DECLARE(uint32_t) switch_core_session_count(void);
+
+/*! 
   \brief Allocate and return a new session from the core based on a given endpoint module name
   \param endpoint_name the name of the endpoint module
   \param pool the pool to use
@@ -403,8 +409,9 @@
 
 /*! 
   \brief Hangup All Sessions
+  \param cause the hangup cause to apply to the hungup channels
 */
-SWITCH_DECLARE(void) switch_core_session_hupall(void);
+SWITCH_DECLARE(void) switch_core_session_hupall(switch_call_cause_t cause);
 
 /*! 
   \brief Send a message to another session using it's uuid
@@ -1192,6 +1199,19 @@
 */
 SWITCH_DECLARE(FILE *) switch_core_data_channel(switch_text_channel_t channel);
 
+
+/*! 
+  \brief Set the maximum priority the process can obtain
+  \return 0 on success
+*/
+SWITCH_DECLARE(int32_t) set_high_priority(void);
+
+/*! 
+  \brief Run endlessly until the system is shutdown
+  \param bg divert console to the background
+*/
+SWITCH_DECLARE(void) switch_core_runtime_loop(int bg);
+
 /*!
   \brief Set the output console to the desired file
   \param console the file path
@@ -1210,6 +1230,14 @@
   \return a number of microseconds
 */
 SWITCH_DECLARE(switch_time_t) switch_core_uptime(void);
+
+/*!
+  \brief send a control message to the core
+  \param cmd the command
+  \param val the command arguement (if needed)
+  \return 0 on success nonzero on error
+*/
+SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, uint32_t *val);
 
 /*!
   \brief Get the output console

Modified: freeswitch/branches/mishehu/src/include/switch_ivr.h
==============================================================================
--- freeswitch/branches/mishehu/src/include/switch_ivr.h	(original)
+++ freeswitch/branches/mishehu/src/include/switch_ivr.h	Wed Sep 20 19:16:25 2006
@@ -233,6 +233,15 @@
 */
 SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_t *session, char *extension, char *dialplan, char *context);
 
+
+/*!
+  \brief Bridge two existing sessions
+  \param originator_uuid the uuid of the originator
+  \param originatee_uuid the uuid of the originator
+  \return SWITCH_STATUS_SUCCESS if all is well 
+*/
+SWITCH_DECLARE(switch_status_t) switch_ivr_uuid_bridge(char *originator_uuid, char *originatee_uuid);
+
 /** @} */
 
 SWITCH_END_EXTERN_C

Modified: freeswitch/branches/mishehu/src/include/switch_types.h
==============================================================================
--- freeswitch/branches/mishehu/src/include/switch_types.h	(original)
+++ freeswitch/branches/mishehu/src/include/switch_types.h	Wed Sep 20 19:16:25 2006
@@ -118,7 +118,7 @@
 typedef struct switch_directories switch_directories;
 SWITCH_DECLARE_DATA extern switch_directories SWITCH_GLOBAL_dirs;
 
-#define SWITCH_THREAD_STACKSIZE 384 * 1024
+#define SWITCH_THREAD_STACKSIZE 256 * 1024
 #define SWITCH_RECCOMMENDED_BUFFER_SIZE 2048
 #define SWITCH_MAX_CODECS 30
 #define SWITCH_MAX_STATE_HANDLERS 30
@@ -176,6 +176,7 @@
 	SWITCH_RTP_FLAG_VAD           - Enable VAD
 	SWITCH_RTP_FLAG_BREAK		  - Stop what you are doing and return SWITCH_STATUS_BREAK
 	SWITCH_RTP_FLAG_MINI		  - Use mini RTP when possible
+	SWITCH_RTP_FLAG_DATAWAIT	  - Do not return from reads unless there is data even when non blocking
 </pre>
  */
 typedef enum {
@@ -189,7 +190,8 @@
 	SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 7),
 	SWITCH_RTP_FLAG_VAD = (1 << 8),
 	SWITCH_RTP_FLAG_BREAK = ( 1 << 9),
-	SWITCH_RTP_FLAG_MINI = ( 1 << 10)
+	SWITCH_RTP_FLAG_MINI = ( 1 << 10),
+	SWITCH_RTP_FLAG_DATAWAIT = (1 << 11)
 } switch_rtp_flag_t;
 
 /*!
@@ -690,9 +692,16 @@
 	SWITCH_CAUSE_INTERWORKING = 127,
 	SWITCH_CAUSE_CRASH = 500,
 	SWITCH_CAUSE_SYSTEM_SHUTDOWN = 501,
-	SWITCH_CAUSE_LOSE_RACE = 502
+	SWITCH_CAUSE_LOSE_RACE = 502,
+	SWITCH_CAUSE_MANAGER_REQUEST = 503
 } switch_call_cause_t;
 
+typedef enum {
+	SCSC_PAUSE_INBOUND,
+	SCSC_HUPALL,
+	SCSC_SHUTDOWN,
+	SCSC_CHECK_RUNNING
+} switch_session_ctl_t;
 
 typedef uint8_t switch_payload_t;
 typedef struct switch_rtp switch_rtp_t;

Modified: freeswitch/branches/mishehu/src/mod/applications/mod_commands/mod_commands.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/applications/mod_commands/mod_commands.c	(original)
+++ freeswitch/branches/mishehu/src/mod/applications/mod_commands/mod_commands.c	Wed Sep 20 19:16:25 2006
@@ -39,6 +39,7 @@
 {
 	uint8_t html = 0;
 	switch_core_time_duration_t duration;
+	char *http = NULL;
 
 	if (session) {
 		return SWITCH_STATUS_FALSE;
@@ -46,7 +47,11 @@
 
 	switch_core_measure_time(switch_core_uptime(), &duration);
 
-	if (cmd && strstr(cmd, "html")) {
+	if (stream->event) {
+        http = switch_event_get_header(stream->event, "http-host");
+    }
+
+	if (http || (cmd && strstr(cmd, "html"))) {
 		html = 1;
 		stream->write_function(stream, "<h1>FreeSWITCH Status</h1>\n<b>");
 	}
@@ -61,6 +66,8 @@
 						   duration.mms, duration.mms == 1 ? "" : "s"
 						   );
 
+	stream->write_function(stream, "%d sessions\n", switch_core_session_count());
+	
 	if (html) {
 		stream->write_function(stream, "</b>\n");
 	}
@@ -80,6 +87,49 @@
 	return SWITCH_STATUS_SUCCESS;
 }
 
+static switch_status_t ctl_function(char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
+{
+	int argc;
+	char *mydata, *argv[5];
+	uint32_t arg = 0;
+
+	if (switch_strlen_zero(data)) {
+		stream->write_function(stream, "USAGE: fsctl [hupall|pause|resume|shutdown]\n");
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	if ((mydata = strdup(data))) {
+		argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+	
+		if (!strcmp(argv[0], "hupall")) {
+			arg = 1;
+			switch_core_session_ctl(SCSC_HUPALL, &arg);
+		} else if (!strcmp(argv[0], "pause")) {
+			arg = 1;
+			switch_core_session_ctl(SCSC_PAUSE_INBOUND, &arg);
+		} else if (!strcmp(argv[0], "resume")) {
+			arg = 0;
+			switch_core_session_ctl(SCSC_PAUSE_INBOUND, &arg);
+		} else if (!strcmp(argv[0], "shutdown")) {
+			arg = 0;
+			switch_core_session_ctl(SCSC_SHUTDOWN, &arg);
+		} else {
+			stream->write_function(stream, "INVALID COMMAND [%s]\n", argv[0]);
+			goto end;
+		} 
+
+		stream->write_function(stream, "OK\n");
+	end:
+		free(mydata);
+	} else {
+		stream->write_function(stream, "MEM ERR\n");
+	}
+
+    return SWITCH_STATUS_SUCCESS;
+	
+}
+
+
 static switch_status_t load_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
 {
 
@@ -119,7 +169,6 @@
 
 	if (dest && (session = switch_core_session_locate(dest))) {
 		switch_channel_t *channel = switch_core_session_get_channel(session);
-		switch_core_session_kill_channel(session, SWITCH_SIG_KILL);
 		switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
 		switch_core_session_rwunlock(session);
 		stream->write_function(stream, "OK\n");
@@ -171,7 +220,28 @@
 
 
 
+static switch_status_t uuid_bridge_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+{
+	char *argv[4] = {0};
+	int argc = 0;
 
+	if (isession) {
+		return SWITCH_STATUS_FALSE;
+	}
+	
+	argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+
+	if (argc != 2) {
+		stream->write_function(stream, "Invalid Parameters\nUsage: uuid_bridge <uuid> <other_uuid>\n");
+	} else {
+		switch_ivr_uuid_bridge(argv[0], argv[1]);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+
 static switch_status_t pause_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
 {
 	switch_core_session_t *session = NULL;
@@ -408,11 +478,26 @@
 }
 
 
+
+static switch_api_interface_t ctl_api_interface = {
+	/*.interface_name */ "fsctl",
+	/*.desc */ "control messages",
+	/*.function */ ctl_function,
+	/*.next */ 
+};
+
+static switch_api_interface_t uuid_bridge_api_interface = {
+	/*.interface_name */ "uuid_bridge",
+	/*.desc */ "uuid_bridge",
+	/*.function */ uuid_bridge_function,
+	/*.next */ &ctl_api_interface
+};
+
 static switch_api_interface_t status_api_interface = {
 	/*.interface_name */ "status",
 	/*.desc */ "status",
 	/*.function */ status_function,
-	/*.next */ NULL
+	/*.next */ &uuid_bridge_api_interface
 };
 
 static switch_api_interface_t show_api_interface = {

Modified: freeswitch/branches/mishehu/src/mod/endpoints/mod_iax/mod_iax.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/endpoints/mod_iax/mod_iax.c	(original)
+++ freeswitch/branches/mishehu/src/mod/endpoints/mod_iax/mod_iax.c	Wed Sep 20 19:16:25 2006
@@ -952,12 +952,10 @@
 			
 			if (globals.calls == 0) {
 				waitlen = 10000;
-			} else if (globals.calls == 1) {
-				waitlen = 1000;
 			} else if (globals.calls < 10) {
-				waitlen = 100;
+				waitlen = 1000;
 			} else {
-				waitlen = 10;
+				waitlen = 500;
 			}
 
 			switch_yield(waitlen);

Modified: freeswitch/branches/mishehu/src/mod/endpoints/mod_sofia/mod_sofia.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/endpoints/mod_sofia/mod_sofia.c	(original)
+++ freeswitch/branches/mishehu/src/mod/endpoints/mod_sofia/mod_sofia.c	Wed Sep 20 19:16:25 2006
@@ -601,21 +601,24 @@
 
 	su_home_deinit(tech_pvt->home);
 
-	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Channel %s hanging up, cause: %s, SIP response: %d\n", 
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Channel %s hanging up, cause: %s\n", 
 			  switch_channel_get_name(channel), switch_channel_cause2str(cause), sip_cause);
 
 	if (tech_pvt->nh) {
 		if (!switch_test_flag(tech_pvt, TFLAG_BYE)) {
 			if (switch_test_flag(tech_pvt, TFLAG_ANS)) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sending BYE\n");
 				nua_bye(tech_pvt->nh, TAG_END());
 			} else {
-				if (switch_test_flag(tech_pvt, TFLAG_INBOUND)) 
+				if (switch_test_flag(tech_pvt, TFLAG_INBOUND)) {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Responding to INVITE with: %d\n", sip_cause);
 					nua_respond(tech_pvt->nh, sip_cause, NULL, TAG_END());
-				else 
+				} else {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sending CANCEL\n");
 					nua_cancel(tech_pvt->nh, TAG_END());
+				}
 			}
 		}
-		nua_handle_bind(tech_pvt->nh, NULL);
 		nua_handle_destroy(tech_pvt->nh);
 		tech_pvt->nh = NULL;
 	}
@@ -727,7 +730,7 @@
 	bw = tech_pvt->read_codec.implementation->bits_per_second;
 	ms = tech_pvt->read_codec.implementation->microseconds_per_frame;
 
-	flags = (switch_rtp_flag_t) (SWITCH_RTP_FLAG_RAW_WRITE | SWITCH_RTP_FLAG_MINI | SWITCH_RTP_FLAG_AUTOADJ);
+	flags = (switch_rtp_flag_t) (SWITCH_RTP_FLAG_RAW_WRITE | SWITCH_RTP_FLAG_MINI | SWITCH_RTP_FLAG_AUTOADJ | SWITCH_RTP_FLAG_DATAWAIT);
 
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "RTP [%s] %s:%d->%s:%d codec: %u ms: %d\n",
 					  switch_channel_get_name(channel),
@@ -812,6 +815,7 @@
 	size_t bytes = 0, samples = 0, frames = 0, ms = 0;
 	switch_channel_t *channel = NULL;
 	int payload = 0;
+
 	//switch_time_t now, started = switch_time_now(), last_act = switch_time_now();
 	//unsigned int elapsed;
 	//uint32_t hard_timeout = 60000 * 3;
@@ -903,8 +907,6 @@
 				tech_pvt->read_frame.samples = (int) samples;
 				break;
 			}
-
-			switch_yield(1000);
 		}
 
 	} 
@@ -1466,6 +1468,7 @@
 							//SIPTAG_CONTACT(tech_pvt->contact), 
 							TAG_END());
 			} else if (switch_test_flag(tech_pvt, TFLAG_EARLY_MEDIA)) {
+				switch_set_flag_locked(tech_pvt, TFLAG_ANS);
 				switch_channel_set_variable(channel, "endpoint_disposition", "ANSWER");
 				switch_channel_answer(channel);
 				return;

Modified: freeswitch/branches/mishehu/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c	(original)
+++ freeswitch/branches/mishehu/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c	Wed Sep 20 19:16:25 2006
@@ -226,7 +226,7 @@
 {
 	struct private_object *tech_pvt;
 	switch_channel_t *channel = NULL;
-	wanpipe_tdm_api_t tdm_api = {};
+	wanpipe_tdm_api_t tdm_api = {0};
 	int err = 0;
 	int mtu_mru;
 	unsigned int rate = 8000;

Modified: freeswitch/branches/mishehu/src/mod/event_handlers/mod_cdr/schema.sql
==============================================================================
--- freeswitch/branches/mishehu/src/mod/event_handlers/mod_cdr/schema.sql	(original)
+++ freeswitch/branches/mishehu/src/mod/event_handlers/mod_cdr/schema.sql	Wed Sep 20 19:16:25 2006
@@ -19,7 +19,7 @@
 	billusec bigint default 0,
 	disposition tinyint default 0, /* 0 = Busy or Unanswered, 1 = Answered */
 	hangupcause int default 0,
-	amaflags tinyint default 0,
+	amaflags tinyint default 0
 );
 
 create index myuuid_index on freeswitchcdr (myuuid);

Modified: freeswitch/branches/mishehu/src/mod/event_handlers/mod_event_socket/mod_event_socket.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/event_handlers/mod_event_socket/mod_event_socket.c	(original)
+++ freeswitch/branches/mishehu/src/mod/event_handlers/mod_event_socket/mod_event_socket.c	Wed Sep 20 19:16:25 2006
@@ -636,7 +636,13 @@
 					switch_core_hash_insert_dup(listener->event_hash, cur, MARKER);
 				} else if (switch_name_event(cur, &type) == SWITCH_STATUS_SUCCESS) {
 					key_count++;
-					listener->event_list[(uint8_t)type] = 1;
+					if (type == SWITCH_EVENT_ALL) {
+						uint32_t x = 0;
+						for (x = 0; x < SWITCH_EVENT_ALL; x++) {
+							listener->event_list[x] = 0;
+						}
+					}
+					listener->event_list[type] = 1;
 					if (type == SWITCH_EVENT_CUSTOM) {
 						custom++;
 					}
@@ -657,6 +663,63 @@
 		}
 
 		snprintf(reply, reply_len, "+OK event listener enabled %s", listener->format == EVENT_FORMAT_XML ? "xml" : "plain");
+
+	} else if (!strncasecmp(cmd, "nixevent", 8)) {
+		char *next, *cur;
+		uint32_t count = 0, key_count = 0;
+		uint8_t custom = 0;
+		
+		strip_cr(cmd);
+		cur = cmd + 5;
+
+		if (cur && (cur = strchr(cur, ' '))) {
+			for(cur++; cur; count++) {
+				switch_event_types_t type;
+
+				if ((next = strchr(cur, ' '))) {
+					*next++ = '\0';
+				}
+				
+				if (custom) {
+					switch_core_hash_delete(listener->event_hash, cur);
+				} else if (switch_name_event(cur, &type) == SWITCH_STATUS_SUCCESS) {
+					uint32_t x = 0;
+					key_count++;
+
+					if (type == SWITCH_EVENT_ALL) {
+
+						for (x = 0; x <= SWITCH_EVENT_ALL; x++) {
+							listener->event_list[x] = 0;
+						}
+					} else {
+						if (listener->event_list[SWITCH_EVENT_ALL]) {
+							listener->event_list[SWITCH_EVENT_ALL] = 0;
+							for (x = 0; x < SWITCH_EVENT_ALL; x++) {
+								listener->event_list[x] = 1;
+							}
+						}
+						listener->event_list[type] = 0;
+					}
+
+					if (type == SWITCH_EVENT_CUSTOM) {
+						custom++;
+					}
+				}
+
+				cur = next;
+			}
+		} 
+
+		if (!key_count) {
+			snprintf(reply, reply_len, "-ERR no keywords supplied");
+			goto done;
+		}
+
+		if (!switch_test_flag(listener, LFLAG_EVENTS)) {
+			switch_set_flag_locked(listener, LFLAG_EVENTS);
+		}
+
+		snprintf(reply, reply_len, "+OK events nixed");
 		
 	} else if (!strncasecmp(cmd, "noevents", 8)) {
 		void *pop;

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_perl/Makefile
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_perl/Makefile	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_perl/Makefile	Wed Sep 20 19:16:25 2006
@@ -6,9 +6,10 @@
 LDFLAGS +=  $(shell $(PERL) -MExtUtils::Embed -e ldopts)
 LDFLAGS +=  $(shell $(PERL) -MConfig -e 'print $$Config{libs}')  
 OBJS += perlxsi.o
+SWIGCFILE=../../../switch_swig.c
+SWIGIFILE=../../../switch_swig.i
 
 
-
 all:	depends $(MODNAME).$(DYNAMIC_LIB_EXTEN) fs_perl.$(DYNAMIC_LIB_EXTEN)
 
 .perlok:
@@ -23,7 +24,10 @@
 
 reswig: 
 	rm switch_swig_wrap.c
-	swig -lswitch_swig.i -ignoremissing -DMULTIPLICITY -perl5 -module fs_perl switch_swig.c
+	swig -o switch_swig_wrap.c -l$(SWIGIFILE) -ignoremissing -DMULTIPLICITY -perl5 -module fs_perl $(SWIGCFILE)
+
+switch_swig.o: $(SWIGCFILE) Makefile
+	$(CC)  -w $(CFLAGS) -c $< -o $@
 
 switch_swig_wrap.o: switch_swig_wrap.c
 	$(CC) -w $(CFLAGS) -c $< -o $@

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_perl/fs_perl.pm
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_perl/fs_perl.pm	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_perl/fs_perl.pm	Wed Sep 20 19:16:25 2006
@@ -1,4 +1,5 @@
-# This file was automatically generated by SWIG
+# This file was created automatically by SWIG 1.3.29.
+# Don't modify this file, modify the SWIG interface instead.
 package fs_perl;
 require Exporter;
 require DynaLoader;
@@ -51,8 +52,8 @@
 *fs_loadable_module_init = *fs_perlc::fs_loadable_module_init;
 *fs_loadable_module_shutdown = *fs_perlc::fs_loadable_module_shutdown;
 *fs_console_loop = *fs_perlc::fs_console_loop;
-*fs_console_log = *fs_perlc::fs_console_log;
-*fs_console_clean = *fs_perlc::fs_console_clean;
+*fs_consol_log = *fs_perlc::fs_consol_log;
+*fs_consol_clean = *fs_perlc::fs_consol_clean;
 *fs_core_session_locate = *fs_perlc::fs_core_session_locate;
 *fs_channel_answer = *fs_perlc::fs_channel_answer;
 *fs_channel_pre_answer = *fs_perlc::fs_channel_pre_answer;
@@ -61,7 +62,16 @@
 *fs_channel_get_variable = *fs_perlc::fs_channel_get_variable;
 *fs_channel_set_state = *fs_perlc::fs_channel_set_state;
 *fs_ivr_play_file = *fs_perlc::fs_ivr_play_file;
+*fs_switch_ivr_record_file = *fs_perlc::fs_switch_ivr_record_file;
+*fs_switch_ivr_sleep = *fs_perlc::fs_switch_ivr_sleep;
 *fs_ivr_play_file2 = *fs_perlc::fs_ivr_play_file2;
+*fs_switch_ivr_collect_digits_callback = *fs_perlc::fs_switch_ivr_collect_digits_callback;
+*fs_switch_ivr_collect_digits_count = *fs_perlc::fs_switch_ivr_collect_digits_count;
+*fs_switch_ivr_originate = *fs_perlc::fs_switch_ivr_originate;
+*fs_switch_ivr_session_transfer = *fs_perlc::fs_switch_ivr_session_transfer;
+*fs_switch_ivr_speak_text = *fs_perlc::fs_switch_ivr_speak_text;
+*fs_switch_channel_get_variable = *fs_perlc::fs_switch_channel_get_variable;
+*fs_switch_channel_set_variable = *fs_perlc::fs_switch_channel_set_variable;
 
 # ------- VARIABLE STUBS --------
 

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_perl/switch_swig_wrap.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_perl/switch_swig_wrap.c	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_perl/switch_swig_wrap.c	Wed Sep 20 19:16:25 2006
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.21
+ * Version 1.3.29
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -8,72 +8,285 @@
  * interface file instead. 
  * ----------------------------------------------------------------------------- */
 
-/*************************************************************** -*- c -*-
- * perl5/precommon.swg
- *
- * Rename all exported symbols from common.swg, to avoid symbol
- * clashes if multiple interpreters are included
- *
- ************************************************************************/
+#define SWIGPERL
+#define SWIG_CASTRANK_MODE
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
 
-#define SWIG_TypeRegister    SWIG_Perl_TypeRegister
-#define SWIG_TypeCheck       SWIG_Perl_TypeCheck
-#define SWIG_TypeCast        SWIG_Perl_TypeCast
-#define SWIG_TypeDynamicCast SWIG_Perl_TypeDynamicCast
-#define SWIG_TypeName        SWIG_Perl_TypeName
-#define SWIG_TypeQuery       SWIG_Perl_TypeQuery
-#define SWIG_TypeClientData  SWIG_Perl_TypeClientData
-#define SWIG_PackData        SWIG_Perl_PackData 
-#define SWIG_UnpackData      SWIG_Perl_UnpackData 
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC)
+#   if (__SUNPRO_CC <= 0x560)
+#     define SWIGTEMPLATEDISAMBIGUATOR template
+#   else
+#     define SWIGTEMPLATEDISAMBIGUATOR 
+#   endif
+# else
+#   define SWIGTEMPLATEDISAMBIGUATOR 
+# endif
+#endif
 
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
 
-/***********************************************************************
- * common.swg
- *
- *     This file contains generic SWIG runtime support for pointer
- *     type checking as well as a few commonly used macros to control
- *     external linkage.
- *
- * Author : David Beazley (beazley at cs.uchicago.edu)
- *
- * Copyright (c) 1999-2000, The University of Chicago
- * 
- * This file may be freely redistributed without license or fee provided
- * this copyright message remains intact.
- ************************************************************************/
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__)) 
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__)) 
+# else
+#   define SWIGUNUSED 
+# endif
+#endif
 
-#include <string.h>
-#include <switch.h>
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
+# endif
+#endif
 
-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#  if defined(_MSC_VER) || defined(__GNUC__)
-#    if defined(STATIC_LINKED)
-#      define SWIGEXPORT(a) a
-#      define SWIGIMPORT(a) extern a
-#    else
-#      define SWIGEXPORT(a) __declspec(dllexport) a
-#      define SWIGIMPORT(a) extern a
-#    endif
-#  else
-#    if defined(__BORLANDC__)
-#      define SWIGEXPORT(a) a _export
-#      define SWIGIMPORT(a) a _export
-#    else
-#      define SWIGEXPORT(a) a
-#      define SWIGIMPORT(a) a
-#    endif
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#  ifndef GCC_HASCLASSVISIBILITY
+#    define GCC_HASCLASSVISIBILITY
 #  endif
-#else
-#  define SWIGEXPORT(a) a
-#  define SWIGIMPORT(a) a
 #endif
 
-#ifdef SWIG_GLOBAL
-#  define SWIGRUNTIME(a) SWIGEXPORT(a)
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif 
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic CAPI SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "2"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 #else
-#  define SWIGRUNTIME(a) static a
+# define SWIG_TYPE_TABLE_NAME
 #endif
 
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the swig runtime code.
+  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  
+  But only do this if is strictly necessary, ie, if you have problems
+  with your compiler or so.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/* 
+   Flags/methods for returning states.
+   
+   The swig conversion methods, as ConvertPtr, return and integer 
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+   
+   Use the following macros/flags to set or process the returning
+   states.
+   
+   In old swig versions, you usually write code as:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit as:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   that seems to be the same, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+    
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   requires also to SWIG_ConvertPtr to return new result values, as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {         
+        if (<obj is ok>) {			       
+          if (<need new object>) {		       
+            *ptr = <ptr to new allocated object>; 
+            return SWIG_NEWOBJ;		       
+          } else {				       
+            *ptr = <ptr to old object>;	       
+            return SWIG_OLDOBJ;		       
+          } 				       
+        } else {				       
+          return SWIG_BADOBJ;		       
+        }					       
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   swig errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+ 
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+
+
+ */
+#define SWIG_OK                    (0) 
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) { 
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) { 
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+
+
+#include <string.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -81,106 +294,141 @@
 typedef void *(*swig_converter_func)(void *);
 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
+/* Structure to store inforomation on one type */
 typedef struct swig_type_info {
-  const char             *name;
-  swig_converter_func     converter;
-  const char             *str;
-  void                   *clientdata;
-  swig_dycast_func        dcast;
-  struct swig_type_info  *next;
-  struct swig_type_info  *prev;
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
 } swig_type_info;
 
-#ifdef SWIG_NOINCLUDE
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
 
-SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
-SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
-SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
-SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
-SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
-SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
-SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
-SWIGIMPORT(char *)           SWIG_PackData(char *, void *, int);
-SWIGIMPORT(char *)           SWIG_UnpackData(char *, void *, int);
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
 
-#else
+/* 
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 
-static swig_type_info *swig_type_list = 0;
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (l1 - f1) - (l2 - f2);
+}
 
-/* Register a type mapping with the type-checking */
-SWIGRUNTIME(swig_type_info *)
-SWIG_TypeRegister(swig_type_info *ti) {
-  swig_type_info *tc, *head, *ret, *next;
-  /* Check to see if this type has already been registered */
-  tc = swig_type_list;
-  while (tc) {
-    if (strcmp(tc->name, ti->name) == 0) {
-      /* Already exists in the table.  Just add additional types to the list */
-      if (tc->clientdata) ti->clientdata = tc->clientdata;
-      head = tc;
-      next = tc->next;
-      goto l1;
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  int equiv = 0;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (!equiv && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
     }
-    tc = tc->prev;
+    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+    if (*ne) ++ne;
   }
-  head = ti;
-  next = 0;
+  return equiv;
+}
 
-  /* Place in list */
-  ti->prev = swig_type_list;
-  swig_type_list = ti;
-
-  /* Build linked lists */
-  l1:
-  ret = head;
-  tc = ti + 1;
-  /* Patch up the rest of the links */
-  while (tc->name) {
-    head->next = tc;
-    tc->prev = head;
-    head = tc;
-    tc++;
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCompare(const char *nb, const char *tb) {
+  int equiv = 0;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (!equiv && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+    if (*ne) ++ne;
   }
-  if (next) next->prev = head;
-  head->next = next;
-  return ret;
+  return equiv;
 }
 
-/* Check the typename */
-SWIGRUNTIME(swig_type_info *) 
-SWIG_TypeCheck(char *c, swig_type_info *ty) {
-  swig_type_info *s;
-  if (!ty) return 0;        /* Void pointer */
-  s = ty->next;             /* First element always just a name */
-  do {
-    if (strcmp(s->name,c) == 0) {
-      if (s == ty->next) return s;
-      /* Move s to the top of the linked list */
-      s->prev->next = s->next;
-      if (s->next) {
-        s->next->prev = s->prev;
-      }
-      /* Insert s as second element in the list */
-      s->next = ty->next;
-      if (ty->next) ty->next->prev = s;
-      ty->next = s;
-      s->prev = ty;
-      return s;
-    }
-    s = s->next;
-  } while (s && (s != ty->next));
-  return 0;
+
+/* think of this as a c++ template<> or a scheme macro */
+#define SWIG_TypeCheck_Template(comparison, ty)         \
+  if (ty) {                                             \
+    swig_cast_info *iter = ty->cast;                    \
+    while (iter) {                                      \
+      if (comparison) {                                 \
+        if (iter == ty->cast) return iter;              \
+        /* Move iter to the top of the linked list */   \
+        iter->prev->next = iter->next;                  \
+        if (iter->next)                                 \
+          iter->next->prev = iter->prev;                \
+        iter->next = ty->cast;                          \
+        iter->prev = 0;                                 \
+        if (ty->cast) ty->cast->prev = iter;            \
+        ty->cast = iter;                                \
+        return iter;                                    \
+      }                                                 \
+      iter = iter->next;                                \
+    }                                                   \
+  }                                                     \
+  return 0
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 }
 
-/* Cast a pointer up an inheritance hierarchy */
-SWIGRUNTIME(void *) 
-SWIG_TypeCast(swig_type_info *ty, void *ptr) {
-  if ((!ty) || (!ty->converter)) return ptr;
-  return (*ty->converter)(ptr);
+/* Same as previous function, except strcmp is replaced with a pointer comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
+  SWIG_TypeCheck_Template(iter->type == from, into);
 }
 
-/* Dynamic pointer casting. Down an inheritance hierarchy */
-SWIGRUNTIME(swig_type_info *) 
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+}
+
+/* 
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
   swig_type_info *lastty = ty;
   if (!ty || !ty->dcast) return ty;
@@ -191,97 +439,260 @@
   return lastty;
 }
 
-/* Return the name associated with this type */
-SWIGRUNTIME(const char *)
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
 SWIG_TypeName(const swig_type_info *ty) {
   return ty->name;
 }
 
-/* Search for a swig_type_info structure */
-SWIGRUNTIME(swig_type_info *)
-SWIG_TypeQuery(const char *name) {
-  swig_type_info *ty = swig_type_list;
-  while (ty) {
-    if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
-    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
-    ty = ty->prev;
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
   }
-  return 0;
+  else
+    return type->name;
 }
 
-/* Set the clientdata field for a type */
-SWIGRUNTIME(void)
+/* 
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
-  swig_type_info *tc, *equiv;
-  if (ti->clientdata == clientdata) return;
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
   ti->clientdata = clientdata;
-  equiv = ti->next;
-  while (equiv) {
-    if (!equiv->converter) {
-      tc = swig_type_list;
-      while (tc) {
-        if ((strcmp(tc->name, equiv->name) == 0))
-          SWIG_TypeClientData(tc,clientdata);
-        tc = tc->prev;
+  
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
       }
+    }    
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+  
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+  
+  We start searching at module start, and finish searching when start == end.  
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start, 
+                            swig_module_info *end, 
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      register size_t l = 0;
+      register size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	register size_t i = (l + r) >> 1; 
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  register int compare = strcmp(name, iname);
+	  if (compare == 0) {	    
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
     }
-    equiv = equiv->next;
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+  
+  We start searching at module start, and finish searching when start == end.  
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start, 
+                     swig_module_info *end, 
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      register size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
   }
+  
+  /* neither found a match */
+  return 0;
 }
 
-/* Pack binary data into a string */
-SWIGRUNTIME(char *)
-SWIG_PackData(char *c, void *ptr, int sz) {
-  static char hex[17] = "0123456789abcdef";
-  int i;
-  unsigned char *u = (unsigned char *) ptr;
-  register unsigned char uu;
-  for (i = 0; i < sz; i++,u++) {
-    uu = *u;
+/* 
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  register const unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    register unsigned char uu = *u;
     *(c++) = hex[(uu & 0xf0) >> 4];
     *(c++) = hex[uu & 0xf];
   }
   return c;
 }
 
-/* Unpack binary data from a string */
-SWIGRUNTIME(char *)
-SWIG_UnpackData(char *c, void *ptr, int sz) {
-  register unsigned char uu = 0;
-  register int d;
-  unsigned char *u = (unsigned char *) ptr;
-  int i;
-  for (i = 0; i < sz; i++, u++) {
-    d = *(c++);
+/* 
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    register char d = *(c++);
+    register unsigned char uu;
     if ((d >= '0') && (d <= '9'))
       uu = ((d - '0') << 4);
     else if ((d >= 'a') && (d <= 'f'))
       uu = ((d - ('a'-10)) << 4);
+    else 
+      return (char *) 0;
     d = *(c++);
     if ((d >= '0') && (d <= '9'))
       uu |= (d - '0');
     else if ((d >= 'a') && (d <= 'f'))
       uu |= (d - ('a'-10));
+    else 
+      return (char *) 0;
     *u = uu;
   }
   return c;
 }
 
-#endif
+/* 
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
 
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
 #ifdef __cplusplus
 }
 #endif
 
-/* ---------------------------------------------------------------------- -*- c -*-
- * perl5.swg
- *
- * Perl5 runtime library
- * $Header: /cvsroot/SWIG/Lib/perl5/perlrun.swg,v 1.14 2003/12/04 19:14:14 beazley Exp $
- * ----------------------------------------------------------------------------- */
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1 
+#define  SWIG_IOError        	   -2 
+#define  SWIG_RuntimeError   	   -3 
+#define  SWIG_IndexError     	   -4 
+#define  SWIG_TypeError      	   -5 
+#define  SWIG_DivisionByZero 	   -6 
+#define  SWIG_OverflowError  	   -7 
+#define  SWIG_SyntaxError    	   -8 
+#define  SWIG_ValueError     	   -9 
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12 
+#define  SWIG_NullReferenceError   -13
 
-#define SWIGPERL
-#define SWIGPERL5
+
+
 #ifdef __cplusplus
 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
 #include <math.h>
@@ -292,21 +703,227 @@
 #include "perl.h"
 #include "XSUB.h"
 
-/* Get rid of free and malloc defined by perl */
-#undef free
-#undef malloc
+/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
 
+/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
+#ifndef PERL_REVISION
+#  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
+#    define PERL_PATCHLEVEL_H_IMPLICIT
+#    include <patchlevel.h>
+#  endif
+#  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
+#    include <could_not_find_Perl_patchlevel.h>
+#  endif
+#  ifndef PERL_REVISION
+#    define PERL_REVISION       (5)
+#    define PERL_VERSION        PATCHLEVEL
+#    define PERL_SUBVERSION     SUBVERSION
+#  endif
+#endif
+
+#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
+#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
+#endif
+
+#ifndef SvIOK_UV
+# define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
+#endif
+
+#ifndef SvUOK
+# define SvUOK(sv)           SvIOK_UV(sv)
+#endif
+
+#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
+#  define PL_sv_undef               sv_undef
+#  define PL_na	                    na
+#  define PL_errgv                  errgv
+#  define PL_sv_no                  sv_no
+#  define PL_sv_yes                 sv_yes
+#  define PL_markstack_ptr          markstack_ptr
+#endif
+
+#ifndef IVSIZE
+#  ifdef LONGSIZE
+#    define IVSIZE LONGSIZE
+#  else
+#    define IVSIZE 4 /* A bold guess, but the best we can make. */
+#  endif
+#endif
+
+#ifndef INT2PTR
+#  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
+#    define PTRV                  UV
+#    define INT2PTR(any,d)        (any)(d)
+#  else
+#    if PTRSIZE == LONGSIZE
+#      define PTRV                unsigned long
+#    else
+#      define PTRV                unsigned
+#    endif
+#    define INT2PTR(any,d)        (any)(PTRV)(d)
+#  endif
+
+#  define NUM2PTR(any,d)  (any)(PTRV)(d)
+#  define PTR2IV(p)       INT2PTR(IV,p)
+#  define PTR2UV(p)       INT2PTR(UV,p)
+#  define PTR2NV(p)       NUM2PTR(NV,p)
+
+#  if PTRSIZE == LONGSIZE
+#    define PTR2ul(p)     (unsigned long)(p)
+#  else
+#    define PTR2ul(p)     INT2PTR(unsigned long,p)
+#  endif
+#endif /* !INT2PTR */
+
+#ifndef get_sv
+#  define get_sv perl_get_sv
+#endif
+
+#ifndef ERRSV
+#  define ERRSV get_sv("@",FALSE)
+#endif
+
 #ifndef pTHX_
 #define pTHX_
-#endif
+#endif   
 
 #include <string.h>
 #ifdef __cplusplus
 }
 #endif
 
-/* Macro to call an XS function */
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
 
+SWIGINTERN const char*
+SWIG_Perl_ErrorType(int code) {
+  const char* type = 0;
+  switch(code) {
+  case SWIG_MemoryError:
+    type = "MemoryError";
+    break;
+  case SWIG_IOError:
+    type = "IOError";
+    break;
+  case SWIG_RuntimeError:
+    type = "RuntimeError";
+    break;
+  case SWIG_IndexError:
+    type = "IndexError";
+    break;
+  case SWIG_TypeError:
+    type = "TypeError";
+    break;
+  case SWIG_DivisionByZero:
+    type = "ZeroDivisionError";
+    break;
+  case SWIG_OverflowError:
+    type = "OverflowError";
+    break;
+  case SWIG_SyntaxError:
+    type = "SyntaxError";
+    break;
+  case SWIG_ValueError:
+    type = "ValueError";
+    break;
+  case SWIG_SystemError:
+    type = "SystemError";
+    break;
+  case SWIG_AttributeError:
+    type = "AttributeError";
+    break;
+  default:
+    type = "RuntimeError";
+  }
+  return type;
+}
+
+
+
+
+/* -----------------------------------------------------------------------------
+ * perlrun.swg
+ *
+ * This file contains the runtime support for Perl modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef PERL_OBJECT
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
+#define SWIG_PERL_OBJECT_CALL pPerl,
+#else
+#define SWIG_PERL_OBJECT_DECL
+#define SWIG_PERL_OBJECT_CALL
+#endif
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
+#define SWIG_NewPackedObj(p, s, type)	                SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule()
+#define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)               
+#define SWIG_Error(code, msg)            		sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
+#define SWIG_fail                        		goto fail						    
+
+/* Perl-specific SWIG API */
+
+#define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
+#define SWIG_MakePackedObj(sv, p, s, type)	        SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
+#define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
+
+
+#define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
+#define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_OWNER   SWIG_POINTER_OWN
+#define SWIG_SHADOW  SWIG_OWNER << 1
+
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
+
+/* SWIG Perl macros */
+
+/* Macro to call an XS function */
 #ifdef PERL_OBJECT 
 #  define SWIG_CALLXS(_name) _name(cv,pPerl) 
 #else 
@@ -317,10 +934,6 @@
 #  endif 
 #endif 
 
-/* Contract support */
-
-#define SWIG_contract_assert(expr,msg) if (!(expr)) { SWIG_croak(msg); } else
-
 /* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
 
 #ifdef PERL_OBJECT
@@ -339,7 +952,7 @@
 #define SWIGCLASS_STATIC
 #else
 #define MAGIC_PPERL
-#define SWIGCLASS_STATIC static
+#define SWIGCLASS_STATIC static SWIGUNUSED
 #ifndef MULTIPLICITY
 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
@@ -367,194 +980,141 @@
 #endif
 #endif
 
-#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
-#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
-#endif
-
-/* Modifications for newer Perl 5.005 releases */
-
-#if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
-#  ifndef PL_sv_yes
-#    define PL_sv_yes sv_yes
+/* Workaround for bug in perl 5.6.x croak and earlier */
+#if (PERL_VERSION < 8)
+#  ifdef PERL_OBJECT
+#    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
+static void SWIG_Perl_croak_null(CPerlObj *pPerl)
+#  else
+static void SWIG_croak_null()
 #  endif
-#  ifndef PL_sv_undef
-#    define PL_sv_undef sv_undef
+{
+  SV *err=ERRSV;
+#  if (PERL_VERSION < 6)
+  croak("%_", err);
+#  else
+  if (SvOK(err) && !SvROK(err)) croak("%_", err);
+  croak(Nullch);
 #  endif
-#  ifndef PL_na
-#    define PL_na na
-#  endif
-#endif
-
-#include <stdlib.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SWIG_OWNER 1
-#define SWIG_SHADOW 2
-
-/* Common SWIG API */
-
-#ifdef PERL_OBJECT
-#  define SWIG_ConvertPtr(obj, pp, type, flags) \
-     SWIG_Perl_ConvertPtr(pPerl, obj, pp, type, flags)
-#  define SWIG_NewPointerObj(p, type, flags) \
-     SWIG_Perl_NewPointerObj(pPerl, p, type, flags)
-#  define SWIG_MakePackedObj(sv, p, s, type)	\
-     SWIG_Perl_MakePackedObj(pPerl, sv, p, s, type)
-#  define SWIG_ConvertPacked(obj, p, s, type, flags) \
-     SWIG_Perl_ConvertPacked(pPerl, obj, p, s, type, flags)
-
+}
 #else
-#  define SWIG_ConvertPtr(obj, pp, type, flags) \
-     SWIG_Perl_ConvertPtr(obj, pp, type, flags)
-#  define SWIG_NewPointerObj(p, type, flags) \
-     SWIG_Perl_NewPointerObj(p, type, flags)
-#  define SWIG_MakePackedObj(sv, p, s, type)	\
-     SWIG_Perl_MakePackedObj(sv, p, s, type )
-#  define SWIG_ConvertPacked(obj, p, s, type, flags) \
-     SWIG_Perl_ConvertPacked(obj, p, s, type, flags)
+#  define SWIG_croak_null() croak(Nullch)
 #endif
 
-/* Perl-specific API */
-#ifdef PERL_OBJECT
-#  define SWIG_MakePtr(sv, ptr, type, flags) \
-     SWIG_Perl_MakePtr(pPerl, sv, ptr, type, flags)
-#  define SWIG_TypeCheckRV(rv, ty) \
-     SWIG_Perl_TypeCheckRV(pPerl, rv, ty)
-#  define SWIG_SetError(str) \
-     SWIG_Perl_SetError(pPerl, str)
-#else
-#  define SWIG_MakePtr(sv, ptr, type, flags) \
-     SWIG_Perl_MakePtr(sv, ptr, type, flags)
-#  define SWIG_TypeCheckRV(rv, ty) \
-     SWIG_Perl_TypeCheckRV(rv, ty)
-#  define SWIG_SetError(str) \
-     SWIG_Perl_SetError(str)
-#  define SWIG_SetErrorSV(str) \
-     SWIG_Perl_SetErrorSV(str)
-#endif
 
-#define SWIG_SetErrorf SWIG_Perl_SetErrorf
 
+#include <stdlib.h>
 
-#ifdef PERL_OBJECT
-#  define SWIG_MAYBE_PERL_OBJECT CPerlObj *pPerl,
-#else
-#  define SWIG_MAYBE_PERL_OBJECT
-#endif
+SWIGRUNTIME const char *
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
+  if (!type) return NULL;
+  if (type->clientdata != NULL) {
+    return (const char*) type->clientdata;
+  } 
+  else {
+    return type->name;
+  }
+}
 
-#ifdef SWIG_NOINCLUDE
-
-SWIGIMPORT(int)               SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *, void **, swig_type_info *, int flags);
-SWIGIMPORT(void)              SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *, void *, swig_type_info *, int flags);
-SWIGIMPORT(SV *)              SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *, swig_type_info *, int flags);
-SWIGIMPORT(void)              SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *, void *, int, swig_type_info *);
-SWIGIMPORT(int)               SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *, void *, int, swig_type_info *, int flags);
-SWIGIMPORT(swig_type_info *)  SWIG_Perl_TypeCheckRV(SWIG_MAYBE_PERL_OBJECT SV *rv, swig_type_info *ty);
-SWIGIMPORT(SV *)              SWIG_Perl_SetError(SWIG_MAYBE_PERL_OBJECT char *);
-
-#else
-
-SWIGRUNTIME(swig_type_info *)
-SWIG_Perl_TypeCheckRV(SWIG_MAYBE_PERL_OBJECT SV *rv, swig_type_info *ty) {
-  swig_type_info *s;
-  if (!ty) return 0;        /* Void pointer */
-  s = ty->next;             /* First element always just a name */
-  do {
-    if (sv_derived_from(rv, (char *) s->name)) {
-      if (s == ty->next) return s;
-      /* Move s to the top of the linked list */
-      s->prev->next = s->next;
-      if (s->next) {
-        s->next->prev = s->prev;
-      }
-      /* Insert s as second element in the list */
-      s->next = ty->next;
-      if (ty->next) ty->next->prev = s;
-      ty->next = s;
-      s->prev = ty;
-      return s;
-    }
-    s = s->next;
-  } while (s && (s != ty->next));
-  return 0;
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
+  SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp((char*)iter->type->name, c) == 0)) 
+			    || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
 }
 
+
 /* Function for getting a pointer value */
 
-SWIGRUNTIME(int) 
+SWIGRUNTIME int
 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
-  swig_type_info *tc;
+  swig_cast_info *tc;
   void *voidptr = (void *)0;
-
+  SV *tsv = 0;
   /* If magical, apply more magic */
   if (SvGMAGICAL(sv))
     mg_get(sv);
 
   /* Check to see if this is an object */
   if (sv_isobject(sv)) {
-    SV *tsv = (SV*) SvRV(sv);
     IV tmp = 0;
+    tsv = (SV*) SvRV(sv);
     if ((SvTYPE(tsv) == SVt_PVHV)) {
       MAGIC *mg;
       if (SvMAGICAL(tsv)) {
         mg = mg_find(tsv,'P');
         if (mg) {
-          SV *rsv = mg->mg_obj;
-          if (sv_isobject(rsv)) {
-            tmp = SvIV((SV*)SvRV(rsv));
+          sv = mg->mg_obj;
+          if (sv_isobject(sv)) {
+	    tsv = (SV*)SvRV(sv);
+            tmp = SvIV(tsv);
           }
         }
       } else {
-        return -1;
+        return SWIG_ERROR;
       }
     } else {
-      tmp = SvIV((SV*)SvRV(sv));
+      tmp = SvIV(tsv);
     }
-    voidptr = (void *)tmp;
-    if (!_t) {
-      *(ptr) = voidptr;
-      return 0;
-    }
+    voidptr = INT2PTR(void *,tmp);
   } else if (! SvOK(sv)) {            /* Check for undef */
     *(ptr) = (void *) 0;
-    return 0;
+    return SWIG_OK;
   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
-    *(ptr) = (void *) 0;
-    if (!SvROK(sv))
-      return 0;
-    else
-      return -1;
+    if (!SvROK(sv)) {
+      *(ptr) = (void *) 0;
+      return SWIG_OK;
+    } else {
+      return SWIG_ERROR;
+    }
   } else {                            /* Don't know what it is */
-    *(ptr) = (void *) 0;
-    return -1;
+    return SWIG_ERROR;
   }
   if (_t) {
     /* Now see if the types match */
-    tc = SWIG_TypeCheckRV(sv,_t);
+    char *_c = HvNAME(SvSTASH(SvRV(sv)));
+    tc = SWIG_TypeProxyCheck(_c,_t);
     if (!tc) {
-      *ptr = voidptr;
-      return -1;
+      return SWIG_ERROR;
     }
     *ptr = SWIG_TypeCast(tc,voidptr);
-    return 0;
+  } else {
+    *ptr = voidptr;
   }
-  *ptr = voidptr;
-  return 0;
+
+  /* 
+   *  DISOWN implementation: we need a perl guru to check this one.
+   */
+  if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+    /* 
+     *  almost copy paste code from below SWIG_POINTER_OWN setting
+     */
+    SV *obj = sv;
+    HV *stash = SvSTASH(SvRV(obj));
+    GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
+    if (isGV(gv)) {
+      HV *hv = GvHVn(gv);
+      /*
+       * To set ownership (see below), a newSViv(1) entry is added. 
+       * Hence, to remove ownership, we delete the entry.
+       */
+      if (hv_exists_ent(hv, obj, 0)) {
+	hv_delete_ent(hv, obj, 0, 0);
+      }
+    }
+  }
+  return SWIG_OK;
 }
 
-SWIGRUNTIME(void)
+SWIGRUNTIME void
 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
   if (ptr && (flags & SWIG_SHADOW)) {
     SV *self;
     SV *obj=newSV(0);
     HV *hash=newHV();
     HV *stash;
-    sv_setref_pv(obj, (char *) t->name, ptr);
+    sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
     stash=SvSTASH(SvRV(obj));
-    if (flags & SWIG_OWNER) {
+    if (flags & SWIG_POINTER_OWN) {
       HV *hv;
       GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
       if (!isGV(gv))
@@ -570,73 +1130,57 @@
     sv_bless(sv, stash);
   }
   else {
-    sv_setref_pv(sv, (char *) t->name, ptr);
+    sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
   }
 }
 
-SWIGRUNTIME(SV *)
+SWIGRUNTIMEINLINE SV *
 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
   SV *result = sv_newmortal();
   SWIG_MakePtr(result, ptr, t, flags);
   return result;
 }
 
-SWIGRUNTIME(void)
-  SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
+SWIGRUNTIME void
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
   char result[1024];
   char *r = result;
-  if ((2*sz + 1 + strlen(type->name)) > 1000) return;
+  if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
   *(r++) = '_';
   r = SWIG_PackData(r,ptr,sz);
-  strcpy(r,type->name);
+  strcpy(r,SWIG_Perl_TypeProxyName(type));
   sv_setpv(sv, result);
 }
 
+SWIGRUNTIME SV *
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
+  SV *result = sv_newmortal();
+  SWIG_Perl_MakePackedObj(result, ptr, sz, type);
+  return result;
+}
+
 /* Convert a packed value value */
-SWIGRUNTIME(int)
-SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
-  swig_type_info *tc;
-  char  *c = 0;
+SWIGRUNTIME int
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c = 0;
 
-  if ((!obj) || (!SvOK(obj))) return -1;
+  if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
   c = SvPV(obj, PL_na);
   /* Pointer values must start with leading underscore */
-  if (*c != '_') return -1;
+  if (*c != '_') return SWIG_ERROR;
   c++;
   c = SWIG_UnpackData(c,ptr,sz);
   if (ty) {
     tc = SWIG_TypeCheck(c,ty);
-    if (!tc) return -1;
+    if (!tc) return SWIG_ERROR;
   }
-  return 0;
+  return SWIG_OK;
 }
 
-SWIGRUNTIME(void)
-SWIG_Perl_SetError(SWIG_MAYBE_PERL_OBJECT const char *error) {
-  if (error) sv_setpv(perl_get_sv("@", TRUE), error);
-}
 
-SWIGRUNTIME(void)
-SWIG_Perl_SetErrorSV(SWIG_MAYBE_PERL_OBJECT SV *error) {
-  if (error) sv_setsv(perl_get_sv("@", TRUE), error);
-}
-
-SWIGRUNTIME(void)
-SWIG_Perl_SetErrorf(const char *fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  sv_vsetpvfn(perl_get_sv("@", TRUE), fmt, strlen(fmt), &args, Null(SV**), 0, Null(bool*));
-  va_end(args);
-}
-
-#endif
-
 /* Macros for low-level exception handling */
-#define SWIG_fail       goto fail
-#define SWIG_croak(x)   { SWIG_SetError(x); goto fail; }
-#define SWIG_croakSV(x) { SWIG_SetErrorSV(x); goto fail; }
-/* most preprocessors do not support vararg macros :-( */
-/* #define SWIG_croakf(x...) { SWIG_SetErrorf(x); goto fail; } */
+#define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
 
 
 typedef XS(SwigPerlWrapper);
@@ -666,9 +1210,6 @@
     swig_type_info **ptype;
 } swig_constant_info;
 
-#ifdef __cplusplus
-}
-#endif
 
 /* Structure for variable table */
 typedef struct {
@@ -682,14 +1223,15 @@
 #ifndef PERL_OBJECT
 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
   #ifndef MULTIPLICITY
-     static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
+     SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) 
   #else
-     static void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) {
+     SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) 
   #endif
 #else
 #  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
-static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) 
 #endif
+{
   MAGIC *mg;
   sv_magic(sv,sv,'U',(char *) name,strlen(name));
   mg = mg_find(sv,'U');
@@ -702,10 +1244,38 @@
 }
 
 
+SWIGRUNTIME swig_module_info *
+SWIG_Perl_GetModule(void) {
+  static void *type_pointer = (void *)0;
+  SV *pointer;
 
+  /* first check if pointer already created */
+  if (!type_pointer) {
+    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
+    if (pointer && SvOK(pointer)) {
+      type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
+    }
+  }
 
+  return (swig_module_info *) type_pointer;
+}
 
+SWIGRUNTIME void
+SWIG_Perl_SetModule(swig_module_info *module) {
+  SV *pointer;
 
+  /* create a new pointer */
+  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
+  sv_setiv(pointer, PTR2IV(module));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Workaround perl5 global namespace pollution. Note that undefining library
+ * functions like fopen will not solve the problem on all platforms as fopen
+ * might be a macro on Windows but not necessarily on other operating systems. */
 #ifdef do_open
   #undef do_open
 #endif
@@ -757,16 +1327,61 @@
 #ifdef ref
   #undef ref
 #endif
-#ifdef ENTER
-  #undef ENTER
+#ifdef read
+  #undef read
 #endif
+#ifdef write
+  #undef write
+#endif
+#ifdef eof
+  #undef eof
+#endif
+#ifdef bool
+  #undef bool
+#endif
+#ifdef close
+  #undef close
+#endif
+#ifdef rewind
+  #undef rewind
+#endif
+#ifdef free
+  #undef free
+#endif
+#ifdef malloc
+  #undef malloc
+#endif
+#ifdef calloc
+  #undef calloc
+#endif
+#ifdef Stat
+  #undef Stat
+#endif
+#ifdef check
+  #undef check
+#endif
 
 
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
 /* -------- TYPES TABLE (BEGIN) -------- */
 
-#define  SWIGTYPE_p_switch_core_session_t swig_types[0] 
-#define  SWIGTYPE_p_switch_input_callback_function_t swig_types[1] 
-static swig_type_info *swig_types[3];
+#define SWIGTYPE_p_char swig_types[0]
+#define SWIGTYPE_p_p_switch_core_session_t swig_types[1]
+#define SWIGTYPE_p_switch_channel_t swig_types[2]
+#define SWIGTYPE_p_switch_core_session_t swig_types[3]
+#define SWIGTYPE_p_switch_file_handle_t swig_types[4]
+#define SWIGTYPE_p_switch_input_callback_function_t swig_types[5]
+#define SWIGTYPE_p_uint32_t swig_types[6]
+static swig_type_info *swig_types[8];
+static swig_module_info swig_module = {swig_types, 7, 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)
 
 /* -------- TYPES TABLE (END) -------- */
 
@@ -775,39 +1390,260 @@
 #define SWIG_name   "fs_perlc::boot_fs_perl"
 #define SWIG_prefix "fs_perlc::"
 
+#define SWIGVERSION 0x010329 
+
+
+#define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
+
+
 #ifdef __cplusplus
 extern "C"
 #endif
 #ifndef PERL_OBJECT
 #ifndef MULTIPLICITY
-SWIGEXPORT(void) SWIG_init (CV* cv);
+SWIGEXPORT void SWIG_init (CV* cv);
 #else
-SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
+SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
 #endif
 #else
-SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
+SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
 #endif
 
-extern void fs_core_set_globals(void);
-extern int fs_core_init(char *);
-extern int fs_core_destroy(void);
-extern int fs_loadable_module_init(void);
-extern int fs_loadable_module_shutdown(void);
-extern int fs_console_loop(void);
-extern void fs_console_log(char *,char *);
-extern void fs_console_clean(char *);
-extern switch_core_session_t *fs_core_session_locate(char *);
-extern void fs_channel_answer(switch_core_session_t *);
-extern void fs_channel_pre_answer(switch_core_session_t *);
-extern void fs_channel_hangup(switch_core_session_t *,char *);
-extern void fs_channel_set_variable(switch_core_session_t *,char *,char *);
-extern void fs_channel_get_variable(switch_core_session_t *,char *);
-extern void fs_channel_set_state(switch_core_session_t *,char *);
-extern int fs_ivr_play_file(switch_core_session_t *,char *,char *,switch_input_callback_function_t,void *,unsigned int);
-extern int fs_ivr_play_file2(switch_core_session_t *,char *);
 
-#include <switch.h>
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor()
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
 
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (SvPOK(obj)) {
+    STRLEN len = 0;
+    char *cstr = SvPV(obj, len); 
+    size_t size = len + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      char* vptr = 0; 
+      if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = vptr;
+	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
+{    
+  SV *obj = sv_newmortal();
+  sv_setiv(obj, (IV) value);
+  return obj;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
+{    
+  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+#include <limits.h>
+#ifndef LLONG_MIN
+# define LLONG_MIN	LONG_LONG_MIN
+#endif
+#ifndef LLONG_MAX
+# define LLONG_MAX	LONG_LONG_MAX
+#endif
+#ifndef ULLONG_MAX
+# define ULLONG_MAX	ULONG_LONG_MAX
+#endif
+
+
+SWIGINTERN int
+SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
+{
+  if (SvNIOK(obj)) {
+    if (val) *val = SvNV(obj);
+    return SWIG_OK;
+  } else if (SvIOK(obj)) {
+    if (val) *val = (double) SvIV(obj);
+    return SWIG_AddCast(SWIG_OK);
+  } else {
+    const char *nptr = SvPV(obj, PL_na);
+    if (nptr) {
+      char *endptr;
+      double v = strtod(nptr, &endptr);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_AddCast(SWIG_OK);
+	}
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+SWIGINTERNINLINE int
+SWIG_CanCastAsInteger(double *d, double min, double max) {
+  double x = *d;
+  if ((min <= x && x <= max)) {
+   double fx = floor(x);
+   double cx = ceil(x);
+   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
+   if ((errno == EDOM) || (errno == ERANGE)) {
+     errno = 0;
+   } else {
+     double summ, reps, diff;
+     if (rd < x) {
+       diff = x - rd;
+     } else if (rd > x) {
+       diff = rd - x;
+     } else {
+       return 1;
+     }
+     summ = rd + x;
+     reps = diff/summ;
+     if (reps < 8*DBL_EPSILON) {
+       *d = rd;
+       return 1;
+     }
+   }
+  }
+  return 0;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val) 
+{
+  if (SvUOK(obj)) {
+    if (val) *val = SvUV(obj);
+    return SWIG_OK;
+  } else  if (SvIOK(obj)) {
+    long v = SvIV(obj);
+    if (v >= 0) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV(obj, PL_na);
+    if (nptr) {
+      char *endptr;
+      unsigned long v = strtoul(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_AddCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+	if (val) *val = (unsigned long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = (unsigned int)(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  SV *obj = sv_newmortal();
+  if (size && carray) {
+    if (carray[size - 1] == 0) {
+      sv_setpv(obj, carray);
+    } else {
+      char *tmp = (char *)malloc((size + 1)*sizeof(char));
+      memcpy(tmp, carray, size);
+      tmp[size] = 0;
+      sv_setpv(obj, tmp);
+      free((char*)tmp);
+    }
+  } else {
+    sv_setsv(obj, &PL_sv_undef);
+  }
+  return obj;
+}
+
+
+SWIGINTERNINLINE SV * 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+#include "switch.h"
+
 #ifdef PERL_OBJECT
 #define MAGIC_CLASS _wrap_fs_perl_var::
 class _wrap_fs_perl_var : public CPerlObj {
@@ -815,9 +1651,8 @@
 #else
 #define MAGIC_CLASS
 #endif
-SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
+SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
     MAGIC_PPERL
-    sv = sv; mg = mg;
     croak("Value is read-only.");
     return 0;
 }
@@ -831,470 +1666,1212 @@
 extern "C" {
 #endif
 XS(_wrap_fs_core_set_globals) {
-    {
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 0) || (items > 0)) {
-            SWIG_croak("Usage: fs_core_set_globals();");
-        }
-        fs_core_set_globals();
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: fs_core_set_globals();");
     }
-    croak(Nullch);
+    fs_core_set_globals();
+    
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_core_init) {
-    {
-        char *arg1 ;
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 1) || (items > 1)) {
-            SWIG_croak("Usage: fs_core_init(path);");
-        }
-        if (!SvOK((SV*) ST(0))) arg1 = 0;
-        else arg1 = (char *) SvPV(ST(0), PL_na);
-        result = (int)fs_core_init(arg1);
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    char *arg1 = (char *) 0 ;
+    int result;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: fs_core_init(path);");
     }
-    croak(Nullch);
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_core_init" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = buf1;
+    result = (int)fs_core_init(arg1);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_core_destroy) {
-    {
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 0) || (items > 0)) {
-            SWIG_croak("Usage: fs_core_destroy();");
-        }
-        result = (int)fs_core_destroy();
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    int result;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: fs_core_destroy();");
     }
-    croak(Nullch);
+    result = (int)fs_core_destroy();
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_loadable_module_init) {
-    {
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 0) || (items > 0)) {
-            SWIG_croak("Usage: fs_loadable_module_init();");
-        }
-        result = (int)fs_loadable_module_init();
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    int result;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: fs_loadable_module_init();");
     }
-    croak(Nullch);
+    result = (int)fs_loadable_module_init();
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_loadable_module_shutdown) {
-    {
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 0) || (items > 0)) {
-            SWIG_croak("Usage: fs_loadable_module_shutdown();");
-        }
-        result = (int)fs_loadable_module_shutdown();
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    int result;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: fs_loadable_module_shutdown();");
     }
-    croak(Nullch);
+    result = (int)fs_loadable_module_shutdown();
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_console_loop) {
-    {
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 0) || (items > 0)) {
-            SWIG_croak("Usage: fs_console_loop();");
-        }
-        result = (int)fs_console_loop();
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    int result;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: fs_console_loop();");
     }
-    croak(Nullch);
+    result = (int)fs_console_loop();
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
 }
 
 
-XS(_wrap_fs_console_log) {
-    {
-        char *arg1 ;
-        char *arg2 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 2) || (items > 2)) {
-            SWIG_croak("Usage: fs_console_log(level_str,msg);");
-        }
-        if (!SvOK((SV*) ST(0))) arg1 = 0;
-        else arg1 = (char *) SvPV(ST(0), PL_na);
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        fs_console_log(arg1,arg2);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+XS(_wrap_fs_consol_log) {
+  {
+    char *arg1 = (char *) 0 ;
+    char *arg2 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: fs_consol_log(level_str,msg);");
     }
-    croak(Nullch);
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_consol_log" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = buf1;
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_consol_log" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    fs_consol_log(arg1,arg2);
+    
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    SWIG_croak_null();
+  }
 }
 
 
-XS(_wrap_fs_console_clean) {
-    {
-        char *arg1 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 1) || (items > 1)) {
-            SWIG_croak("Usage: fs_console_clean(msg);");
-        }
-        if (!SvOK((SV*) ST(0))) arg1 = 0;
-        else arg1 = (char *) SvPV(ST(0), PL_na);
-        fs_console_clean(arg1);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+XS(_wrap_fs_consol_clean) {
+  {
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: fs_consol_clean(msg);");
     }
-    croak(Nullch);
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_consol_clean" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = buf1;
+    fs_consol_clean(arg1);
+    
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_core_session_locate) {
-    {
-        char *arg1 ;
-        switch_core_session_t *result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 1) || (items > 1)) {
-            SWIG_croak("Usage: fs_core_session_locate(uuid);");
-        }
-        if (!SvOK((SV*) ST(0))) arg1 = 0;
-        else arg1 = (char *) SvPV(ST(0), PL_na);
-        result = (switch_core_session_t *)fs_core_session_locate(arg1);
-        
-        ST(argvi) = sv_newmortal();
-        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_switch_core_session_t, 0|0);
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    char *arg1 = (char *) 0 ;
+    switch_core_session_t *result = 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: fs_core_session_locate(uuid);");
     }
-    croak(Nullch);
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_core_session_locate" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = buf1;
+    result = (switch_core_session_t *)fs_core_session_locate(arg1);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_switch_core_session_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_channel_answer) {
-    {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 1) || (items > 1)) {
-            SWIG_croak("Usage: fs_channel_answer(session);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_channel_answer. Expected _p_switch_core_session_t");
-            }
-        }
-        fs_channel_answer(arg1);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: fs_channel_answer(session);");
     }
-    croak(Nullch);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_channel_answer" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    fs_channel_answer(arg1);
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_channel_pre_answer) {
-    {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 1) || (items > 1)) {
-            SWIG_croak("Usage: fs_channel_pre_answer(session);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_channel_pre_answer. Expected _p_switch_core_session_t");
-            }
-        }
-        fs_channel_pre_answer(arg1);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: fs_channel_pre_answer(session);");
     }
-    croak(Nullch);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_channel_pre_answer" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    fs_channel_pre_answer(arg1);
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_channel_hangup) {
-    {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        char *arg2 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 2) || (items > 2)) {
-            SWIG_croak("Usage: fs_channel_hangup(session,cause);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_channel_hangup. Expected _p_switch_core_session_t");
-            }
-        }
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        fs_channel_hangup(arg1,arg2);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 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: fs_channel_hangup(session,cause);");
     }
-    croak(Nullch);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_channel_hangup" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_channel_hangup" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    fs_channel_hangup(arg1,arg2);
+    
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_channel_set_variable) {
-    {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        char *arg2 ;
-        char *arg3 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 3) || (items > 3)) {
-            SWIG_croak("Usage: fs_channel_set_variable(session,var,val);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_channel_set_variable. Expected _p_switch_core_session_t");
-            }
-        }
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        if (!SvOK((SV*) ST(2))) arg3 = 0;
-        else arg3 = (char *) SvPV(ST(2), PL_na);
-        fs_channel_set_variable(arg1,arg2,arg3);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 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: fs_channel_set_variable(session,var,val);");
     }
-    croak(Nullch);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_channel_set_variable" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_channel_set_variable" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_channel_set_variable" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
+    fs_channel_set_variable(arg1,arg2,arg3);
+    
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_channel_get_variable) {
-    {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        char *arg2 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 2) || (items > 2)) {
-            SWIG_croak("Usage: fs_channel_get_variable(session,var);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_channel_get_variable. Expected _p_switch_core_session_t");
-            }
-        }
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        fs_channel_get_variable(arg1,arg2);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 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: fs_channel_get_variable(session,var);");
     }
-    croak(Nullch);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_channel_get_variable" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_channel_get_variable" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    fs_channel_get_variable(arg1,arg2);
+    
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_channel_set_state) {
-    {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        char *arg2 ;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 2) || (items > 2)) {
-            SWIG_croak("Usage: fs_channel_set_state(session,state);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_channel_set_state. Expected _p_switch_core_session_t");
-            }
-        }
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        fs_channel_set_state(arg1,arg2);
-        
-        
-        XSRETURN(argvi);
-        fail:
-        ;
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 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: fs_channel_set_state(session,state);");
     }
-    croak(Nullch);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_channel_set_state" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_channel_set_state" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    fs_channel_set_state(arg1,arg2);
+    
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    SWIG_croak_null();
+  }
 }
 
 
 XS(_wrap_fs_ivr_play_file) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    switch_input_callback_function_t arg4 ;
+    void *arg5 = (void *) 0 ;
+    unsigned int arg6 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    void *argp4 ;
+    int res4 = 0 ;
+    int res5 ;
+    unsigned int val6 ;
+    int ecode6 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 6) || (items > 6)) {
+      SWIG_croak("Usage: fs_ivr_play_file(session,file,timer_name,dtmf_callback,buf,buflen);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_ivr_play_file" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_ivr_play_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_ivr_play_file" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
     {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        char *arg2 ;
-        char *arg3 ;
-        switch_input_callback_function_t arg4 ;
-        void *arg5 = (void *) 0 ;
-        unsigned int arg6 ;
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 6) || (items > 6)) {
-            SWIG_croak("Usage: fs_ivr_play_file(session,file,timer_name,dtmf_callback,buf,buflen);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_ivr_play_file. Expected _p_switch_core_session_t");
-            }
-        }
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        if (!SvOK((SV*) ST(2))) arg3 = 0;
-        else arg3 = (char *) SvPV(ST(2), PL_na);
-        {
-            switch_input_callback_function_t * argp;
-            if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_switch_input_callback_function_t,0) < 0) {
-                SWIG_croak("Type error in argument 4 of fs_ivr_play_file. Expected _p_switch_input_callback_function_t");
-            }
-            arg4 = *argp;
-        }
-        {
-            if (SWIG_ConvertPtr(ST(4), (void **) &arg5, 0,0) < 0) {
-                SWIG_croak("Type error in argument 5 of fs_ivr_play_file. Expected _p_void");
-            }
-        }
-        arg6 = (unsigned int) SvUV(ST(5));
-        result = (int)fs_ivr_play_file(arg1,arg2,arg3,arg4,arg5,arg6);
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+      res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_switch_input_callback_function_t,  0 );
+      if (!SWIG_IsOK(res4)) {
+        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fs_ivr_play_file" "', argument " "4"" of type '" "switch_input_callback_function_t""'"); 
+      }  
+      if (!argp4) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_ivr_play_file" "', argument " "4"" of type '" "switch_input_callback_function_t""'");
+      } else {
+        arg4 = *((switch_input_callback_function_t *)(argp4));
+      }
     }
-    croak(Nullch);
+    res5 = SWIG_ConvertPtr(ST(4),SWIG_as_voidptrptr(&arg5), 0, 0);
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fs_ivr_play_file" "', argument " "5"" of type '" "void *""'"); 
+    }
+    ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fs_ivr_play_file" "', argument " "6"" of type '" "unsigned int""'");
+    } 
+    arg6 = (unsigned int)(val6);
+    result = (int)fs_ivr_play_file(arg1,arg2,arg3,arg4,arg5,arg6);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    
+    
+    SWIG_croak_null();
+  }
 }
 
 
+XS(_wrap_fs_switch_ivr_record_file) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    switch_file_handle_t *arg2 = (switch_file_handle_t *) 0 ;
+    char *arg3 = (char *) 0 ;
+    switch_input_callback_function_t arg4 ;
+    void *arg5 = (void *) 0 ;
+    unsigned int arg6 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    void *argp4 ;
+    int res4 = 0 ;
+    int res5 ;
+    unsigned int val6 ;
+    int ecode6 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 6) || (items > 6)) {
+      SWIG_croak("Usage: fs_switch_ivr_record_file(session,fh,file,dtmf_callback,buf,buflen);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_record_file" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_switch_file_handle_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_record_file" "', argument " "2"" of type '" "switch_file_handle_t *""'"); 
+    }
+    arg2 = (switch_file_handle_t *)(argp2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_switch_ivr_record_file" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
+    {
+      res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_switch_input_callback_function_t,  0 );
+      if (!SWIG_IsOK(res4)) {
+        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fs_switch_ivr_record_file" "', argument " "4"" of type '" "switch_input_callback_function_t""'"); 
+      }  
+      if (!argp4) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_switch_ivr_record_file" "', argument " "4"" of type '" "switch_input_callback_function_t""'");
+      } else {
+        arg4 = *((switch_input_callback_function_t *)(argp4));
+      }
+    }
+    res5 = SWIG_ConvertPtr(ST(4),SWIG_as_voidptrptr(&arg5), 0, 0);
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fs_switch_ivr_record_file" "', argument " "5"" of type '" "void *""'"); 
+    }
+    ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fs_switch_ivr_record_file" "', argument " "6"" of type '" "unsigned int""'");
+    } 
+    arg6 = (unsigned int)(val6);
+    result = (int)fs_switch_ivr_record_file(arg1,arg2,arg3,arg4,arg5,arg6);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_fs_switch_ivr_sleep) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    uint32_t arg2 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: fs_switch_ivr_sleep(session,ms);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_sleep" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    {
+      res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_uint32_t,  0 );
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_sleep" "', argument " "2"" of type '" "uint32_t""'"); 
+      }  
+      if (!argp2) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_switch_ivr_sleep" "', argument " "2"" of type '" "uint32_t""'");
+      } else {
+        arg2 = *((uint32_t *)(argp2));
+      }
+    }
+    result = (int)fs_switch_ivr_sleep(arg1,arg2);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
 XS(_wrap_fs_ivr_play_file2) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    int result;
+    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: fs_ivr_play_file2(session,file);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_ivr_play_file2" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_ivr_play_file2" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    result = (int)fs_ivr_play_file2(arg1,arg2);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_fs_switch_ivr_collect_digits_callback) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    switch_input_callback_function_t arg2 ;
+    void *arg3 = (void *) 0 ;
+    unsigned int arg4 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 ;
+    int res2 = 0 ;
+    int res3 ;
+    unsigned int val4 ;
+    int ecode4 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: fs_switch_ivr_collect_digits_callback(session,dtmf_callback,buf,buflen);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_collect_digits_callback" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
     {
-        switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
-        char *arg2 ;
-        int result;
-        int argvi = 0;
-        dXSARGS;
-        
-        if ((items < 2) || (items > 2)) {
-            SWIG_croak("Usage: fs_ivr_play_file2(session,file);");
-        }
-        {
-            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_switch_core_session_t,0) < 0) {
-                SWIG_croak("Type error in argument 1 of fs_ivr_play_file2. Expected _p_switch_core_session_t");
-            }
-        }
-        if (!SvOK((SV*) ST(1))) arg2 = 0;
-        else arg2 = (char *) SvPV(ST(1), PL_na);
-        result = (int)fs_ivr_play_file2(arg1,arg2);
-        
-        ST(argvi) = sv_newmortal();
-        sv_setiv(ST(argvi++), (IV) result);
-        XSRETURN(argvi);
-        fail:
-        ;
+      res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_switch_input_callback_function_t,  0 );
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_collect_digits_callback" "', argument " "2"" of type '" "switch_input_callback_function_t""'"); 
+      }  
+      if (!argp2) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_switch_ivr_collect_digits_callback" "', argument " "2"" of type '" "switch_input_callback_function_t""'");
+      } else {
+        arg2 = *((switch_input_callback_function_t *)(argp2));
+      }
     }
-    croak(Nullch);
+    res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_switch_ivr_collect_digits_callback" "', argument " "3"" of type '" "void *""'"); 
+    }
+    ecode4 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fs_switch_ivr_collect_digits_callback" "', argument " "4"" of type '" "unsigned int""'");
+    } 
+    arg4 = (unsigned int)(val4);
+    result = (int)fs_switch_ivr_collect_digits_callback(arg1,arg2,arg3,arg4);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
 }
 
 
+XS(_wrap_fs_switch_ivr_collect_digits_count) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    unsigned int arg3 ;
+    unsigned int arg4 ;
+    char *arg5 = (char *) 0 ;
+    char *arg6 = (char *) 0 ;
+    unsigned int arg7 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    unsigned int val3 ;
+    int ecode3 = 0 ;
+    unsigned int val4 ;
+    int ecode4 = 0 ;
+    int res5 ;
+    char *buf5 = 0 ;
+    int alloc5 = 0 ;
+    int res6 ;
+    char *buf6 = 0 ;
+    int alloc6 = 0 ;
+    unsigned int val7 ;
+    int ecode7 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 7) || (items > 7)) {
+      SWIG_croak("Usage: fs_switch_ivr_collect_digits_count(session,buf,buflen,maxdigits,terminators,terminator,timeout);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "3"" of type '" "unsigned int""'");
+    } 
+    arg3 = (unsigned int)(val3);
+    ecode4 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "4"" of type '" "unsigned int""'");
+    } 
+    arg4 = (unsigned int)(val4);
+    res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "5"" of type '" "char const *""'");
+    }
+    arg5 = buf5;
+    res6 = SWIG_AsCharPtrAndSize(ST(5), &buf6, NULL, &alloc6);
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "6"" of type '" "char *""'");
+    }
+    arg6 = buf6;
+    ecode7 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
+    if (!SWIG_IsOK(ecode7)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fs_switch_ivr_collect_digits_count" "', argument " "7"" of type '" "unsigned int""'");
+    } 
+    arg7 = (unsigned int)(val7);
+    result = (int)fs_switch_ivr_collect_digits_count(arg1,arg2,arg3,arg4,(char const *)arg5,arg6,arg7);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    
+    
+    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+    if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    
+    
+    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+    if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
+    
+    SWIG_croak_null();
+  }
+}
 
+
+XS(_wrap_fs_switch_ivr_originate) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    switch_core_session_t **arg2 = (switch_core_session_t **) 0 ;
+    char *arg3 = (char *) 0 ;
+    uint32_t arg4 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    void *argp4 ;
+    int res4 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: fs_switch_ivr_originate(session,bleg,bridgeto,timelimit_sec);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_originate" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_originate" "', argument " "2"" of type '" "switch_core_session_t **""'"); 
+    }
+    arg2 = (switch_core_session_t **)(argp2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_switch_ivr_originate" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
+    {
+      res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_uint32_t,  0 );
+      if (!SWIG_IsOK(res4)) {
+        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fs_switch_ivr_originate" "', argument " "4"" of type '" "uint32_t""'"); 
+      }  
+      if (!argp4) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_switch_ivr_originate" "', argument " "4"" of type '" "uint32_t""'");
+      } else {
+        arg4 = *((uint32_t *)(argp4));
+      }
+    }
+    result = (int)fs_switch_ivr_originate(arg1,arg2,arg3,arg4);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    XSRETURN(argvi);
+  fail:
+    
+    
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_fs_switch_ivr_session_transfer) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    char *arg4 = (char *) 0 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int res4 ;
+    char *buf4 = 0 ;
+    int alloc4 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: fs_switch_ivr_session_transfer(session,extension,dialplan,context);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_session_transfer" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_session_transfer" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_switch_ivr_session_transfer" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
+    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fs_switch_ivr_session_transfer" "', argument " "4"" of type '" "char *""'");
+    }
+    arg4 = buf4;
+    result = (int)fs_switch_ivr_session_transfer(arg1,arg2,arg3,arg4);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_fs_switch_ivr_speak_text) {
+  {
+    switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    char *arg4 = (char *) 0 ;
+    uint32_t arg5 ;
+    switch_input_callback_function_t arg6 ;
+    char *arg7 = (char *) 0 ;
+    void *arg8 = (void *) 0 ;
+    unsigned int arg9 ;
+    int result;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int res4 ;
+    char *buf4 = 0 ;
+    int alloc4 = 0 ;
+    void *argp5 ;
+    int res5 = 0 ;
+    void *argp6 ;
+    int res6 = 0 ;
+    int res7 ;
+    char *buf7 = 0 ;
+    int alloc7 = 0 ;
+    int res8 ;
+    unsigned int val9 ;
+    int ecode9 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 9) || (items > 9)) {
+      SWIG_croak("Usage: fs_switch_ivr_speak_text(session,tts_name,voice_name,timer_name,rate,dtmf_callback,text,buf,buflen);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_core_session_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_ivr_speak_text" "', argument " "1"" of type '" "switch_core_session_t *""'"); 
+    }
+    arg1 = (switch_core_session_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_ivr_speak_text" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_switch_ivr_speak_text" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
+    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fs_switch_ivr_speak_text" "', argument " "4"" of type '" "char *""'");
+    }
+    arg4 = buf4;
+    {
+      res5 = SWIG_ConvertPtr(ST(4), &argp5, SWIGTYPE_p_uint32_t,  0 );
+      if (!SWIG_IsOK(res5)) {
+        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fs_switch_ivr_speak_text" "', argument " "5"" of type '" "uint32_t""'"); 
+      }  
+      if (!argp5) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_switch_ivr_speak_text" "', argument " "5"" of type '" "uint32_t""'");
+      } else {
+        arg5 = *((uint32_t *)(argp5));
+      }
+    }
+    {
+      res6 = SWIG_ConvertPtr(ST(5), &argp6, SWIGTYPE_p_switch_input_callback_function_t,  0 );
+      if (!SWIG_IsOK(res6)) {
+        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "fs_switch_ivr_speak_text" "', argument " "6"" of type '" "switch_input_callback_function_t""'"); 
+      }  
+      if (!argp6) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fs_switch_ivr_speak_text" "', argument " "6"" of type '" "switch_input_callback_function_t""'");
+      } else {
+        arg6 = *((switch_input_callback_function_t *)(argp6));
+      }
+    }
+    res7 = SWIG_AsCharPtrAndSize(ST(6), &buf7, NULL, &alloc7);
+    if (!SWIG_IsOK(res7)) {
+      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "fs_switch_ivr_speak_text" "', argument " "7"" of type '" "char *""'");
+    }
+    arg7 = buf7;
+    res8 = SWIG_ConvertPtr(ST(7),SWIG_as_voidptrptr(&arg8), 0, 0);
+    if (!SWIG_IsOK(res8)) {
+      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "fs_switch_ivr_speak_text" "', argument " "8"" of type '" "void *""'"); 
+    }
+    ecode9 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(8), &val9);
+    if (!SWIG_IsOK(ecode9)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "fs_switch_ivr_speak_text" "', argument " "9"" of type '" "unsigned int""'");
+    } 
+    arg9 = (unsigned int)(val9);
+    result = (int)fs_switch_ivr_speak_text(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+    if (alloc7 == SWIG_NEWOBJ) free((char*)buf7);
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+    if (alloc7 == SWIG_NEWOBJ) free((char*)buf7);
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_fs_switch_channel_get_variable) {
+  {
+    switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *result = 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: fs_switch_channel_get_variable(channel,varname);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_channel_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_channel_get_variable" "', argument " "1"" of type '" "switch_channel_t *""'"); 
+    }
+    arg1 = (switch_channel_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_channel_get_variable" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    result = (char *)fs_switch_channel_get_variable(arg1,arg2);
+    ST(argvi) = SWIG_FromCharPtr(result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_fs_switch_channel_set_variable) {
+  {
+    switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    int result;
+    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: fs_switch_channel_set_variable(channel,varname,value);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_channel_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fs_switch_channel_set_variable" "', argument " "1"" of type '" "switch_channel_t *""'"); 
+    }
+    arg1 = (switch_channel_t *)(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fs_switch_channel_set_variable" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = buf2;
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fs_switch_channel_set_variable" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = buf3;
+    result = (int)fs_switch_channel_set_variable(arg1,arg2,arg3);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+    SWIG_croak_null();
+  }
+}
+
+
+
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
-static swig_type_info _swigt__p_switch_core_session_t[] = {{"_p_switch_core_session_t", 0, "switch_core_session_t *", 0},{"_p_switch_core_session_t"},{0}};
-static swig_type_info _swigt__p_switch_input_callback_function_t[] = {{"_p_switch_input_callback_function_t", 0, "switch_input_callback_function_t *", 0},{"_p_switch_input_callback_function_t"},{0}};
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_switch_core_session_t = {"_p_p_switch_core_session_t", "switch_core_session_t **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_switch_channel_t = {"_p_switch_channel_t", "switch_channel_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_switch_core_session_t = {"_p_switch_core_session_t", "switch_core_session_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_switch_file_handle_t = {"_p_switch_file_handle_t", "switch_file_handle_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_switch_input_callback_function_t = {"_p_switch_input_callback_function_t", "switch_input_callback_function_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0};
 
-static swig_type_info *swig_types_initial[] = {
-_swigt__p_switch_core_session_t, 
-_swigt__p_switch_input_callback_function_t, 
-0
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_char,
+  &_swigt__p_p_switch_core_session_t,
+  &_swigt__p_switch_channel_t,
+  &_swigt__p_switch_core_session_t,
+  &_swigt__p_switch_file_handle_t,
+  &_swigt__p_switch_input_callback_function_t,
+  &_swigt__p_uint32_t,
 };
 
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_switch_core_session_t[] = {  {&_swigt__p_p_switch_core_session_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_switch_channel_t[] = {  {&_swigt__p_switch_channel_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_switch_core_session_t[] = {  {&_swigt__p_switch_core_session_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_switch_file_handle_t[] = {  {&_swigt__p_switch_file_handle_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_switch_input_callback_function_t[] = {  {&_swigt__p_switch_input_callback_function_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uint32_t[] = {  {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
 
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_char,
+  _swigc__p_p_switch_core_session_t,
+  _swigc__p_switch_channel_t,
+  _swigc__p_switch_core_session_t,
+  _swigc__p_switch_file_handle_t,
+  _swigc__p_switch_input_callback_function_t,
+  _swigc__p_uint32_t,
+};
+
+
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
 
 static swig_constant_info swig_constants[] = {
-{0}
+{0,0,0,0,0,0}
 };
 #ifdef __cplusplus
 }
 #endif
 static swig_variable_info swig_variables[] = {
-{0}
+{0,0,0,0}
 };
 static swig_command_info swig_commands[] = {
 {"fs_perlc::fs_core_set_globals", _wrap_fs_core_set_globals},
@@ -1303,8 +2880,8 @@
 {"fs_perlc::fs_loadable_module_init", _wrap_fs_loadable_module_init},
 {"fs_perlc::fs_loadable_module_shutdown", _wrap_fs_loadable_module_shutdown},
 {"fs_perlc::fs_console_loop", _wrap_fs_console_loop},
-{"fs_perlc::fs_console_log", _wrap_fs_console_log},
-{"fs_perlc::fs_console_clean", _wrap_fs_console_clean},
+{"fs_perlc::fs_consol_log", _wrap_fs_consol_log},
+{"fs_perlc::fs_consol_clean", _wrap_fs_consol_clean},
 {"fs_perlc::fs_core_session_locate", _wrap_fs_core_session_locate},
 {"fs_perlc::fs_channel_answer", _wrap_fs_channel_answer},
 {"fs_perlc::fs_channel_pre_answer", _wrap_fs_channel_pre_answer},
@@ -1313,69 +2890,285 @@
 {"fs_perlc::fs_channel_get_variable", _wrap_fs_channel_get_variable},
 {"fs_perlc::fs_channel_set_state", _wrap_fs_channel_set_state},
 {"fs_perlc::fs_ivr_play_file", _wrap_fs_ivr_play_file},
+{"fs_perlc::fs_switch_ivr_record_file", _wrap_fs_switch_ivr_record_file},
+{"fs_perlc::fs_switch_ivr_sleep", _wrap_fs_switch_ivr_sleep},
 {"fs_perlc::fs_ivr_play_file2", _wrap_fs_ivr_play_file2},
+{"fs_perlc::fs_switch_ivr_collect_digits_callback", _wrap_fs_switch_ivr_collect_digits_callback},
+{"fs_perlc::fs_switch_ivr_collect_digits_count", _wrap_fs_switch_ivr_collect_digits_count},
+{"fs_perlc::fs_switch_ivr_originate", _wrap_fs_switch_ivr_originate},
+{"fs_perlc::fs_switch_ivr_session_transfer", _wrap_fs_switch_ivr_session_transfer},
+{"fs_perlc::fs_switch_ivr_speak_text", _wrap_fs_switch_ivr_speak_text},
+{"fs_perlc::fs_switch_channel_get_variable", _wrap_fs_switch_channel_get_variable},
+{"fs_perlc::fs_switch_channel_set_variable", _wrap_fs_switch_channel_set_variable},
 {0,0}
 };
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic 
+ * memory is used. Also, since swig_type_info structures store pointers to 
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization. 
+ * The idea is that swig generates all the structures that are needed. 
+ * The runtime then collects these partially filled structures. 
+ * The SWIG_InitializeModule function takes these initial arrays out of 
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned staticly to an initial 
+ * array. We just loop though that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it 
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded. 
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the 
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
 
 #ifdef __cplusplus
-extern "C"
+extern "C" {
+#if 0
+} /* c-mode */
 #endif
+#endif
 
-XS(SWIG_init) {
-    dXSARGS;
-    int i;
-    static int _init = 0;
-    if (!_init) {
-        for (i = 0; swig_types_initial[i]; i++) {
-            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
-        }	
-        _init = 1;
-    }
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head;
+  static int init_run = 0;
+  
+  clientdata = clientdata;
+  
+  if (init_run) return;
+  init_run = 1;
+  
+  /* Initialize the swig_module */
+  swig_module.type_initial = swig_type_initial;
+  swig_module.cast_initial = swig_cast_initial;
+  
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (module_head) {
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  } else {
+    /* This is the first module loaded */
+    swig_module.next = &swig_module;
+    SWIG_SetModule(clientdata, &swig_module);
+  }
+  
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
     
-    /* Install commands */
-    for (i = 0; swig_commands[i].name; i++) {
-        newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+    
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
     }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+        type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
     
-    /* Install variables */
-    for (i = 0; swig_variables[i].name; i++) {
-        SV *sv;
-        sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
-        if (swig_variables[i].type) {
-            SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+        if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+          cast->type = ret;
+          ret = 0;
         } else {
-            sv_setiv(sv,(IV) 0);
+          /* Check for casting already in the list */
+          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+          if (!ocast) ret = 0;
         }
-        swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
+      }
+      
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
     }
-    
-    /* Install constant */
-    for (i = 0; swig_constants[i].type; i++) {
-        SV *sv;
-        sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
-        switch(swig_constants[i].type) {
-            case SWIG_INT:
-            sv_setiv(sv, (IV) swig_constants[i].lvalue);
-            break;
-            case SWIG_FLOAT:
-            sv_setnv(sv, (double) swig_constants[i].dvalue);
-            break;
-            case SWIG_STRING:
-            sv_setpv(sv, (char *) swig_constants[i].pvalue);
-            break;
-            case SWIG_POINTER:
-            SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
-            break;
-            case SWIG_BINARY:
-            SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
-            break;
-            default:
-            break;
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+  
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+    printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+  
+  if (init_run) return;
+  init_run = 1;
+  
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
         }
-        SvREADONLY_on(sv);
+        equiv = equiv->next;
+      }
     }
-    
-    ST(0) = &PL_sv_yes;
-    XSRETURN(1);
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{
+  /* c-mode */
+#endif
+}
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+
+XS(SWIG_init) {
+  dXSARGS;
+  int i;
+  
+  SWIG_InitializeModule(0);
+  
+  /* Install commands */
+  for (i = 0; swig_commands[i].name; i++) {
+    newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
+  }
+  
+  /* Install variables */
+  for (i = 0; swig_variables[i].name; i++) {
+    SV *sv;
+    sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2);
+    if (swig_variables[i].type) {
+      SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
+    } else {
+      sv_setiv(sv,(IV) 0);
+    }
+    swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
+  }
+  
+  /* Install constant */
+  for (i = 0; swig_constants[i].type; i++) {
+    SV *sv;
+    sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2);
+    switch(swig_constants[i].type) {
+    case SWIG_INT:
+      sv_setiv(sv, (IV) swig_constants[i].lvalue);
+      break;
+    case SWIG_FLOAT:
+      sv_setnv(sv, (double) swig_constants[i].dvalue);
+      break;
+    case SWIG_STRING:
+      sv_setpv(sv, (char *) swig_constants[i].pvalue);
+      break;
+    case SWIG_POINTER:
+      SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
+      break;
+    case SWIG_BINARY:
+      SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
+      break;
+    default:
+      break;
+    }
+    SvREADONLY_on(sv);
+  }
+  
+  ST(0) = &PL_sv_yes;
+  XSRETURN(1);
 }
 

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_php/Makefile
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_php/Makefile	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_php/Makefile	Wed Sep 20 19:16:25 2006
@@ -8,6 +8,9 @@
 PHPMOD=freeswitch
 PHPLDFLAGS = `$(PCFG) --ldflags` -lm -ldl -lxml2 -lz -lphp5
 MOD_CFLAGS += -fPIC
+SWIGCFILE=../../../switch_swig.c
+SWIGIFILE=../../../switch_swig.i
+
 all:	depends $(MODNAME).$(DYNAMIC_LIB_EXTEN) $(PHPMOD).$(DYNAMIC_LIB_EXTEN)
 
 depends:
@@ -19,13 +22,13 @@
 
 reswig: 
 	rm -f switch_swig_wrap.c config.m4 CREDITS *$(PHPMOD)*
-	swig -lswitch_swig.i -ignoremissing -DMULTIPLICITY -php -module $(PHPMOD) switch_swig.c
+	swig -o switch_swig_wrap.c -l$(SWIGIFILE) -ignoremissing -DMULTIPLICITY -php -module $(PHPMOD) $(SWIGCFILE)
 	patch -p0 -i fix.diff
 
 switch_swig_wrap.o: switch_swig_wrap.c Makefile
 	$(CC)  -w $(CFLAGS) -c $< -o $@
 
-switch_swig.o: switch_swig.c Makefile
+switch_swig.o: $(SWIGCFILE) Makefile
 	$(CC)  -w $(CFLAGS) -c $< -o $@
 
 

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_python/Makefile
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_python/Makefile	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_python/Makefile	Wed Sep 20 19:16:25 2006
@@ -2,11 +2,13 @@
 CFLAGS += -fPIC -I$(PREFIX)/include/python2.4/
 PYMOD=freeswitch
 LDFLAGS=-lpython2.4 -Xlinker -L$(PREFIX)/lib/python2.4/config/
+SWIGCFILE=../../../switch_swig.c
+SWIGIFILE=../../../switch_swig.i
 
 all:	depends $(MODNAME).$(DYNAMIC_LIB_EXTEN) $(PYMOD).$(DYNAMIC_LIB_EXTEN)
 
 depends:
-	MAKE=$(MAKE) $(BASE)/build/buildlib.sh $(BASE) install Python-2.4.3.tgz --prefix=$(PREFIX) --enable-threads
+	MAKE=$(MAKE) PY_CFLAGS=-fPIC $(BASE)/build/buildlib.sh $(BASE) install Python-2.4.3.tgz --prefix=$(PREFIX) --enable-threads
 
 %.o:  %.c
 	$(CC) $(LCFLAGS) $(CFLAGS) -c $< -o $@
@@ -16,13 +18,13 @@
 
 reswig: 
 	rm -f switch_swig_wrap.c config.m4 CREDITS *${PYMOD}*
-	swig -lswitch_swig.i -ignoremissing -DMULTIPLICITY -python -module $(PYMOD) switch_swig.c
+	swig -o switch_swig_wrap.c -l$(SWIGIFILE) -ignoremissing -DMULTIPLICITY -python -module $(PYMOD) $(SWIGCFILE)
 	patch -p0 -i fix.diff
 
 switch_swig_wrap.o: switch_swig_wrap.c Makefile
 	$(CC)  -w $(CFLAGS) -c $< -o $@
 
-switch_swig.o: switch_swig.c Makefile
+switch_swig.o: $(SWIGCFILE) Makefile
 	$(CC)  -w $(CFLAGS) -c $< -o $@
 
 

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_ruby/Makefile
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_ruby/Makefile	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_ruby/Makefile	Wed Sep 20 19:16:25 2006
@@ -2,11 +2,13 @@
 CFLAGS += -fPIC -I../../../../libs/ruby-1.8.5/
 RBMOD=freeswitch
 LDFLAGS=-lruby-static -L$(PREFIX)/lib/ 
+SWIGCFILE=../../../switch_swig.c
+SWIGIFILE=../../../switch_swig.i
 
 all:	depends $(MODNAME).$(DYNAMIC_LIB_EXTEN) $(RBMOD).$(DYNAMIC_LIB_EXTEN)
-	
+
 depends:
-	MAKE=$(MAKE) $(BASE)/build/buildlib.sh $(BASE) install ruby-1.8.5.tar.gz --prefix=$(PREFIX)
+	MAKE=$(MAKE) MOD_CFLAGS=-fPIC $(BASE)/build/buildlib.sh $(BASE) install ruby-1.8.5.tar.gz --prefix=$(PREFIX)
 	cp -f config.h ../../../../libs/ruby-1.8.5/
 
 %.o:  %.c
@@ -17,13 +19,12 @@
 
 reswig: 
 	rm -f switch_swig_wrap.c config.m4 CREDITS *${RBMOD}*
-	swig -lswitch_swig.i -ignoremissing -DMULTIPLICITY -ruby -module $(RBMOD) switch_swig.c
-	patch -p0 -i fix.diff
+	swig -o switch_swig_wrap.c -l$(SWIGIFILE) -ignoremissing -DMULTIPLICITY -ruby -module $(RBMOD) $(SWIGCFILE)
 
 switch_swig_wrap.o: switch_swig_wrap.c Makefile
 	$(CC)  -w $(CFLAGS) -c $< -o $@
 
-switch_swig.o: switch_swig.c Makefile
+switch_swig.o: $(SWIGCFILE) Makefile
 	$(CC)  -w $(CFLAGS) -c $< -o $@
 
 
@@ -40,4 +41,3 @@
 install:
 	#cp -f rb_$(RBMOD).$(DYNAMIC_LIB_EXTEN) $(MDIR)
 	cp -f $(MODNAME).$(DYNAMIC_LIB_EXTEN) $(PREFIX)/mod
-	

Modified: freeswitch/branches/mishehu/src/mod/languages/mod_ruby/mod_ruby.c
==============================================================================
--- freeswitch/branches/mishehu/src/mod/languages/mod_ruby/mod_ruby.c	(original)
+++ freeswitch/branches/mishehu/src/mod/languages/mod_ruby/mod_ruby.c	Wed Sep 20 19:16:25 2006
@@ -42,11 +42,8 @@
 
 #include <ruby.h>
 
-
 const char modname[] = "mod_ruby";
 
-
-
 static void ruby_function(switch_core_session_t *session, char *data)
 {
 	char *uuid = switch_core_session_get_uuid(session);
@@ -56,7 +53,6 @@
 	int argc, state;
 	char *argv[5];
 	char ruby_code[1024]; 
-	//void*** tsrm_ls = NULL;
 
 	snprintf(mydata, len, "%s %s", uuid, data);
 
@@ -65,21 +61,19 @@
 	sprintf(ruby_code, "$uuid=\"%s\"; include(\"%s\");\n", argv[0], argv[1]);
 
 	ruby_init();
-			
+	
 	ruby_init_loadpath();
 
 	ruby_script("embedded");	
 	rb_load_file(data);
-    	rb_p(rb_eval_string_protect(argv[1], &state));
-    	if (state) {
+	rb_p(rb_eval_string_protect(argv[1], &state));
+	if (state) {
 		VALUE error = rb_inspect(rb_gv_get("$!"));
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Your code is broken.  \nHere is the error I found: %s\n",error);		
-    	}
+	}
 	state = ruby_exec();
 	state = ruby_cleanup(state);
 	ruby_finalize();	
-
-
 }
 
 static const switch_application_interface_t ruby_application_interface = {
@@ -105,24 +99,6 @@
 	/* connect my internal structure to the blank pointer passed to me */
 	*module_interface = &ruby_module_interface;
 
-	//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Hello World!\n");
-
 	/* indicate that the module should continue to be loaded */
 	return SWITCH_STATUS_SUCCESS;
 }
-
-/*
-  Called when the system shuts down
-  SWITCH_MOD_DECLARE(switch_status) switch_module_shutdown(void)
-  {
-  return SWITCH_STATUS_SUCCESS;
-  }
-*/
-
-/*
-  If it exists, this is called in it's own thread when the module-load completes
-  SWITCH_MOD_DECLARE(switch_status) switch_module_shutdown(void)
-  {
-  return SWITCH_STATUS_SUCCESS;
-  }
-*/

Modified: freeswitch/branches/mishehu/src/switch.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch.c	(original)
+++ freeswitch/branches/mishehu/src/switch.c	Wed Sep 20 19:16:25 2006
@@ -35,7 +35,7 @@
 
 #define PIDFILE "freeswitch.pid"
 #define LOGFILE "freeswitch.log"
-static int RUNNING = 0;
+
 static char *lfile = LOGFILE;
 static char *pfile = PIDFILE;
 #define SERVICENAME "Freeswitch"
@@ -53,38 +53,13 @@
 
 	static int handle_SIGHUP(int sig)
 {
+	uint32_t arg = 0;
 	if(sig);
-	RUNNING = 0;
+	switch_core_session_ctl(SCSC_SHUTDOWN, &arg);
 	return 0;
 }
 
-static void set_high_priority()
-{
-#ifdef WIN32
-	SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
-#else
-	//nice(-19);
-#endif
-}
 
-static void freeswitch_runtime_loop(int bg)
-{
-	if (bg) {
-		bg = 0;
-#ifdef WIN32
-		WaitForSingleObject(shutdown_event, INFINITE);
-#else
-		RUNNING = 1;
-		while(RUNNING) {
-			switch_yield(10000);
-		}
-#endif
-	}  else {
-		/* wait for console input */
-		switch_console_loop();
-	}
-}
-
 static int freeswitch_kill_background()
 {
 	FILE *f;
@@ -175,6 +150,7 @@
 	int bg = 0;
 	FILE *f;
 	pid_t pid = 0;
+	int x, die = 0;
 
 #ifdef WIN32
     SERVICE_TABLE_ENTRY dispatchTable[] =
@@ -182,62 +158,73 @@
         { SERVICENAME, &service_main },
         { NULL, NULL }
     };
+#endif
 
-	if (argv[1] && !strcmp(argv[1], "-service")) {
-		if(StartServiceCtrlDispatcher( dispatchTable ) == 0 )
-		{
-			//Not loaded as a service
-			fprintf(stderr, "Error Freeswitch loaded as a console app with -service option\n");
-			fprintf(stderr, "To install the service load freeswitch with -install\n");
+	for (x = 1; x < argc; x++) {
+#ifdef WIN32
+		if (x == 1) {
+			if (argv[x] && !strcmp(argv[x], "-service")) {
+				if(StartServiceCtrlDispatcher( dispatchTable ) == 0 )
+					{
+						//Not loaded as a service
+						fprintf(stderr, "Error Freeswitch loaded as a console app with -service option\n");
+						fprintf(stderr, "To install the service load freeswitch with -install\n");
+					}
+				exit(0);
+			}
+			if (argv[x] && !strcmp(argv[x], "-install")) {
+				char exePath[1024];
+				char servicePath[1024];
+
+				SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
+				GetModuleFileName( NULL, exePath, 1024 );
+				snprintf(servicePath, sizeof(servicePath), "%s -service", exePath);
+				CreateService(
+							  handle,
+							  SERVICENAME,
+							  SERVICENAME,
+							  GENERIC_READ | GENERIC_EXECUTE,
+							  SERVICE_WIN32_OWN_PROCESS,
+							  SERVICE_AUTO_START,
+							  SERVICE_ERROR_IGNORE,
+							  servicePath,
+							  NULL,
+							  NULL,
+							  NULL,
+							  NULL,
+							  NULL
+							  );
+				exit(0);
+			}
+			if (argv[x] && !strcmp(argv[x], "-uninstall")) {
+				SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
+				SC_HANDLE service = OpenService( handle, SERVICENAME, DELETE );
+				if( service != NULL )
+					{
+						// remove the service!
+						DeleteService( service );
+					}
+				exit(0);
+			}
 		}
-		exit(0);
-	}
-	if (argv[1] && !strcmp(argv[1], "-install")) {
-		char exePath[1024];
-	    char servicePath[1024];
+#endif
+		if (argv[x] && !strcmp(argv[x], "-hp")) {
+			set_high_priority();
+		}
+		
+		if (argv[x] && !strcmp(argv[x], "-stop")) {
+			die++;
+		}
 
-		SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
-		GetModuleFileName( NULL, exePath, 1024 );
-		snprintf(servicePath, sizeof(servicePath), "%s -service", exePath);
-		CreateService(
-			handle,
-			SERVICENAME,
-			SERVICENAME,
-			GENERIC_READ | GENERIC_EXECUTE,
-			SERVICE_WIN32_OWN_PROCESS,
-			SERVICE_AUTO_START,
-			SERVICE_ERROR_IGNORE,
-			servicePath,
-			NULL,
-			NULL,
-			NULL,
-			NULL,
-			NULL
-		);
-		exit(0);
-	}
-	if (argv[1] && !strcmp(argv[1], "-uninstall")) {
-		SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
-		SC_HANDLE service = OpenService( handle, SERVICENAME, DELETE );
-		if( service != NULL )
-		{
-			// remove the service!
-			DeleteService( service );
+		if (argv[x] && !strcmp(argv[x], "-nc")) {
+			bg++;
 		}
-		exit(0);
 	}
-#endif
 
-	set_high_priority();
-
-	if (argv[1] && !strcmp(argv[1], "-stop")) {
+	if (die) {
 		return freeswitch_kill_background();
 	}
 
-	if (argv[1] && !strcmp(argv[1], "-nc")) {
-		bg++;
-	}
-
 	if (bg) {
 		ppath = lfile;
 
@@ -246,8 +233,6 @@
 
 #ifdef WIN32
 		FreeConsole();
-		snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
-		shutdown_event = CreateEvent(NULL, FALSE, FALSE, path);		
 #else
 		if ((pid = fork())) {
 			fprintf(stderr, "%d Backgrounding.\n", (int)pid);
@@ -270,7 +255,7 @@
 	fprintf(f, "%d", pid = getpid());
 	fclose(f);
 
-	freeswitch_runtime_loop(bg);
+	switch_core_runtime_loop(bg);
 
 	return switch_core_destroy();
 }

Modified: freeswitch/branches/mishehu/src/switch_buffer.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch_buffer.c	(original)
+++ freeswitch/branches/mishehu/src/switch_buffer.c	Wed Sep 20 19:16:25 2006
@@ -170,6 +170,7 @@
 
 	buffer->front += reading;
 	buffer->used -= reading;
+
 	//if (buffer->id == 3) printf("%u o %d = %d\n", buffer->id, (uint32_t)reading, (uint32_t)buffer->used);
 	return reading;
 }
@@ -184,7 +185,7 @@
 
 	freespace = buffer->datalen - buffer->used;
 
-	if (buffer->front != buffer->data) {
+	if (buffer->used && buffer->data != buffer->front) {
 		memmove(buffer->data, buffer->front, buffer->used);
 		buffer->front = buffer->data;
 	}
@@ -192,7 +193,6 @@
 	if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_DYNAMIC)) {
 		if (freespace < datalen) {
 			switch_size_t new_size, new_block_size;
-			
 			new_size = buffer->datalen + datalen;
 			new_block_size = buffer->datalen + buffer->blocksize;
 
@@ -203,6 +203,7 @@
 			if (!(buffer->data = realloc(buffer->data, new_size))) {
 				return 0;
 			}
+			buffer->front = buffer->data;
 			buffer->datalen = new_size;
 		}
 	}

Modified: freeswitch/branches/mishehu/src/switch_channel.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch_channel.c	(original)
+++ freeswitch/branches/mishehu/src/switch_channel.c	Wed Sep 20 19:16:25 2006
@@ -86,6 +86,7 @@
 	{ "CRASH", SWITCH_CAUSE_CRASH },
 	{ "SYSTEM_SHUTDOWN", SWITCH_CAUSE_SYSTEM_SHUTDOWN },
 	{ "LOSE_RACE", SWITCH_CAUSE_LOSE_RACE },
+	{ "MANAGER_REQUEST", SWITCH_CAUSE_MANAGER_REQUEST },
 	{ NULL, 0 }
 };
 
@@ -98,6 +99,7 @@
 	switch_core_session_t *session;
 	switch_channel_state_t state;
 	uint32_t flags;
+	uint32_t state_flags;
 	switch_caller_profile_t *caller_profile;
 	switch_caller_profile_t *originator_caller_profile;
 	switch_caller_profile_t *originatee_caller_profile;
@@ -374,6 +376,15 @@
 	switch_set_flag_locked(channel, flags);
 }
 
+SWITCH_DECLARE(void) switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flags)
+{
+	assert(channel != NULL);
+
+	switch_mutex_lock(channel->flag_mutex);
+	channel->state_flags |= flags;
+	switch_mutex_unlock(channel->flag_mutex);
+}
+
 SWITCH_DECLARE(void) switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flags)
 {
 	assert(channel != NULL);
@@ -392,10 +403,10 @@
 	return state;
 }
 
-SWITCH_DECLARE(unsigned int) switch_channel_ready(switch_channel_t *channel)
+SWITCH_DECLARE(uint8_t) switch_channel_ready(switch_channel_t *channel)
 {
 	assert(channel != NULL);
-	return (channel->state > CS_RING && channel->state < CS_HANGUP) ? 1 : 0;
+	return (channel->state > CS_RING && channel->state < CS_HANGUP && !switch_test_flag(channel, CF_TRANSFER)) ? 1 : 0;
 }
 
 static const char *state_names[] = {
@@ -616,6 +627,12 @@
 		}
 	}
  done:
+	
+	if (channel->state_flags) {
+		channel->flags |= channel->state_flags;
+		channel->state_flags = 0;
+	}
+
 	switch_mutex_unlock(channel->flag_mutex);
 	return channel->state;
 }
@@ -830,12 +847,14 @@
 	for (index = 0; index < SWITCH_MAX_STATE_HANDLERS; index++) {
 		channel->state_handlers[index] = NULL;
 	}
+
 	if (state_handler) {
 		for (index = 0; index < i; index++) {
 			channel->state_handlers[index] = new_handlers[i];
 		}
 	}
 
+	channel->state_handler_index = i;
 }
 
 SWITCH_DECLARE(void) switch_channel_set_caller_extension(switch_channel_t *channel,

Modified: freeswitch/branches/mishehu/src/switch_console.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch_console.c	(original)
+++ freeswitch/branches/mishehu/src/switch_console.c	Wed Sep 20 19:16:25 2006
@@ -203,20 +203,42 @@
 {
 	char hostname[256];
 	char cmd[2048];
-	int running = 1, activity = 1;
+	uint32_t activity = 1, running = 1;
 	switch_size_t x = 0;
 
 	gethostname(hostname, sizeof(hostname));
 
-	while (running) {
+	while(running) {
+		uint32_t arg;
+		fd_set rfds, efds;
+		struct timeval tv = {0, 20000};
+
+		switch_core_session_ctl(SCSC_CHECK_RUNNING, &arg);
+		if (!arg) {
+			break;
+		}
+
 		if (activity) {
 			switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_CONSOLE, "\nfreeswitch@%s> ", hostname);
 		}
-		//activity = switch_socket_waitfor(fileno(stdin), 100, POLLIN | POLLERR);
 
+#ifdef _MSC_VER
+//Microsofts macros don't pass their own compilers warnings.
+#pragma warning(push)
+#pragma warning(disable: 4127 4389)
+#endif
+
+		FD_ZERO(&rfds);
+		FD_ZERO(&efds);
+		FD_SET(fileno(stdin), &rfds);
+		FD_SET(fileno(stdin), &efds);
+		activity = select(fileno(stdin)+1, &rfds, NULL, &efds, &tv);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 		if (activity == 0) {
 			fflush(stdout);
-			switch_sleep(100);
 			continue;
 		}
 

Modified: freeswitch/branches/mishehu/src/switch_core.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch_core.c	(original)
+++ freeswitch/branches/mishehu/src/switch_core.c	Wed Sep 20 19:16:25 2006
@@ -127,6 +127,9 @@
 	uint32_t session_count;
 	uint32_t session_limit;
 	switch_queue_t *sql_queue;
+	uint32_t no_new_sessions;
+	uint32_t shutting_down;
+	uint8_t running;
 };
 
 /* Prototypes */
@@ -143,11 +146,7 @@
 /* The main runtime obj we keep this hidden for ourselves */
 static struct switch_core_runtime runtime;
 
-/* Mutex and conditional for sql lite */
-static switch_mutex_t *SWITCH_SQL_MUTEX;
-static switch_thread_cond_t *SWITCH_SQL_CONDITIONAL;
 
-
 static void db_pick_path(char *dbname, char *buf, switch_size_t size)
 {
 
@@ -540,7 +539,7 @@
 	}
 }
 
-SWITCH_DECLARE(void) switch_core_session_hupall(void)
+SWITCH_DECLARE(void) switch_core_session_hupall(switch_call_cause_t cause)
 {
 	switch_hash_index_t *hi;
 	void *val;
@@ -553,7 +552,7 @@
 		if (val) {
 			session = (switch_core_session_t *) val;
 			channel = switch_core_session_get_channel(session);
-			switch_channel_hangup(channel, SWITCH_CAUSE_SYSTEM_SHUTDOWN);
+			switch_channel_hangup(channel, cause);
 		}
 	}
 	switch_mutex_unlock(runtime.session_table_mutex);
@@ -2896,9 +2895,6 @@
 
 		endstate = switch_channel_get_state(session->channel);
 
-		if (endstate >= CS_HANGUP) {
-			goto done;
-		}
 
 		if (midstate == endstate) {
 			switch_thread_cond_wait(session->cond, session->mutex);
@@ -3068,6 +3064,7 @@
 	}
 }
 
+
 SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session_t *session, switch_thread_start_t func,
 													   void *obj)
 {
@@ -3117,6 +3114,11 @@
 		return NULL;
 	}
 
+	if (runtime.no_new_sessions || runtime.shutting_down) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Read my lips: no new sessions!\n");
+		return NULL;
+	}
+
 	if (pool) {
 		usepool = pool;
 	} else if (switch_core_new_memory_pool(&usepool) != SWITCH_STATUS_SUCCESS) {
@@ -3169,6 +3171,11 @@
 	return session;
 }
 
+SWITCH_DECLARE(uint32_t) switch_core_session_count(void)
+{
+	return runtime.session_count;
+}
+
 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request_by_name(char *endpoint_name, switch_memory_pool_t *pool)
 {
 	const switch_endpoint_interface_t *endpoint_interface;
@@ -3185,7 +3192,13 @@
 {
 	char *errmsg;
 	switch_status_t status = SWITCH_STATUS_FALSE;
+	uint8_t forever = 0;
 
+	if (!retries) {
+		forever = 1;
+		retries = 1000;
+	}
+
 	while(retries > 0) {
 		switch_core_db_exec(
 							db,
@@ -3195,10 +3208,14 @@
 							&errmsg
 							);		
 		if (errmsg) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR\n[%s]\n[%s]\n", sql,errmsg);
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR [%s]\n", errmsg);
 			switch_core_db_free(errmsg);
 			switch_yield(100000);
 			retries--;
+			if (retries == 0 && forever) {
+				retries = 1000;
+				continue;
+			}
 		} else {
 			status = SWITCH_STATUS_SUCCESS;
 			break;
@@ -3208,76 +3225,76 @@
 	return status;
 }
 
+#ifdef DO_EVENTS
+#define SQLLEN 1024 * 64
 static void *SWITCH_THREAD_FUNC switch_core_sql_thread(switch_thread_t *thread, void *obj)
 {
 	void *pop;
 	uint32_t itterations = 0;
-	uint8_t trans = 0;
-	switch_time_t last_commit = switch_time_now();
-	uint32_t freq = 1000, target = 1000, diff = 0;
-
-	//if these are null we have big problems
-	assert(SWITCH_SQL_MUTEX != NULL);
-	assert(SWITCH_SQL_CONDITIONAL != NULL);
+	uint8_t trans = 0, nothing_in_queue = 0;
+	uint32_t freq = 1000, target = 1000;
+	uint32_t len = 0;
+	uint32_t sql_len = SQLLEN;
+	char *sqlbuf = (char *) malloc(sql_len);
 	
 	if (!runtime.event_db) {
 		runtime.event_db = switch_core_db_handle();
 	}
 	switch_queue_create(&runtime.sql_queue, SWITCH_SQL_QUEUE_LEN, runtime.memory_pool);
 
-	switch_mutex_lock(SWITCH_SQL_MUTEX);
-	
 	for(;;) {
 		if (switch_queue_trypop(runtime.sql_queue, &pop) == SWITCH_STATUS_SUCCESS) {
 			char *sql = (char *) pop;
+			uint32_t newlen;
 
 			if (sql) {
 				if (itterations == 0) {
-					char *isql = "begin transaction CORE1;";
-					if (switch_core_db_persistant_execute(runtime.event_db, isql, 25) != SWITCH_STATUS_SUCCESS) {
-						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL exec error! [%s]\n", isql);
-					} else {
-						trans = 1;
-					}
+					char *isql = "begin transaction CORE1;\n";
+					switch_core_db_persistant_execute(runtime.event_db, isql, 0);
+					trans = 1;
+					
 				}
 
 				itterations++;
-
-				if (switch_core_db_persistant_execute(runtime.event_db, sql, 25) != SWITCH_STATUS_SUCCESS) {
-					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL exec error! [%s]\n", sql);
+				newlen = (uint32_t)strlen(sql) + 2;
+				if (len + newlen > sql_len) {
+					sql_len = len + SQLLEN;
+					if (!(sqlbuf = realloc(sqlbuf, sql_len))) {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL thread ending on mem err\n");
+						break;
+					}
 				}
+				snprintf(sqlbuf + len, sql_len - len, "%s;\n", sql); 
+				len += newlen;
 				switch_core_db_free(sql);
 			} else {
 				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "SQL thread ending\n");
 				break;
 			}
 		} else {
-			//Are we currently in a transaction, wait accordingly
-			if(trans) {
-				//we need to finish a transaction in a bit, wait around until we have more work or that time comes
-				switch_thread_cond_timedwait(SWITCH_SQL_CONDITIONAL, SWITCH_SQL_MUTEX, (freq * 1000)  + last_commit - switch_time_now());
-			} else {
-				//wait until we have more work
-				switch_thread_cond_wait(SWITCH_SQL_CONDITIONAL, SWITCH_SQL_MUTEX);
-			}
+			nothing_in_queue = 1;
 		}
-		
-		if (diff < freq) {
-			diff = (uint32_t)((switch_time_now() - last_commit) / 1000);
-		} 
 
-		if (trans && (itterations == target || diff >= freq)) {
-			char *sql = "end transaction CORE1";
-			if (switch_core_db_persistant_execute(runtime.event_db, sql, 25) != SWITCH_STATUS_SUCCESS) {
-				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL exec error! [%s]\n", sql);
-			}
-			last_commit = switch_time_now();
+
+		if (trans && ((itterations == target) || nothing_in_queue)) {
+			char *isql = "end transaction CORE1";
+
+			switch_core_db_persistant_execute(runtime.event_db, sqlbuf, 0);
+			switch_core_db_persistant_execute(runtime.event_db, isql, 0);
 			itterations = 0;
 			trans = 0;
-			diff = 0;
+			nothing_in_queue = 0;
+			len = 0;
+			*sqlbuf = '\0';
 		}
 		
+		if (nothing_in_queue) {
+			switch_yield(freq);
+		} 
 	}
+
+
+	free(sqlbuf);
 	return NULL;
 }
 
@@ -3289,10 +3306,6 @@
 	
 	assert(runtime.memory_pool != NULL);
 
-	//create the mutex and conditional
-	switch_mutex_init(&SWITCH_SQL_MUTEX, SWITCH_MUTEX_NESTED, runtime.memory_pool);
-	switch_thread_cond_create(&SWITCH_SQL_CONDITIONAL, runtime.memory_pool);
-
 	switch_threadattr_create(&thd_attr, runtime.memory_pool);
 	switch_threadattr_detach_set(thd_attr, 1);
 	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
@@ -3300,7 +3313,6 @@
 	
 }
 
-#ifdef DO_EVENTS
 static void core_event_handler(switch_event_t *event)
 {
 	char *sql = NULL;
@@ -3400,16 +3412,6 @@
 
 	if (sql) {
 		switch_queue_push(runtime.sql_queue, sql);
-
-		//See if we need to wake up the sql thread
-		if(switch_mutex_trylock(SWITCH_SQL_MUTEX) == SWITCH_STATUS_SUCCESS) {
-                        //wake up the SQL thread
-                        switch_thread_cond_signal(SWITCH_SQL_CONDITIONAL);
-
-                        //give up our lock
-                        switch_mutex_unlock(SWITCH_SQL_MUTEX);
-		}
-
 		sql = NULL;
 	}
 }
@@ -3480,6 +3482,60 @@
 	return runtime.session_limit;
 }
 
+
+SWITCH_DECLARE(int32_t) set_high_priority(void)
+{
+#ifdef __linux__
+	struct sched_param sched = {0};
+	sched.sched_priority = 1;
+	if (sched_setscheduler(0, SCHED_RR, &sched)) {
+        sched.sched_priority = 0;
+        if (sched_setscheduler(0, SCHED_OTHER, &sched)) {
+			return -1;
+		}
+	}
+#endif
+
+#ifdef WIN32
+	SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
+#else
+	nice(-10);
+#endif
+
+#define USE_MLOCKALL
+#ifdef HAVE_MLOCKALL
+#ifdef USE_MLOCKALL
+	mlockall(MCL_CURRENT|MCL_FUTURE);
+#endif
+#endif
+	return 0;
+}
+
+SWITCH_DECLARE(void) switch_core_runtime_loop(int bg)
+{
+#ifdef WIN32
+	HANDLE shutdown_event;
+	char path[256] = "";
+#endif
+	if (bg) {
+		bg = 0;
+#ifdef WIN32
+		snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
+		shutdown_event = CreateEvent(NULL, FALSE, FALSE, path);		
+		WaitForSingleObject(shutdown_event, INFINITE);
+#else
+		runtime.running = 1;
+		while(runtime.running) {
+			switch_yield(1000000);
+		}
+#endif
+	}  else {
+		/* wait for console input */
+		switch_console_loop();
+	}
+}
+
+
 SWITCH_DECLARE(switch_status_t) switch_core_init(char *console, const char **err)
 {
 	switch_xml_t xml = NULL, cfg = NULL;
@@ -3542,7 +3598,10 @@
 
 	assert(runtime.memory_pool != NULL);
 	switch_log_init(runtime.memory_pool);
+
+#ifdef DO_EVENTS
 	switch_core_sql_thread_launch();
+#endif
 
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Allocated memory pool. Sessions are %u bytes\n", sizeof(switch_core_session_t));
 	switch_event_init(runtime.memory_pool);
@@ -3605,7 +3664,7 @@
 	}
 
 	runtime.session_id = 1;
-
+	runtime.running = 1;
 	switch_core_hash_init(&runtime.session_table, runtime.memory_pool);
 	switch_mutex_init(&runtime.session_table_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
 #ifdef CRASH_PROT
@@ -3665,13 +3724,6 @@
 		switch_event_fire(&event);
 	}
 
-//#define USE_MLOCKALL
-#ifdef HAVE_MLOCKALL
-#ifdef USE_MLOCKALL
-	mlockall(MCL_CURRENT|MCL_FUTURE);
-#endif
-#endif
-
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nFreeSWITCH Version %s Started.\nCrash Protection [%s]\nMax Sessions[%u]\n\n", SWITCH_VERSION_FULL, __CP, switch_core_session_limit(0));
 	return SWITCH_STATUS_SUCCESS;
 
@@ -3699,6 +3751,31 @@
 	return switch_time_now() - runtime.initiated;
 }
 
+SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, uint32_t *val)
+{
+
+	if (runtime.shutting_down) {
+		return -1;
+	}
+
+	switch (cmd) {
+	case SCSC_PAUSE_INBOUND:
+		runtime.no_new_sessions = *val;
+		break;
+	case SCSC_HUPALL:
+		switch_core_session_hupall(SWITCH_CAUSE_MANAGER_REQUEST);
+		break;
+	case SCSC_SHUTDOWN:
+		runtime.running = 0;
+		break;
+	case SCSC_CHECK_RUNNING:
+		*val = runtime.running;
+		break;
+	}
+
+	return 0;
+}
+
 SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
 {
 	switch_event_t *event;
@@ -3706,9 +3783,11 @@
 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Shutting Down");
 		switch_event_fire(&event);
 	}
+	runtime.shutting_down = 1;
+	runtime.no_new_sessions = 1;
 
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "End existing sessions\n");
-	switch_core_session_hupall();
+	switch_core_session_hupall(SWITCH_CAUSE_SYSTEM_SHUTDOWN);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clean up modules.\n");
 	switch_loadable_module_shutdown();
 
@@ -3716,14 +3795,6 @@
 	switch_event_shutdown();
 	
 	switch_queue_push(runtime.sql_queue, NULL);
-	//See if we need to wake up the sql thread
-	if(switch_mutex_trylock(SWITCH_SQL_MUTEX) == SWITCH_STATUS_SUCCESS) {
-		//wake up the SQL thread
-		switch_thread_cond_signal(SWITCH_SQL_CONDITIONAL);
-
-		//give up our lock
-		switch_mutex_unlock(SWITCH_SQL_MUTEX);
-	}
 
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Waiting for unfinished SQL transactions\n");
 	while (switch_queue_size(runtime.sql_queue) > 0) {

Modified: freeswitch/branches/mishehu/src/switch_ivr.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch_ivr.c	(original)
+++ freeswitch/branches/mishehu/src/switch_ivr.c	Wed Sep 20 19:16:25 2006
@@ -1354,7 +1354,11 @@
 		switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
 	}
 	switch_channel_clear_state_handler(channel, &audio_bridge_peer_state_handlers);
-		
+
+	if (!switch_channel_test_flag(channel, CF_TRANSFER)) {
+		switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
+	}
+	
 	return SWITCH_STATUS_FALSE;
 }
 
@@ -1396,6 +1400,108 @@
 	/*.on_hold */ audio_bridge_on_hold,
 };
 
+
+static switch_status_t uuid_bridge_on_transmit(switch_core_session_t *session)
+{
+	switch_channel_t *channel = NULL;
+	switch_core_session_t *other_session;
+
+	channel = switch_core_session_get_channel(session);
+	assert(channel != NULL);
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CUSTOM TRANSMIT\n");
+	switch_channel_clear_state_handler(channel, NULL);
+
+	if (!switch_channel_test_flag(channel, CF_ORIGINATOR)) {
+		switch_channel_set_flag(channel, CF_TAGGED);
+		return SWITCH_STATUS_FALSE;
+	}
+
+	if ((other_session = switch_channel_get_private(channel, "_uuid_bridge_"))) {
+		switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
+		switch_channel_state_t state = switch_channel_get_state(other_channel);
+		switch_channel_state_t mystate = switch_channel_get_state(channel);
+		switch_event_t *event;
+		uint8_t ready_a, ready_b;
+		switch_caller_profile_t *profile, *new_profile;
+
+		switch_channel_clear_flag(channel, CF_TRANSFER);
+		switch_channel_set_private(channel, "_uuid_bridge_", NULL);
+
+		while (mystate <= CS_HANGUP && state <= CS_HANGUP && !switch_channel_test_flag(other_channel, CF_TAGGED)) {
+			switch_yield(1000);
+			state = switch_channel_get_state(other_channel);
+			mystate = switch_channel_get_state(channel);
+		}
+
+		switch_channel_clear_flag(other_channel, CF_TRANSFER|CF_TAGGED);
+
+
+		switch_core_session_reset(session);
+		switch_core_session_reset(other_session);
+		
+		ready_a = switch_channel_ready(channel);
+		ready_b = switch_channel_ready(other_channel);
+
+		if (!ready_a || !ready_b) {
+			if (!ready_a) {
+				switch_channel_hangup(other_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+			}
+
+			if (!ready_b) {
+				switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+			}
+			return SWITCH_STATUS_FALSE;
+		}
+		
+		/* add another profile to both sessions for CDR's sake */
+		if ((profile = switch_channel_get_caller_profile(channel))) {
+			new_profile = switch_caller_profile_clone(session, profile);
+			new_profile->destination_number = switch_core_session_strdup(session, switch_core_session_get_uuid(other_session));
+			switch_channel_set_caller_profile(channel, new_profile);
+		} 
+
+		if ((profile = switch_channel_get_caller_profile(other_channel))) {
+			new_profile = switch_caller_profile_clone(other_session, profile);
+			new_profile->destination_number = switch_core_session_strdup(other_session, switch_core_session_get_uuid(session));
+			switch_channel_set_caller_profile(other_channel, new_profile);
+		} 
+
+		/* fire events that will change the data table from "show channels" */
+		if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Application", "uuid_bridge");
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Application-Data", switch_core_session_get_uuid(other_session));
+			switch_event_fire(&event);
+		}
+
+		if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_event_set_data(other_channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Application", "uuid_bridge");
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Application-Data", switch_core_session_get_uuid(session));
+			switch_event_fire(&event);
+		}
+
+		switch_ivr_multi_threaded_bridge(session, other_session, NULL, NULL, NULL);
+	} else {
+		switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+	}
+
+
+
+	return SWITCH_STATUS_FALSE;
+}
+
+static const switch_state_handler_table_t uuid_bridge_state_handlers = {
+	/*.on_init */ NULL,
+	/*.on_ring */ NULL,
+	/*.on_execute */ NULL,
+	/*.on_hangup */ NULL,
+	/*.on_loopback */ NULL,
+	/*.on_transmit */ uuid_bridge_on_transmit,
+	/*.on_hold */ NULL
+};
+
 struct key_collect {
 	char *key;
 	char *file;
@@ -1549,11 +1655,11 @@
 													 )
 										  
 {
-	char *peer_names[MAX_PEERS];
-	switch_core_session_t *peer_session, *peer_sessions[MAX_PEERS];
-	switch_caller_profile_t *caller_profiles[MAX_PEERS], *caller_caller_profile;
+	char *peer_names[MAX_PEERS] = {0};
+	switch_core_session_t *peer_session, *peer_sessions[MAX_PEERS] = {0};
+	switch_caller_profile_t *caller_profiles[MAX_PEERS] = {0}, *caller_caller_profile;
 	char *chan_type = NULL, *chan_data;
-	switch_channel_t *peer_channel = NULL, *peer_channels[MAX_PEERS];
+	switch_channel_t *peer_channel = NULL, *peer_channels[MAX_PEERS] = {0};
 	time_t start;
 	switch_frame_t *read_frame = NULL;
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
@@ -1703,7 +1809,9 @@
 			peer_channels[i] = NULL;
 			peer_sessions[i] = NULL;
 			continue;
-		} 
+		}
+
+		switch_core_session_read_lock(peer_sessions[i]);
 		pool = NULL;
 	
 		peer_channels[i] = switch_core_session_get_channel(peer_sessions[i]);
@@ -1880,6 +1988,13 @@
 		switch_core_codec_destroy(&write_codec);
 	}
 
+	for (i = 0; i < argc; i++) {
+		if (!peer_channels[i]) {
+			continue;
+		}
+		switch_core_session_rwunlock(peer_sessions[i]);
+	}
+
 	return status;
 }
 
@@ -1961,7 +2076,11 @@
 				switch_channel_event_set_data(caller_channel, event);
 				switch_event_fire(&event);
 			}
-		
+
+			if (switch_channel_get_state(caller_channel) != CS_EXECUTE && !switch_channel_test_flag(caller_channel, CF_TRANSFER)) {
+				switch_channel_hangup(caller_channel, SWITCH_CAUSE_NORMAL_CLEARING);
+			}
+
 			this_audio_thread->objs[0] = NULL;
 			this_audio_thread->objs[1] = NULL;
 			this_audio_thread->objs[2] = NULL;
@@ -1971,13 +2090,7 @@
 			switch_mutex_lock(this_audio_thread->mutex);
 			this_audio_thread->running = 0;
 			switch_mutex_unlock(this_audio_thread->mutex);
-
-			if (!switch_channel_test_flag(peer_channel, CF_TRANSFER) && 
-				switch_channel_get_state(peer_channel) < CS_HANGUP) {
-				switch_core_session_kill_channel(peer_session, SWITCH_SIG_KILL);
-				switch_channel_hangup(peer_channel, SWITCH_CAUSE_NORMAL_CLEARING);
-			}
-
+			
 			switch_channel_clear_flag(caller_channel, CF_ORIGINATOR);
 
 			if (other_audio_thread->running > 0) {
@@ -2009,6 +2122,52 @@
 }
 
 
+SWITCH_DECLARE(switch_status_t) switch_ivr_uuid_bridge(char *originator_uuid, char *originatee_uuid)
+{
+	switch_core_session_t *originator_session, *originatee_session;
+	switch_channel_t *originator_channel, *originatee_channel;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+
+	if ((originator_session = switch_core_session_locate(originator_uuid))) {
+		if ((originatee_session = switch_core_session_locate(originatee_uuid))) { 
+			originator_channel = switch_core_session_get_channel(originator_session);
+			originatee_channel = switch_core_session_get_channel(originatee_session);
+
+			/* override transmit state for originator_channel to bridge to originatee_channel 
+			 * install pointer to originatee_session into originator_channel
+			 * set CF_TRANSFER on both channels and change state to CS_TRANSMIT to
+			 * inturrupt anything they are already doing.
+			 * originatee_session will fall asleep and originator_session will bridge to it
+			 */
+			
+			switch_channel_clear_state_handler(originator_channel, NULL);
+			switch_channel_clear_state_handler(originatee_channel, NULL);
+			switch_channel_set_flag(originator_channel, CF_ORIGINATOR);
+			switch_channel_add_state_handler(originator_channel, &uuid_bridge_state_handlers);
+			switch_channel_add_state_handler(originatee_channel, &uuid_bridge_state_handlers);
+			switch_channel_set_private(originator_channel, "_uuid_bridge_", originatee_session);
+
+			/* switch_channel_set_state_flag sets flags you want to be set when the next stat change happens */
+			switch_channel_set_state_flag(originator_channel, CF_TRANSFER);
+			switch_channel_set_state_flag(originatee_channel, CF_TRANSFER);
+
+			/* release the read locks we have on the channels */
+			switch_core_session_rwunlock(originator_session);
+			switch_core_session_rwunlock(originatee_session);
+
+			/* change the states and let the chips fall where they may */
+			switch_channel_set_state(originator_channel, CS_TRANSMIT);
+			switch_channel_set_state(originatee_channel, CS_TRANSMIT);
+			
+		} else {
+			switch_core_session_rwunlock(originator_session);
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "no channel for uuid %s\n", originatee_uuid);
+		}
+	}
+
+	return status;
+
+}
 
 SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_t *session, char *extension, char *dialplan, char *context)
 {

Modified: freeswitch/branches/mishehu/src/switch_rtp.c
==============================================================================
--- freeswitch/branches/mishehu/src/switch_rtp.c	(original)
+++ freeswitch/branches/mishehu/src/switch_rtp.c	Wed Sep 20 19:16:25 2006
@@ -584,11 +584,16 @@
 	}
 
 	switch_mutex_lock((*rtp_session)->flag_mutex);
+	
+	if ((*rtp_session)->packet_buffer) {
+		switch_buffer_destroy(&(*rtp_session)->packet_buffer);
+	}
+			
 	switch_rtp_kill_socket(*rtp_session);
 	switch_socket_close((*rtp_session)->sock);
 	(*rtp_session)->sock = NULL;
-	switch_mutex_unlock((*rtp_session)->flag_mutex);
 
+
 	if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_VAD)) {
 		switch_rtp_disable_vad(*rtp_session);
 	}
@@ -602,6 +607,8 @@
 		switch_core_timer_destroy(&(*rtp_session)->timer);
 	}
 
+	switch_mutex_unlock((*rtp_session)->flag_mutex);
+
 	return;
 }
 
@@ -834,6 +841,10 @@
 		}		
 		
 		if (status == SWITCH_STATUS_BREAK || bytes == 0) {
+			if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_DATAWAIT)) {
+				switch_yield(rtp_session->ms_per_packet);
+				continue;
+			}
 			return 0;
 		}
 
@@ -1099,7 +1110,8 @@
 		send_msg->header.m = m ? 1 : 0;
 		if (packetize) {
 			if (!rtp_session->packet_buffer) {
-				if (switch_buffer_create(rtp_session->pool, &rtp_session->packet_buffer, rtp_session->packet_size * 2) != SWITCH_STATUS_SUCCESS) {
+				if (switch_buffer_create_dynamic(&rtp_session->packet_buffer, rtp_session->packet_size, rtp_session->packet_size * 2, 0) 
+					!= SWITCH_STATUS_SUCCESS) {
 					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Buffer memory error\n");
 					return -1;
 				}



More information about the Freeswitch-svn mailing list