From a7f74af7d0ef689d19c07329fc3f0ea301517949 Mon Sep 17 00:00:00 2001
From: Anthony Minessale <anthm@freeswitch.org>
Date: Mon, 10 May 2010 13:06:22 -0500
Subject: [PATCH] add bind method to EventConsumer takes same args as
 constructor to bind more events to an existing consumer

---
 build/strip.pl                                |    6 +
 src/include/switch_cpp.h                      |    4 +-
 src/include/switch_types.h.orig               | 1714 +++++
 .../mod_conference/mod_conference.c.orig      | 6343 +++++++++++++++++
 .../mod_conference/mod_conference.c.rej       |   50 +
 .../formats/mod_sndfile/mod_sndfile.c.orig    |  462 ++
 .../mod_java/src/org/freeswitch/swig/API.java |    6 +-
 .../src/org/freeswitch/swig/CoreSession.java  |   80 +-
 .../src/org/freeswitch/swig/DTMF.java         |    6 +-
 .../src/org/freeswitch/swig/Event.java        |   22 +-
 .../org/freeswitch/swig/EventConsumer.java    |   22 +-
 .../org/freeswitch/swig/freeswitchJNI.java    |   60 +-
 .../languages/mod_java/switch_swig_wrap.cpp   |  649 +-
 src/mod/languages/mod_lua/mod_lua_wrap.cpp    | 2208 +-----
 .../languages/mod_managed/freeswitch_wrap.cxx |   53 +-
 src/mod/languages/mod_managed/managed/swig.cs |   63 +-
 src/mod/languages/mod_perl/freeswitch.pm      |    3 +-
 src/mod/languages/mod_perl/mod_perl_wrap.cpp  | 3389 +--------
 src/mod/languages/mod_python/freeswitch.py    |    4 +-
 .../languages/mod_python/mod_python_wrap.cpp  | 2446 +------
 .../mod_python/mod_python_wrap.cpp.rej        |   38 +
 src/switch_core.c.orig                        | 2018 ++++++
 src/switch_cpp.cpp                            |   39 +-
 src/switch_event.c                            |    2 +-
 src/switch_time.c.orig                        | 1962 +++++
 25 files changed, 13598 insertions(+), 8051 deletions(-)
 create mode 100755 build/strip.pl
 create mode 100644 src/include/switch_types.h.orig
 create mode 100644 src/mod/applications/mod_conference/mod_conference.c.orig
 create mode 100644 src/mod/applications/mod_conference/mod_conference.c.rej
 create mode 100644 src/mod/formats/mod_sndfile/mod_sndfile.c.orig
 create mode 100644 src/mod/languages/mod_python/mod_python_wrap.cpp.rej
 create mode 100644 src/switch_core.c.orig
 create mode 100644 src/switch_time.c.orig

diff --git a/build/strip.pl b/build/strip.pl
new file mode 100755
index 0000000000..cb3591782e
--- /dev/null
+++ b/build/strip.pl
@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+while(<>) {
+  s/SWITCH_DECLARE_CONSTRUCTOR//g;
+  s/SWITCH_DECLARE[^\(]*\((.*?)\)/$1/g;
+  print;
+}
diff --git a/src/include/switch_cpp.h b/src/include/switch_cpp.h
index af9c9dcf62..9d383b0f78 100644
--- a/src/include/switch_cpp.h
+++ b/src/include/switch_cpp.h
@@ -170,12 +170,12 @@ SWITCH_DECLARE(void) consoleCleanLog(char *msg);
 	 public:
 		 switch_queue_t *events;
 		 switch_event_types_t e_event_id;
-		 switch_event_node_t *node;
 		 char *e_callback;
 		 char *e_subclass_name;
 		 char *e_cb_arg;
-		 SWITCH_DECLARE_CONSTRUCTOR EventConsumer(const char *event_name, const char *subclass_name = "");
+		 SWITCH_DECLARE_CONSTRUCTOR EventConsumer(const char *event_name = NULL, const char *subclass_name = "");
 		 SWITCH_DECLARE_CONSTRUCTOR ~ EventConsumer();
+		 SWITCH_DECLARE(int) bind(const char *event_name, const char *subclass_name = "");
 		 SWITCH_DECLARE(Event *) pop(int block = 0);
 	 };
 
diff --git a/src/include/switch_types.h.orig b/src/include/switch_types.h.orig
new file mode 100644
index 0000000000..2589e2b8c3
--- /dev/null
+++ b/src/include/switch_types.h.orig
@@ -0,0 +1,1714 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ * Copyright (C) 2005-2010, Anthony Minessale II <anthm@freeswitch.org>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Bret McDanel <trixter AT 0xdecafbad dot com>
+ *
+ * switch_types.h -- Data Types
+ *
+ */
+/*! \file switch_types.h
+    \brief Data Types
+*/
+#ifndef SWITCH_TYPES_H
+#define SWITCH_TYPES_H
+
+#include <switch.h>
+SWITCH_BEGIN_EXTERN_C
+#define SWITCH_ENT_ORIGINATE_DELIM ":_:"
+#define SWITCH_BLANK_STRING ""
+#define SWITCH_TON_UNDEF 255
+#define SWITCH_NUMPLAN_UNDEF 255
+#ifdef WIN32
+#define SWITCH_SEQ_FWHITE FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY
+#define SWITCH_SEQ_FRED FOREGROUND_RED | FOREGROUND_INTENSITY
+#define SWITCH_SEQ_FMAGEN FOREGROUND_BLUE | FOREGROUND_RED
+#define SWITCH_SEQ_FCYAN FOREGROUND_GREEN | FOREGROUND_BLUE
+#define SWITCH_SEQ_FGREEN FOREGROUND_GREEN
+#define SWITCH_SEQ_FYELLOW FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY
+#define SWITCH_SEQ_DEFAULT_COLOR SWITCH_SEQ_FWHITE
+#else
+#define SWITCH_SEQ_ESC "\033["
+/* Ansi Control character suffixes */
+#define SWITCH_SEQ_HOME_CHAR 'H'
+#define SWITCH_SEQ_HOME_CHAR_STR "H"
+#define SWITCH_SEQ_CLEARLINE_CHAR '1'
+#define SWITCH_SEQ_CLEARLINE_CHAR_STR "1"
+#define SWITCH_SEQ_CLEARLINEEND_CHAR "K"
+#define SWITCH_SEQ_CLEARSCR_CHAR0 '2'
+#define SWITCH_SEQ_CLEARSCR_CHAR1 'J'
+#define SWITCH_SEQ_CLEARSCR_CHAR "2J"
+#define SWITCH_SEQ_DEFAULT_COLOR SWITCH_SEQ_ESC SWITCH_SEQ_END_COLOR	/* Reset to Default fg/bg color */
+#define SWITCH_SEQ_AND_COLOR ";"	/* To add multiple color definitions */
+#define SWITCH_SEQ_END_COLOR "m"	/* To end color definitions */
+/* Foreground colors values */
+#define SWITCH_SEQ_F_BLACK "30"
+#define SWITCH_SEQ_F_RED "31"
+#define SWITCH_SEQ_F_GREEN "32"
+#define SWITCH_SEQ_F_YELLOW "33"
+#define SWITCH_SEQ_F_BLUE "34"
+#define SWITCH_SEQ_F_MAGEN "35"
+#define SWITCH_SEQ_F_CYAN "36"
+#define SWITCH_SEQ_F_WHITE "37"
+/* Background colors values */
+#define SWITCH_SEQ_B_BLACK "40"
+#define SWITCH_SEQ_B_RED "41"
+#define SWITCH_SEQ_B_GREEN "42"
+#define SWITCH_SEQ_B_YELLOW "43"
+#define SWITCH_SEQ_B_BLUE "44"
+#define SWITCH_SEQ_B_MAGEN "45"
+#define SWITCH_SEQ_B_CYAN "46"
+#define SWITCH_SEQ_B_WHITE "47"
+/* Preset escape sequences - Change foreground colors only */
+#define SWITCH_SEQ_FBLACK SWITCH_SEQ_ESC SWITCH_SEQ_F_BLACK SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FRED SWITCH_SEQ_ESC SWITCH_SEQ_F_RED SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FGREEN SWITCH_SEQ_ESC SWITCH_SEQ_F_GREEN SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FYELLOW SWITCH_SEQ_ESC SWITCH_SEQ_F_YELLOW SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FBLUE SWITCH_SEQ_ESC SWITCH_SEQ_F_BLUE SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FMAGEN SWITCH_SEQ_ESC SWITCH_SEQ_F_MAGEN SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FCYAN SWITCH_SEQ_ESC SWITCH_SEQ_F_CYAN SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_FWHITE SWITCH_SEQ_ESC SWITCH_SEQ_F_WHITE SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BBLACK SWITCH_SEQ_ESC SWITCH_SEQ_B_BLACK SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BRED SWITCH_SEQ_ESC SWITCH_SEQ_B_RED SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BGREEN SWITCH_SEQ_ESC SWITCH_SEQ_B_GREEN SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BYELLOW SWITCH_SEQ_ESC SWITCH_SEQ_B_YELLOW SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BBLUE SWITCH_SEQ_ESC SWITCH_SEQ_B_BLUE SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BMAGEN SWITCH_SEQ_ESC SWITCH_SEQ_B_MAGEN SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BCYAN SWITCH_SEQ_ESC SWITCH_SEQ_B_CYAN SWITCH_SEQ_END_COLOR
+#define SWITCH_SEQ_BWHITE SWITCH_SEQ_ESC SWITCH_SEQ_B_WHITE SWITCH_SEQ_END_COLOR
+/* Preset escape sequences */
+#define SWITCH_SEQ_HOME SWITCH_SEQ_ESC SWITCH_SEQ_HOME_CHAR_STR
+#define SWITCH_SEQ_CLEARLINE SWITCH_SEQ_ESC SWITCH_SEQ_CLEARLINE_CHAR_STR
+#define SWITCH_SEQ_CLEARLINEEND SWITCH_SEQ_ESC SWITCH_SEQ_CLEARLINEEND_CHAR
+#define SWITCH_SEQ_CLEARSCR SWITCH_SEQ_ESC SWITCH_SEQ_CLEARSCR_CHAR SWITCH_SEQ_HOME
+#endif
+#define SWITCH_DEFAULT_CLID_NAME ""
+#define SWITCH_DEFAULT_DTMF_DURATION 2000
+#define SWITCH_MIN_DTMF_DURATION 400
+#define SWITCH_MAX_DTMF_DURATION 192000
+#define SWITCH_DEFAULT_DIR_PERMS SWITCH_FPROT_UREAD | SWITCH_FPROT_UWRITE | SWITCH_FPROT_UEXECUTE | SWITCH_FPROT_GREAD | SWITCH_FPROT_GEXECUTE
+#ifdef WIN32
+#define SWITCH_PATH_SEPARATOR "\\"
+#else
+#define SWITCH_PATH_SEPARATOR "/"
+#endif
+#define SWITCH_URL_SEPARATOR "://"
+#define SWITCH_IGNORE_DISPLAY_UPDATES_VARIABLE "ignore_display_updates"
+#define SWITCH_AUDIO_SPOOL_PATH_VARIABLE "audio_spool_path"
+#define SWITCH_BRIDGE_HANGUP_CAUSE_VARIABLE "bridge_hangup_cause"
+#define SWITCH_READ_TERMINATOR_USED_VARIABLE "read_terminator_used"
+#define SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE "send_silence_when_idle"
+#define SWITCH_CURRENT_APPLICATION_VARIABLE "current_application"
+#define SWITCH_CURRENT_APPLICATION_DATA_VARIABLE "current_application_data"
+#define SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE "current_application_response"
+#define SWITCH_ENABLE_HEARTBEAT_EVENTS_VARIABLE "enable_heartbeat_events"
+#define SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE "bypass_media_after_bridge"
+#define SWITCH_READ_RESULT_VARIABLE "read_result"
+#define SWITCH_COPY_XML_CDR_VARIABLE "copy_xml_cdr"
+#define SWITCH_CURRENT_APPLICATION_VARIABLE "current_application"
+#define SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE "proto_specific_hangup_cause"
+#define SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE "execute_on_answer"
+#define SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE "execute_on_pre_answer"
+#define SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE "execute_on_media"
+#define SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE "api_on_answer"
+#define SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE "execute_on_ring"
+#define SWITCH_CALL_TIMEOUT_VARIABLE "call_timeout"
+#define SWITCH_HOLDING_UUID_VARIABLE "holding_uuid"
+#define SWITCH_SOFT_HOLDING_UUID_VARIABLE "soft_holding_uuid"
+#define SWITCH_API_BRIDGE_END_VARIABLE "api_after_bridge"
+#define SWITCH_API_HANGUP_HOOK_VARIABLE "api_hangup_hook"
+#define SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE "session_in_hangup_hook"
+#define SWITCH_PROCESS_CDR_VARIABLE "process_cdr"
+#define SWITCH_BRIDGE_CHANNEL_VARIABLE "bridge_channel"
+#define SWITCH_CHANNEL_NAME_VARIABLE "channel_name"
+#define SWITCH_BRIDGE_UUID_VARIABLE "bridge_uuid"
+#define SWITCH_CONTINUE_ON_FAILURE_VARIABLE "continue_on_fail"
+#define SWITCH_PLAYBACK_TERMINATORS_VARIABLE "playback_terminators"
+#define SWITCH_PLAYBACK_TERMINATOR_USED "playback_terminator_used"
+#define SWITCH_CACHE_SPEECH_HANDLES_VARIABLE "cache_speech_handles"
+#define SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME "__cache_speech_handles_obj__"
+#define SWITCH_BYPASS_MEDIA_VARIABLE "bypass_media"
+#define SWITCH_PROXY_MEDIA_VARIABLE "proxy_media"
+#define SWITCH_ENDPOINT_DISPOSITION_VARIABLE "endpoint_disposition"
+#define SWITCH_HOLD_MUSIC_VARIABLE "hold_music"
+#define SWITCH_EXPORT_VARS_VARIABLE "export_vars"
+#define SWITCH_R_SDP_VARIABLE "switch_r_sdp"
+#define SWITCH_L_SDP_VARIABLE "switch_l_sdp"
+#define SWITCH_B_SDP_VARIABLE "switch_m_sdp"
+#define SWITCH_BRIDGE_VARIABLE "bridge_to"
+#define SWITCH_SIGNAL_BRIDGE_VARIABLE "signal_bridge_to"
+#define SWITCH_SIGNAL_BOND_VARIABLE "signal_bond"
+#define SWITCH_ORIGINATOR_VARIABLE "originator"
+#define SWITCH_ORIGINATOR_CODEC_VARIABLE "originator_codec"
+#define SWITCH_ORIGINATOR_VIDEO_CODEC_VARIABLE "originator_video_codec"
+#define SWITCH_LOCAL_MEDIA_IP_VARIABLE "local_media_ip"
+#define SWITCH_LOCAL_MEDIA_PORT_VARIABLE "local_media_port"
+#define SWITCH_REMOTE_MEDIA_IP_VARIABLE "remote_media_ip"
+#define SWITCH_REMOTE_MEDIA_PORT_VARIABLE "remote_media_port"
+#define SWITCH_REMOTE_VIDEO_IP_VARIABLE "remote_video_ip"
+#define SWITCH_REMOTE_VIDEO_PORT_VARIABLE "remote_video_port"
+#define SWITCH_LOCAL_VIDEO_IP_VARIABLE "local_video_ip"
+#define SWITCH_LOCAL_VIDEO_PORT_VARIABLE "local_video_port"
+#define SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE "hangup_after_bridge"
+#define SWITCH_PARK_AFTER_BRIDGE_VARIABLE "park_after_bridge"
+#define SWITCH_TRANSFER_AFTER_BRIDGE_VARIABLE "transfer_after_bridge"
+#define SWITCH_EXEC_AFTER_BRIDGE_APP_VARIABLE "exec_after_bridge_app"
+#define SWITCH_EXEC_AFTER_BRIDGE_ARG_VARIABLE "exec_after_bridge_arg"
+#define SWITCH_MAX_FORWARDS_VARIABLE "max_forwards"
+#define SWITCH_DISABLE_APP_LOG_VARIABLE "disable_app_log"
+#define SWITCH_SPEECH_KEY "speech"
+#define SWITCH_UUID_BRIDGE "uuid_bridge"
+#define SWITCH_BITS_PER_BYTE 8
+#define SWITCH_DEFAULT_FILE_BUFFER_LEN 65536
+#define SWITCH_DTMF_LOG_LEN 1000
+typedef uint8_t switch_byte_t;
+
+typedef struct {
+	char digit;
+	uint32_t duration;
+} switch_dtmf_t;
+
+typedef enum {
+	SWITCH_CALL_DIRECTION_INBOUND,
+	SWITCH_CALL_DIRECTION_OUTBOUND
+} switch_call_direction_t;
+
+typedef enum {
+	SBF_DIAL_ALEG = (1 << 0),
+	SBF_EXEC_ALEG = (1 << 1),
+	SBF_DIAL_BLEG = (1 << 2),
+	SBF_EXEC_BLEG = (1 << 3),
+	SBF_EXEC_OPPOSITE = (1 << 4),
+	SBF_EXEC_SAME = (1 << 5),
+	SBF_ONCE = (1 << 6),
+	SBF_EXEC_INLINE = (1 << 7)
+} switch_bind_flag_enum_t;
+typedef uint32_t switch_bind_flag_t;
+
+typedef enum {
+	SWITCH_DTMF_RECV = 0,
+	SWITCH_DTMF_SEND = 1
+} switch_dtmf_direction_t;
+
+typedef enum {
+	SOF_NONE = 0,
+	SOF_NOBLOCK = (1 << 0),
+	SOF_FORKED_DIAL = (1 << 1),
+	SOF_NO_EFFECTIVE_CID_NUM = (1 << 2),
+	SOF_NO_EFFECTIVE_CID_NAME = (1 << 3)
+} switch_originate_flag_enum_t;
+typedef uint32_t switch_originate_flag_t;
+
+typedef enum {
+	SPF_NONE = 0,
+	SPF_ODD = (1 << 0),
+	SPF_EVEN = (1 << 1)
+} switch_port_flag_enum_t;
+typedef uint32_t switch_port_flag_t;
+
+typedef enum {
+	ED_MUX_READ = (1 << 0),
+	ED_MUX_WRITE = (1 << 1),
+	ED_DTMF = (1 << 2)
+} switch_eavesdrop_flag_enum_t;
+typedef uint32_t switch_eavesdrop_flag_t;
+
+typedef enum {
+	SCF_NONE = 0,
+	SCF_USE_SQL = (1 << 0),
+	SCF_NO_NEW_SESSIONS = (1 << 1),
+	SCF_SHUTTING_DOWN = (1 << 2),
+	SCF_VG = (1 << 3),
+	SCF_RESTART = (1 << 4),
+	SCF_SHUTDOWN_REQUESTED = (1 << 5),
+	SCF_USE_AUTO_NAT = (1 << 6),
+	SCF_EARLY_HANGUP = (1 << 7),
+	SCF_CALIBRATE_CLOCK = (1 << 8),
+	SCF_USE_HEAVY_TIMING = (1 << 9),
+	SCF_USE_CLOCK_RT = (1 << 10)
+} switch_core_flag_enum_t;
+typedef uint32_t switch_core_flag_t;
+
+typedef enum {
+	SWITCH_ENDPOINT_INTERFACE,
+	SWITCH_TIMER_INTERFACE,
+	SWITCH_DIALPLAN_INTERFACE,
+	SWITCH_CODEC_INTERFACE,
+	SWITCH_APPLICATION_INTERFACE,
+	SWITCH_API_INTERFACE,
+	SWITCH_FILE_INTERFACE,
+	SWITCH_SPEECH_INTERFACE,
+	SWITCH_DIRECTORY_INTERFACE,
+	SWITCH_CHAT_INTERFACE,
+	SWITCH_SAY_INTERFACE,
+	SWITCH_ASR_INTERFACE,
+	SWITCH_MANAGEMENT_INTERFACE
+} switch_module_interface_name_t;
+
+typedef enum {
+	SUF_NONE = 0,
+	SUF_THREAD_RUNNING = (1 << 0),
+	SUF_READY = (1 << 1),
+	SUF_NATIVE = (1 << 2)
+} switch_unicast_flag_enum_t;
+typedef uint32_t switch_unicast_flag_t;
+
+typedef enum {
+	SWITCH_FALSE = 0,
+	SWITCH_TRUE = 1
+} switch_bool_t;
+
+/* WARNING, Do not forget to update *SAY_METHOD_NAMES[] in src/switch_ivr_play_say.c */
+typedef enum {
+	SSM_NA,
+	SSM_PRONOUNCED,
+	SSM_ITERATED,
+	SSM_COUNTED
+} switch_say_method_t;
+
+/* WARNING, Do not forget to update *SAY_TYPE_NAMES[] in src/switch_ivr_say.c */
+typedef enum {
+	SST_NUMBER,
+	SST_ITEMS,
+	SST_PERSONS,
+	SST_MESSAGES,
+	SST_CURRENCY,
+	SST_TIME_MEASUREMENT,
+	SST_CURRENT_DATE,
+	SST_CURRENT_TIME,
+	SST_CURRENT_DATE_TIME,
+	SST_TELEPHONE_NUMBER,
+	SST_TELEPHONE_EXTENSION,
+	SST_URL,
+	SST_IP_ADDRESS,
+	SST_EMAIL_ADDRESS,
+	SST_POSTAL_ADDRESS,
+	SST_ACCOUNT_NUMBER,
+	SST_NAME_SPELLED,
+	SST_NAME_PHONETIC,
+	SST_SHORT_DATE_TIME
+} switch_say_type_t;
+
+typedef enum {
+	SSG_MASCULINE,
+	SSG_FEMININE,
+	SSG_NEUTER
+} switch_say_gender_t;
+
+typedef enum {
+	SMA_NONE,
+	SMA_GET,
+	SMA_SET
+} switch_management_action_t;
+
+typedef enum {
+	SSHF_NONE = 0,
+	SSHF_OWN_THREAD = (1 << 0),
+	SSHF_FREE_ARG = (1 << 1),
+	SSHF_NO_DEL = (1 << 2)
+} switch_scheduler_flag_enum_t;
+typedef uint32_t switch_scheduler_flag_t;
+
+typedef enum {
+	SMF_NONE = 0,
+	SMF_REBRIDGE = (1 << 0),
+	SMF_ECHO_ALEG = (1 << 1),
+	SMF_ECHO_BLEG = (1 << 2),
+	SMF_FORCE = (1 << 3),
+	SMF_LOOP = (1 << 4),
+	SMF_HOLD_BLEG = (1 << 5),
+	SMF_IMMEDIATE = (1 << 6),
+	SMF_EXEC_INLINE = (1 << 7),
+	SMF_PRIORITY = (1 << 8)
+} switch_media_flag_enum_t;
+typedef uint32_t switch_media_flag_t;
+
+typedef enum {
+	SWITCH_BITPACK_MODE_RFC3551,
+	SWITCH_BITPACK_MODE_AAL2
+} switch_bitpack_mode_t;
+
+typedef enum {
+	SWITCH_ABC_TYPE_INIT,
+	SWITCH_ABC_TYPE_READ,
+	SWITCH_ABC_TYPE_WRITE,
+	SWITCH_ABC_TYPE_WRITE_REPLACE,
+	SWITCH_ABC_TYPE_READ_REPLACE,
+	SWITCH_ABC_TYPE_READ_PING,
+	SWITCH_ABC_TYPE_CLOSE
+} switch_abc_type_t;
+
+typedef struct {
+	switch_byte_t *buf;
+	uint32_t buflen;
+	switch_byte_t *cur;
+	uint32_t bytes;
+	uint32_t bits_tot;
+	switch_byte_t bits_cur;
+	switch_byte_t bits_rem;
+	switch_byte_t frame_bits;
+	switch_byte_t shiftby;
+	switch_byte_t this_byte;
+	switch_byte_t under;
+	switch_byte_t over;
+	switch_bitpack_mode_t mode;
+} switch_bitpack_t;
+
+
+struct switch_directories {
+	char *base_dir;
+	char *mod_dir;
+	char *conf_dir;
+	char *log_dir;
+	char *run_dir;
+	char *db_dir;
+	char *script_dir;
+	char *temp_dir;
+	char *htdocs_dir;
+	char *grammar_dir;
+	char *storage_dir;
+	char *recordings_dir;
+	char *sounds_dir;
+};
+
+typedef struct switch_directories switch_directories;
+SWITCH_DECLARE_DATA extern switch_directories SWITCH_GLOBAL_dirs;
+
+#define SWITCH_MAX_STACKS 16
+#define SWITCH_THREAD_STACKSIZE 240 * 1024
+#define SWITCH_SYSTEM_THREAD_STACKSIZE 8192 * 1024
+#define SWITCH_MAX_INTERVAL 120	/* we only do up to 120ms */
+#define SWITCH_INTERVAL_PAD 10	/* A little extra buffer space to be safe */
+#define SWITCH_MAX_SAMPLE_LEN 48
+#define SWITCH_BYTES_PER_SAMPLE 2	/* slin is 2 bytes per sample */
+#define SWITCH_RECOMMENDED_BUFFER_SIZE 4096	/* worst case of 32khz @60ms we only do 48khz @10ms which is 960 */
+#define SWITCH_MAX_CODECS 50
+#define SWITCH_MAX_STATE_HANDLERS 30
+#define SWITCH_CORE_QUEUE_LEN 100000
+#define SWITCH_MAX_MANAGEMENT_BUFFER_LEN 1024 * 8
+
+#define SWITCH_ACCEPTABLE_INTERVAL(_i) (_i && _i <= SWITCH_MAX_INTERVAL && (_i % 10) == 0)
+
+typedef enum {
+	SWITCH_CPF_NONE = 0,
+	SWITCH_CPF_SCREEN = (1 << 0),
+	SWITCH_CPF_HIDE_NAME = (1 << 1),
+	SWITCH_CPF_HIDE_NUMBER = (1 << 2)
+} switch_caller_profile_flag_enum_t;
+typedef uint32_t switch_caller_profile_flag_t;
+
+typedef enum {
+	SWITCH_AUDIO_COL_STR_TITLE = 0x01,
+	SWITCH_AUDIO_COL_STR_COPYRIGHT = 0x02,
+	SWITCH_AUDIO_COL_STR_SOFTWARE = 0x03,
+	SWITCH_AUDIO_COL_STR_ARTIST = 0x04,
+	SWITCH_AUDIO_COL_STR_COMMENT = 0x05,
+	SWITCH_AUDIO_COL_STR_DATE = 0x06
+} switch_audio_col_t;
+
+typedef enum {
+	SWITCH_XML_SECTION_RESULT = 0,
+	SWITCH_XML_SECTION_CONFIG = (1 << 0),
+	SWITCH_XML_SECTION_DIRECTORY = (1 << 1),
+	SWITCH_XML_SECTION_DIALPLAN = (1 << 2),
+	SWITCH_XML_SECTION_PHRASES = (1 << 3),
+
+	/* Nothing after this line */
+	SWITCH_XML_SECTION_MAX = (1 << 4)
+} switch_xml_section_enum_t;
+typedef uint32_t switch_xml_section_t;
+
+/*!
+  \enum switch_vad_flag_t
+  \brief RTP Related Flags
+<pre>
+    SWITCH_VAD_FLAG_TALKING         - Currently Talking
+    SWITCH_VAD_FLAG_EVENTS_TALK     - Fire events when talking is detected
+	SWITCH_VAD_FLAG_EVENTS_NOTALK   - Fire events when not talking is detected
+	SWITCH_VAD_FLAG_CNG				- Send CNG
+</pre>
+ */
+typedef enum {
+	SWITCH_VAD_FLAG_TALKING = (1 << 0),
+	SWITCH_VAD_FLAG_EVENTS_TALK = (1 << 1),
+	SWITCH_VAD_FLAG_EVENTS_NOTALK = (1 << 2),
+	SWITCH_VAD_FLAG_CNG = (1 << 3)
+} switch_vad_flag_enum_t;
+typedef uint32_t switch_vad_flag_t;
+
+typedef struct {
+	switch_size_t raw_bytes;
+	switch_size_t media_bytes;
+	switch_size_t packet_count;
+	switch_size_t media_packet_count;
+	switch_size_t skip_packet_count;
+	switch_size_t jb_packet_count;
+	switch_size_t dtmf_packet_count;
+	switch_size_t cng_packet_count;
+	switch_size_t flush_packet_count;
+} switch_rtp_numbers_t;
+
+typedef struct {
+	switch_rtp_numbers_t inbound;
+	switch_rtp_numbers_t outbound;
+} switch_rtp_stats_t;
+
+typedef enum {
+	SWITCH_RTP_FLUSH_ONCE,
+	SWITCH_RTP_FLUSH_STICK,
+	SWITCH_RTP_FLUSH_UNSTICK
+} switch_rtp_flush_t;
+
+#define SWITCH_RTP_CNG_PAYLOAD 13
+
+/*!
+  \enum switch_rtp_flag_t
+  \brief RTP Related Flags
+<pre>
+    SWITCH_RTP_FLAG_NOBLOCK       - Do not block
+    SWITCH_RTP_FLAG_IO            - IO is ready
+	SWITCH_RTP_FLAG_USE_TIMER     - Timeout Reads and replace with a CNG Frame
+	SWITCH_RTP_FLAG_TIMER_RECLOCK - Resync the timer to the current clock on slips
+	SWITCH_RTP_FLAG_SECURE        - Secure RTP
+	SWITCH_RTP_FLAG_AUTOADJ       - Auto-Adjust the dest based on the source
+	SWITCH_RTP_FLAG_RAW_WRITE     - Try to forward packets unscathed
+	SWITCH_RTP_FLAG_GOOGLEHACK    - Convert payload from 102 to 97
+	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
+	SWITCH_RTP_FLAG_BUGGY_2833    - Emulate the bug in cisco equipment to allow interop
+	SWITCH_RTP_FLAG_PASS_RFC2833  - Pass 2833 (ignore it)
+	SWITCH_RTP_FLAG_AUTO_CNG      - Generate outbound CNG frames when idle    
+</pre>
+ */
+typedef enum {
+	SWITCH_RTP_FLAG_NOBLOCK = (1 << 0),
+	SWITCH_RTP_FLAG_IO = (1 << 1),
+	SWITCH_RTP_FLAG_USE_TIMER = (1 << 2),
+	SWITCH_RTP_FLAG_TIMER_RECLOCK = (1 << 3),
+	SWITCH_RTP_FLAG_SECURE_SEND = (1 << 4),
+	SWITCH_RTP_FLAG_SECURE_RECV = (1 << 5),
+	SWITCH_RTP_FLAG_AUTOADJ = (1 << 6),
+	SWITCH_RTP_FLAG_RAW_WRITE = (1 << 7),
+	SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 8),
+	SWITCH_RTP_FLAG_VAD = (1 << 9),
+	SWITCH_RTP_FLAG_BREAK = (1 << 10),
+	SWITCH_RTP_FLAG_MINI = (1 << 11),
+	SWITCH_RTP_FLAG_DATAWAIT = (1 << 12),
+	SWITCH_RTP_FLAG_BUGGY_2833 = (1 << 13),
+	SWITCH_RTP_FLAG_PASS_RFC2833 = (1 << 14),
+	SWITCH_RTP_FLAG_AUTO_CNG = (1 << 15),
+	SWITCH_RTP_FLAG_SECURE_SEND_RESET = (1 << 16),
+	SWITCH_RTP_FLAG_SECURE_RECV_RESET = (1 << 17),
+	SWITCH_RTP_FLAG_PROXY_MEDIA = (1 << 18),
+	SWITCH_RTP_FLAG_SHUTDOWN = (1 << 19),
+	SWITCH_RTP_FLAG_FLUSH = (1 << 20),
+	SWITCH_RTP_FLAG_AUTOFLUSH = (1 << 21),
+	SWITCH_RTP_FLAG_STICKY_FLUSH = (1 << 22),
+	SWITCH_ZRTP_FLAG_SECURE_SEND = (1 << 23),
+	SWITCH_ZRTP_FLAG_SECURE_RECV = (1 << 24),
+	SWITCH_ZRTP_FLAG_SECURE_MITM_SEND = (1 << 25),
+	SWITCH_ZRTP_FLAG_SECURE_MITM_RECV = (1 << 26),
+	SWITCH_RTP_FLAG_DEBUG_RTP_READ = (1 << 27),
+	SWITCH_RTP_FLAG_DEBUG_RTP_WRITE = (1 << 28),
+	SWITCH_RTP_FLAG_VIDEO = (1 << 29),
+	SWITCH_RTP_FLAG_ENABLE_RTCP = (1 << 30),
+	SWITCH_RTP_FLAG_RTCP_PASSTHRU = (1 << 31)
+	/* don't add any more 31 is the limit! gotta chnge to an array to add more */
+} switch_rtp_flag_enum_t;
+typedef uint32_t switch_rtp_flag_t;
+
+typedef enum {
+	RTP_BUG_NONE = 0,			/* won't be using this one much ;) */
+
+	RTP_BUG_CISCO_SKIP_MARK_BIT_2833 = (1 << 0),
+	/* Some Cisco devices get mad when you send the mark bit on new 2833 because it makes
+	   them flush their jitterbuffer and the dtmf along with it.
+
+	   This flag will disable the sending of the mark bit on the first DTMF packet.
+	 */
+
+
+	RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833 = (1 << 1)
+		/*
+		   Sonus wrongly expects that, when sending a multi-packet 2833 DTMF event, The sender
+		   should increment the RTP timestamp in each packet when, in reality, the sender should
+		   send the same exact timestamp and increment the duration field in the 2833 payload.
+		   This allows a reconstruction of the duration if any of the packets are lost.
+
+		   final_duration - initial_timestamp = total_samples
+
+		   However, if the duration value exceeds the space allocated (16 bits), The sender should increment
+		   the timestamp one unit and reset the duration to 0. 
+
+		   Always sending a duration of 0 with a new timestamp should be tolerated but is rarely intentional
+		   and is mistakenly done by many devices.  
+		   The issue is that the Sonus expects everyone to do it this way instead of tolerating either way.
+		   Sonus will actually ignore every packet with the same timestamp before concluding if it's DTMF.
+
+		   This flag will cause each packet to have a new timestamp.
+		 */
+} switch_rtp_bug_flag_t;
+
+#ifdef _MSC_VER
+#pragma pack(push, r1, 1)
+#endif
+
+#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
+typedef struct {
+	unsigned version:2;			/* protocol version       */
+	unsigned p:1;				/* padding flag           */
+	unsigned x:1;				/* header extension flag  */
+	unsigned cc:4;				/* CSRC count             */
+	unsigned m:1;				/* marker bit             */
+	unsigned pt:7;				/* payload type           */
+	unsigned seq:16;			/* sequence number        */
+	unsigned ts:32;				/* timestamp              */
+	unsigned ssrc:32;			/* synchronization source */
+} switch_rtp_hdr_t;
+
+#else /*  BIG_ENDIAN */
+
+typedef struct {
+	unsigned cc:4;				/* CSRC count             */
+	unsigned x:1;				/* header extension flag  */
+	unsigned p:1;				/* padding flag           */
+	unsigned version:2;			/* protocol version       */
+	unsigned pt:7;				/* payload type           */
+	unsigned m:1;				/* marker bit             */
+	unsigned seq:16;			/* sequence number        */
+	unsigned ts:32;				/* timestamp              */
+	unsigned ssrc:32;			/* synchronization source */
+} switch_rtp_hdr_t;
+
+#endif
+
+#ifdef _MSC_VER
+#pragma pack(pop, r1)
+#endif
+
+#ifdef _MSC_VER
+#pragma pack(push, r1, 1)
+#endif
+
+#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
+typedef struct {
+	unsigned version:2;			/* protocol version                  */
+	unsigned p:1;				/* padding flag                      */
+	unsigned count:5;			/* number of reception report blocks */
+	unsigned type:8;			/* packet type                       */
+	unsigned length:16;			/* length in 32-bit words - 1        */
+} switch_rtcp_hdr_t;
+
+#else /*  BIG_ENDIAN */
+
+typedef struct {
+	unsigned count:5;			/* number of reception report blocks */
+	unsigned p:1;				/* padding flag                      */
+	unsigned version:2;			/* protocol version                  */
+	unsigned type:8;			/* packet type                       */
+	unsigned length:16;			/* length in 32-bit words - 1        */
+} switch_rtcp_hdr_t;
+
+#endif
+
+#ifdef _MSC_VER
+#pragma pack(pop, r1)
+#endif
+
+/*!
+  \enum switch_priority_t
+  \brief Priority Indication
+<pre>
+    SWITCH_PRIORITY_NORMAL  - Normal Priority
+    SWITCH_PRIORITY_LOW     - Low Priority
+    SWITCH_PRIORITY_HIGH    - High Priority
+</pre>
+ */
+typedef enum {
+	SWITCH_PRIORITY_NORMAL,
+	SWITCH_PRIORITY_LOW,
+	SWITCH_PRIORITY_HIGH
+} switch_priority_t;
+
+/*!
+  \enum switch_ivr_option_t
+  \brief Possible options related to ivr functions
+<pre>
+    SWITCH_IVR_OPTION_NONE  - nothing whatsoever
+    SWITCH_IVR_OPTION_ASYNC - Asynchronous (do things in the background when applicable)
+	SWITCH_IVR_OPTION_FILE  - string argument implies a filename
+</pre>
+ */
+typedef enum {
+	SWITCH_IVR_OPTION_NONE = 0,
+	SWITCH_IVR_OPTION_ASYNC = (1 << 0),
+	SWITCH_IVR_OPTION_FILE = (1 << 1)
+} switch_ivr_option_enum_t;
+typedef uint32_t switch_ivr_option_t;
+
+/*!
+  \enum switch_core_session_message_types_t
+  \brief Possible types of messages for inter-session communication
+<pre>
+	SWITCH_MESSAGE_REDIRECT_AUDIO     - Indication to redirect audio to another location if possible
+	SWITCH_MESSAGE_TRANSMIT_TEXT      - A text message
+	SWITCH_MESSAGE_INDICATE_ANSWER    - indicate answer
+	SWITCH_MESSAGE_INDICATE_PROGRESS  - indicate progress 
+	SWITCH_MESSAGE_INDICATE_BRIDGE    - indicate a bridge starting
+	SWITCH_MESSAGE_INDICATE_UNBRIDGE  - indicate a bridge ending
+	SWITCH_MESSAGE_INDICATE_TRANSFER  - indicate a transfer is taking place
+	SWITCH_MESSAGE_INDICATE_MEDIA	  - indicate media is required
+	SWITCH_MESSAGE_INDICATE_NOMEDIA	  - indicate no-media is required
+	SWITCH_MESSAGE_INDICATE_HOLD      - indicate hold
+	SWITCH_MESSAGE_INDICATE_UNHOLD    - indicate unhold
+	SWITCH_MESSAGE_INDICATE_REDIRECT  - indicate redirect
+	SWITCH_MESSAGE_INDICATE_RESPOND    - indicate reject
+	SWITCH_MESSAGE_INDICATE_BROADCAST - indicate media broadcast
+	SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT - indicate media broadcast
+	SWITCH_MESSAGE_INDICATE_DEFLECT - indicate deflect
+	SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ - indicate video refresh request
+</pre>
+ */
+typedef enum {
+	SWITCH_MESSAGE_REDIRECT_AUDIO,
+	SWITCH_MESSAGE_TRANSMIT_TEXT,
+	SWITCH_MESSAGE_INDICATE_ANSWER,
+	SWITCH_MESSAGE_INDICATE_PROGRESS,
+	SWITCH_MESSAGE_INDICATE_BRIDGE,
+	SWITCH_MESSAGE_INDICATE_UNBRIDGE,
+	SWITCH_MESSAGE_INDICATE_TRANSFER,
+	SWITCH_MESSAGE_INDICATE_RINGING,
+	SWITCH_MESSAGE_INDICATE_MEDIA,
+	SWITCH_MESSAGE_INDICATE_NOMEDIA,
+	SWITCH_MESSAGE_INDICATE_HOLD,
+	SWITCH_MESSAGE_INDICATE_UNHOLD,
+	SWITCH_MESSAGE_INDICATE_REDIRECT,
+	SWITCH_MESSAGE_INDICATE_RESPOND,
+	SWITCH_MESSAGE_INDICATE_BROADCAST,
+	SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT,
+	SWITCH_MESSAGE_INDICATE_DEFLECT,
+	SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ,
+	SWITCH_MESSAGE_INDICATE_DISPLAY,
+	SWITCH_MESSAGE_INDICATE_TRANSCODING_NECESSARY,
+	SWITCH_MESSAGE_INDICATE_AUDIO_SYNC,
+	SWITCH_MESSAGE_INDICATE_REQUEST_IMAGE_MEDIA,
+	SWITCH_MESSAGE_INDICATE_UUID_CHANGE,
+	SWITCH_MESSAGE_INDICATE_SIMPLIFY,
+	SWITCH_MESSAGE_INDICATE_DEBUG_AUDIO,
+	SWITCH_MESSAGE_INDICATE_PROXY_MEDIA,
+	SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC,
+	SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC_COMPLETE,
+	SWITCH_MESSAGE_INDICATE_PHONE_EVENT,
+	SWITCH_MESSAGE_INVALID
+} switch_core_session_message_types_t;
+
+typedef struct {
+	uint32_t T38MaxBitRate;
+	switch_bool_t T38FaxFillBitRemoval;
+	switch_bool_t T38FaxTranscodingMMR;
+	switch_bool_t T38FaxTranscodingJBIG;
+	const char *T38FaxRateManagement;
+	uint32_t T38FaxMaxBuffer;
+	uint32_t T38FaxMaxDatagram;
+	const char *T38FaxUdpEC;
+	const char *T38VendorInfo;
+	const char *ip;
+	uint32_t port;
+} switch_t38_options_t;
+
+/*!
+  \enum switch_stack_t
+  \brief Expression of how to stack a list
+<pre>
+SWITCH_STACK_BOTTOM - Stack on the bottom
+SWITCH_STACK_TOP	- Stack on the top
+</pre>
+ */
+typedef enum {
+	SWITCH_STACK_BOTTOM,
+	SWITCH_STACK_TOP
+} switch_stack_t;
+
+/*!
+  \enum switch_status_t
+  \brief Common return values
+<pre>
+    SWITCH_STATUS_SUCCESS	- General Success (common return value for most functions)
+    SWITCH_STATUS_FALSE		- General Falsehood
+    SWITCH_STATUS_TIMEOUT	- A Timeout has occured
+    SWITCH_STATUS_RESTART	- An indication to restart the previous operation
+    SWITCH_STATUS_TERM		- An indication to terminate
+    SWITCH_STATUS_NOTIMPL	- An indication that requested resource is not impelemented
+    SWITCH_STATUS_MEMERR	- General memory error
+    SWITCH_STATUS_NOOP		- NOTHING
+    SWITCH_STATUS_RESAMPLE	- An indication that a resample has occured
+    SWITCH_STATUS_GENERR	- A general Error
+    SWITCH_STATUS_INUSE		- An indication that requested resource is in use
+	SWITCH_STATUS_BREAK     - A non-fatal break of an operation
+    SWITCH_STATUS_SOCKERR   - A socket error
+	SWITCH_STATUS_MORE_DATA - Need More Data
+	SWITCH_STATUS_NOTFOUND  - Not Found
+	SWITCH_STATUS_UNLOAD    - Unload
+	SWITCH_STATUS_NOUNLOAD  - Never Unload
+</pre>
+ */
+typedef enum {
+	SWITCH_STATUS_SUCCESS,
+	SWITCH_STATUS_FALSE,
+	SWITCH_STATUS_TIMEOUT,
+	SWITCH_STATUS_RESTART,
+	SWITCH_STATUS_TERM,
+	SWITCH_STATUS_NOTIMPL,
+	SWITCH_STATUS_MEMERR,
+	SWITCH_STATUS_NOOP,
+	SWITCH_STATUS_RESAMPLE,
+	SWITCH_STATUS_GENERR,
+	SWITCH_STATUS_INUSE,
+	SWITCH_STATUS_BREAK,
+	SWITCH_STATUS_SOCKERR,
+	SWITCH_STATUS_MORE_DATA,
+	SWITCH_STATUS_NOTFOUND,
+	SWITCH_STATUS_UNLOAD,
+	SWITCH_STATUS_NOUNLOAD,
+	SWITCH_STATUS_IGNORE,
+	SWITCH_STATUS_TOO_SMALL,
+	SWITCH_STATUS_NOT_INITALIZED
+} switch_status_t;
+
+
+
+/*!
+\enum switch_log_level_t
+\brief Log Level Enumeration
+<pre>
+	SWITCH_LOG_DEBUG            - Debug
+	SWITCH_LOG_INFO             - Info
+	SWITCH_LOG_NOTICE           - Notice
+	SWITCH_LOG_WARNING          - Warning
+	SWITCH_LOG_ERROR            - Error
+	SWITCH_LOG_CRIT             - Critical
+	SWITCH_LOG_ALERT            - Alert
+	SWITCH_LOG_CONSOLE          - Console
+</pre>
+ */
+typedef enum {
+	SWITCH_LOG_DEBUG10 = 110,
+	SWITCH_LOG_DEBUG9 = 109,
+	SWITCH_LOG_DEBUG8 = 108,
+	SWITCH_LOG_DEBUG7 = 107,
+	SWITCH_LOG_DEBUG6 = 106,
+	SWITCH_LOG_DEBUG5 = 105,
+	SWITCH_LOG_DEBUG4 = 104,
+	SWITCH_LOG_DEBUG3 = 103,
+	SWITCH_LOG_DEBUG2 = 102,
+	SWITCH_LOG_DEBUG1 = 101,
+	SWITCH_LOG_DEBUG = 7,
+	SWITCH_LOG_INFO = 6,
+	SWITCH_LOG_NOTICE = 5,
+	SWITCH_LOG_WARNING = 4,
+	SWITCH_LOG_ERROR = 3,
+	SWITCH_LOG_CRIT = 2,
+	SWITCH_LOG_ALERT = 1,
+	SWITCH_LOG_CONSOLE = 0,
+	SWITCH_LOG_INVALID = 64
+} switch_log_level_t;
+
+
+/*!
+\enum switch_text_channel_t
+\brief A target to write log/debug info to
+<pre>
+SWITCH_CHANNEL_ID_LOG			- Write to the currently defined log
+SWITCH_CHANNEL_ID_LOG_CLEAN		- Write to the currently defined log with no extra file/line/date information
+SWITCH_CHANNEL_ID_EVENT			- Write to the event engine as a LOG event
+</pre>
+ */
+typedef enum {
+	SWITCH_CHANNEL_ID_LOG,
+	SWITCH_CHANNEL_ID_LOG_CLEAN,
+	SWITCH_CHANNEL_ID_EVENT,
+	SWITCH_CHANNEL_ID_SESSION
+} switch_text_channel_t;
+
+typedef enum {
+	SCSMF_DYNAMIC = (1 << 0),
+	SCSMF_FREE_STRING_REPLY = (1 << 1),
+	SCSMF_FREE_POINTER_REPLY = (1 << 2)
+} switch_core_session_message_flag_enum_t;
+typedef uint32_t switch_core_session_message_flag_t;
+
+#define SWITCH_CHANNEL_LOG SWITCH_CHANNEL_ID_LOG, __FILE__, __SWITCH_FUNC__, __LINE__, NULL
+#define SWITCH_CHANNEL_LOG_CLEAN SWITCH_CHANNEL_ID_LOG_CLEAN, __FILE__, __SWITCH_FUNC__, __LINE__, NULL
+#define SWITCH_CHANNEL_SESSION_LOG_CLEAN(x) SWITCH_CHANNEL_ID_LOG_CLEAN, __FILE__, __SWITCH_FUNC__, __LINE__, switch_core_session_get_uuid((x))
+#define SWITCH_CHANNEL_EVENT SWITCH_CHANNEL_ID_EVENT, __FILE__, __SWITCH_FUNC__, __LINE__, NULL
+#define SWITCH_CHANNEL_SESSION_LOG(x) SWITCH_CHANNEL_ID_SESSION, __FILE__, __SWITCH_FUNC__, __LINE__, (const char*)(x)
+#define SWITCH_CHANNEL_CHANNEL_LOG(x) SWITCH_CHANNEL_ID_SESSION, __FILE__, __SWITCH_FUNC__, __LINE__, (const char*)switch_channel_get_session(x)
+#define SWITCH_CHANNEL_UUID_LOG(x) SWITCH_CHANNEL_ID_LOG, __FILE__, __SWITCH_FUNC__, __LINE__, (x)
+
+/*!
+  \enum switch_channel_state_t
+  \brief Channel States (these are the defaults, CS_SOFT_EXECUTE, CS_EXCHANGE_MEDIA, and CS_CONSUME_MEDIA are often overridden by specific apps)
+<pre>
+CS_NEW       - Channel is newly created.
+CS_INIT      - Channel has been initilized.
+CS_ROUTING   - Channel is looking for an extension to execute.
+CS_SOFT_EXECUTE  - Channel is ready to execute from 3rd party control.
+CS_EXECUTE   - Channel is executing it's dialplan.
+CS_EXCHANGE_MEDIA  - Channel is exchanging media with another channel.
+CS_PARK      - Channel is accepting media awaiting commands.
+CS_CONSUME_MEDIA		 - Channel is consuming all media and dropping it.
+CS_HIBERNATE - Channel is in a sleep state.
+CS_RESET 	 - Channel is in a reset state.
+CS_HANGUP    - Channel is flagged for hangup and ready to end.
+CS_REPORTING - Channel is ready to collect call detail.
+CS_DESTROY      - Channel is ready to be destroyed and out of the state machine
+</pre>
+ */
+typedef enum {
+	CS_NEW,
+	CS_INIT,
+	CS_ROUTING,
+	CS_SOFT_EXECUTE,
+	CS_EXECUTE,
+	CS_EXCHANGE_MEDIA,
+	CS_PARK,
+	CS_CONSUME_MEDIA,
+	CS_HIBERNATE,
+	CS_RESET,
+	CS_HANGUP,
+	CS_REPORTING,
+	CS_DESTROY,
+	CS_NONE
+} switch_channel_state_t;
+
+
+/*!
+  \enum switch_channel_flag_t
+  \brief Channel Flags
+
+<pre>
+CF_ANSWERED			- Channel is answered
+CF_OUTBOUND			- Channel is an outbound channel
+CF_EARLY_MEDIA		- Channel is ready for audio before answer 
+CF_ORIGINATOR		- Channel is an originator
+CF_TRANSFER			- Channel is being transfered
+CF_ACCEPT_CNG		- Channel will accept CNG frames
+CF_REDIRECT 		- Channel is being redirected
+CF_BRIDGED			- Channel in a bridge
+CF_HOLD				- Channel is on hold
+CF_SERVICE			- Channel has a service thread
+CF_TAGGED			- Channel is tagged
+CF_WINNER			- Channel is the winner
+CF_CONTROLLED		- Channel is under control
+CF_PROXY_MODE		- Channel has no media
+CF_SUSPEND			- Suspend i/o
+CF_EVENT_PARSE		- Suspend control events
+CF_GEN_RINGBACK		- Channel is generating it's own ringback
+CF_RING_READY		- Channel is ready to send ringback
+CF_BREAK			- Channel should stop what it's doing
+CF_BROADCAST		- Channel is broadcasting
+CF_UNICAST			- Channel has a unicast connection
+CF_VIDEO			- Channel has video
+CF_EVENT_LOCK		- Don't parse events
+CF_RESET			- Tell extension parser to reset
+CF_ORIGINATING		- Channel is originating
+CF_STOP_BROADCAST	- Signal to stop broadcast
+</pre>
+ */
+
+typedef enum {
+	CC_MEDIA_ACK = 1,
+	CC_BYPASS_MEDIA,
+	CC_PROXY_MEDIA,
+	/* WARNING: DO NOT ADD ANY FLAGS BELOW THIS LINE */
+	CC_FLAG_MAX
+} switch_channel_cap_t;
+
+typedef enum {
+	CF_ANSWERED = 1,
+	CF_OUTBOUND,
+	CF_EARLY_MEDIA,
+	CF_BRIDGE_ORIGINATOR,
+	CF_TRANSFER,
+	CF_ACCEPT_CNG,
+	CF_REDIRECT,
+	CF_BRIDGED,
+	CF_HOLD,
+	CF_SERVICE,
+	CF_TAGGED,
+	CF_WINNER,
+	CF_CONTROLLED,
+	CF_PROXY_MODE,
+	CF_SUSPEND,
+	CF_EVENT_PARSE,
+	CF_GEN_RINGBACK,
+	CF_RING_READY,
+	CF_BREAK,
+	CF_BROADCAST,
+	CF_UNICAST,
+	CF_VIDEO,
+	CF_EVENT_LOCK,
+	CF_EVENT_LOCK_PRI,
+	CF_RESET,
+	CF_ORIGINATING,
+	CF_STOP_BROADCAST,
+	CF_PROXY_MEDIA,
+	CF_INNER_BRIDGE,
+	CF_REQ_MEDIA,
+	CF_VERBOSE_EVENTS,
+	CF_PAUSE_BUGS,
+	CF_DIVERT_EVENTS,
+	CF_BLOCK_STATE,
+	CF_FS_RTP,
+	CF_REPORTING,
+	CF_PARK,
+	CF_TIMESTAMP_SET,
+	CF_ORIGINATOR,
+	CF_XFER_ZOMBIE,
+	CF_MEDIA_ACK,
+	CF_THREAD_SLEEPING,
+	CF_DISABLE_RINGBACK,
+	CF_NOT_READY,
+	CF_SIGNAL_BRIDGE_TTL,
+	CF_MEDIA_BRIDGE_TTL,
+	CF_BYPASS_MEDIA_AFTER_BRIDGE,
+	CF_LEG_HOLDING,
+	CF_BROADCAST_DROP_MEDIA,
+	CF_EARLY_HANGUP,
+	CF_MEDIA_SET,
+	/* WARNING: DO NOT ADD ANY FLAGS BELOW THIS LINE */
+	CF_FLAG_MAX
+} switch_channel_flag_t;
+
+
+typedef enum {
+	CF_APP_TAGGED = (1 << 0)
+} switch_channel_app_flag_t;
+
+
+/*!
+  \enum switch_frame_flag_t
+  \brief Frame Flags
+
+<pre>
+SFF_CNG        = (1 <<  0) - Frame represents comfort noise
+SFF_RAW_RTP    = (1 <<  1) - Frame has raw rtp accessible
+SFF_RTP_HEADER = (1 << 2)  - Get the rtp header from the frame header
+SFF_PLC        = (1 << 3)  - Frame has generated PLC data
+SFF_RFC2833    = (1 << 4)  - Frame has rfc2833 dtmf data
+SFF_DYNAMIC    = (1 << 5)  - Frame is dynamic and should be freed
+</pre>
+ */
+typedef enum {
+	SFF_NONE = 0,
+	SFF_CNG = (1 << 0),
+	SFF_RAW_RTP = (1 << 1),
+	SFF_RTP_HEADER = (1 << 2),
+	SFF_PLC = (1 << 3),
+	SFF_RFC2833 = (1 << 4),
+	SFF_PROXY_PACKET = (1 << 5),
+	SFF_DYNAMIC = (1 << 6),
+	SFF_ZRTP = (1 << 7)
+} switch_frame_flag_enum_t;
+typedef uint32_t switch_frame_flag_t;
+
+
+typedef enum {
+	SAF_NONE = 0,
+	SAF_SUPPORT_NOMEDIA = (1 << 0),
+	SAF_ROUTING_EXEC = (1 << 1),
+	SAF_MEDIA_TAP = (1 << 2)
+} switch_application_flag_enum_t;
+typedef uint32_t switch_application_flag_t;
+
+/*!
+  \enum switch_signal_t
+  \brief Signals to send to channels
+<pre>
+SWITCH_SIG_KILL - Kill the channel
+SWITCH_SIG_XFER - Stop the current io but leave it viable
+</pre>
+ */
+
+typedef enum {
+	SWITCH_SIG_NONE,
+	SWITCH_SIG_KILL,
+	SWITCH_SIG_XFER,
+	SWITCH_SIG_BREAK
+} switch_signal_t;
+
+/*!
+  \enum switch_codec_flag_t
+  \brief Codec related flags
+<pre>
+SWITCH_CODEC_FLAG_ENCODE =			(1 <<  0) - Codec can encode
+SWITCH_CODEC_FLAG_DECODE =			(1 <<  1) - Codec can decode
+SWITCH_CODEC_FLAG_SILENCE_START =	(1 <<  2) - Start period of silence
+SWITCH_CODEC_FLAG_SILENCE_STOP =	(1 <<  3) - End period of silence
+SWITCH_CODEC_FLAG_SILENCE =			(1 <<  4) - Silence
+SWITCH_CODEC_FLAG_FREE_POOL =		(1 <<  5) - Free codec's pool on destruction
+SWITCH_CODEC_FLAG_AAL2 =			(1 <<  6) - USE AAL2 Bitpacking
+SWITCH_CODEC_FLAG_PASSTHROUGH =		(1 <<  7) - Passthrough only
+</pre>
+*/
+typedef enum {
+	SWITCH_CODEC_FLAG_ENCODE = (1 << 0),
+	SWITCH_CODEC_FLAG_DECODE = (1 << 1),
+	SWITCH_CODEC_FLAG_SILENCE_START = (1 << 2),
+	SWITCH_CODEC_FLAG_SILENCE_STOP = (1 << 3),
+	SWITCH_CODEC_FLAG_SILENCE = (1 << 4),
+	SWITCH_CODEC_FLAG_FREE_POOL = (1 << 5),
+	SWITCH_CODEC_FLAG_AAL2 = (1 << 6),
+	SWITCH_CODEC_FLAG_PASSTHROUGH = (1 << 7),
+	SWITCH_CODEC_FLAG_READY = (1 << 8)
+} switch_codec_flag_enum_t;
+typedef uint32_t switch_codec_flag_t;
+
+
+/*!
+  \enum switch_speech_flag_t
+  \brief Speech related flags
+<pre>
+SWITCH_SPEECH_FLAG_HASTEXT =		(1 <<  0) - Interface is has text to read.
+SWITCH_SPEECH_FLAG_PEEK =			(1 <<  1) - Read data but do not erase it.
+SWITCH_SPEECH_FLAG_FREE_POOL =		(1 <<  2) - Free interface's pool on destruction.
+SWITCH_SPEECH_FLAG_BLOCKING =       (1 <<  3) - Indicate that a blocking call is desired 
+SWITCH_SPEECH_FLAG_PAUSE = 			(1 <<  4) - Pause toggle for playback
+</pre>
+*/
+typedef enum {
+	SWITCH_SPEECH_FLAG_NONE = 0,
+	SWITCH_SPEECH_FLAG_HASTEXT = (1 << 0),
+	SWITCH_SPEECH_FLAG_PEEK = (1 << 1),
+	SWITCH_SPEECH_FLAG_FREE_POOL = (1 << 2),
+	SWITCH_SPEECH_FLAG_BLOCKING = (1 << 3),
+	SWITCH_SPEECH_FLAG_PAUSE = (1 << 4),
+	SWITCH_SPEECH_FLAG_OPEN = (1 << 5),
+	SWITCH_SPEECH_FLAG_DONE = (1 << 6)
+} switch_speech_flag_enum_t;
+typedef uint32_t switch_speech_flag_t;
+
+/*!
+  \enum switch_asr_flag_t
+  \brief Asr related flags
+<pre>
+SWITCH_ASR_FLAG_DATA =			(1 <<  0) - Interface has data
+SWITCH_ASR_FLAG_FREE_POOL =		(1 <<  1) - Pool needs to be freed
+SWITCH_ASR_FLAG_CLOSED = 		(1 <<  2) - Interface has been closed
+SWITCH_ASR_FLAG_FIRE_EVENTS =	(1 <<  3) - Fire all speech events
+SWITCH_ASR_FLAG_AUTO_RESUME =   (1 <<  4) - Auto Resume
+</pre>
+*/
+typedef enum {
+	SWITCH_ASR_FLAG_NONE = 0,
+	SWITCH_ASR_FLAG_DATA = (1 << 0),
+	SWITCH_ASR_FLAG_FREE_POOL = (1 << 1),
+	SWITCH_ASR_FLAG_CLOSED = (1 << 2),
+	SWITCH_ASR_FLAG_FIRE_EVENTS = (1 << 3),
+	SWITCH_ASR_FLAG_AUTO_RESUME = (1 << 4)
+
+} switch_asr_flag_enum_t;
+typedef uint32_t switch_asr_flag_t;
+
+/*!
+  \enum switch_directory_flag_t
+  \brief Directory Handle related flags
+<pre>
+SWITCH_DIRECTORY_FLAG_FREE_POOL =		(1 <<  0) - Free interface's pool on destruction.
+</pre>
+*/
+typedef enum {
+	SWITCH_DIRECTORY_FLAG_FREE_POOL = (1 << 0)
+
+} switch_directory_flag_enum_t;
+typedef uint32_t switch_directory_flag_t;
+
+/*!
+  \enum switch_codec_type_t
+  \brief Codec types
+<pre>
+SWITCH_CODEC_TYPE_AUDIO - Audio Codec
+SWITCH_CODEC_TYPE_VIDEO - Video Codec
+SWITCH_CODEC_TYPE_T38   - T38 Codec
+SWITCH_CODEC_TYPE_APP   - Application Codec
+</pre>
+ */
+typedef enum {
+	SWITCH_CODEC_TYPE_AUDIO,
+	SWITCH_CODEC_TYPE_VIDEO,
+	SWITCH_CODEC_TYPE_T38,
+	SWITCH_CODEC_TYPE_APP
+} switch_codec_type_t;
+
+
+/*!
+  \enum switch_timer_flag_t
+  \brief Timer related flags
+<pre>
+SWITCH_TIMER_FLAG_FREE_POOL =		(1 <<  0) - Free timer's pool on destruction
+</pre>
+*/
+typedef enum {
+	SWITCH_TIMER_FLAG_FREE_POOL = (1 << 0)
+} switch_timer_flag_enum_t;
+typedef uint32_t switch_timer_flag_t;
+
+
+/*!
+  \enum switch_timer_flag_t
+  \brief Timer related flags
+<pre>
+SMBF_READ_STREAM - Include the Read Stream
+SMBF_WRITE_STREAM - Include the Write Stream
+SMBF_WRITE_REPLACE - Replace the Write Stream
+SMBF_READ_REPLACE - Replace the Read Stream
+SMBF_STEREO - Record in stereo
+SMBF_ANSWER_RECORD_REQ - Don't record until the channel is answered
+SMBF_THREAD_LOCK - Only let the same thread who created the bug remove it.
+</pre>
+*/
+typedef enum {
+	SMBF_BOTH = 0,
+	SMBF_READ_STREAM = (1 << 0),
+	SMBF_WRITE_STREAM = (1 << 1),
+	SMBF_WRITE_REPLACE = (1 << 2),
+	SMBF_READ_REPLACE = (1 << 3),
+	SMBF_READ_PING = (1 << 4),
+	SMBF_STEREO = (1 << 5),
+	SMBF_ANSWER_REQ = (1 << 6),
+	SMBF_THREAD_LOCK = (1 << 7),
+	SMBF_PRUNE = (1 << 8)
+} switch_media_bug_flag_enum_t;
+typedef uint32_t switch_media_bug_flag_t;
+
+/*!
+  \enum switch_file_flag_t
+  \brief File flags
+<pre>
+SWITCH_FILE_FLAG_READ =         (1 <<  0) - Open for read
+SWITCH_FILE_FLAG_WRITE =        (1 <<  1) - Open for write
+SWITCH_FILE_FLAG_FREE_POOL =    (1 <<  2) - Free file handle's pool on destruction
+SWITCH_FILE_DATA_SHORT =        (1 <<  3) - Read data in shorts
+SWITCH_FILE_DATA_INT =          (1 <<  4) - Read data in ints
+SWITCH_FILE_DATA_FLOAT =        (1 <<  5) - Read data in floats
+SWITCH_FILE_DATA_DOUBLE =       (1 <<  6) - Read data in doubles
+SWITCH_FILE_DATA_RAW =          (1 <<  7) - Read data as is
+SWITCH_FILE_PAUSE =             (1 <<  8) - Pause
+SWITCH_FILE_NATIVE =            (1 <<  9) - File is in native format (no transcoding)
+SWITCH_FILE_SEEK = 				(1 << 10) - File has done a seek
+SWITCH_FILE_OPEN =              (1 << 11) - File is open
+</pre>
+ */
+typedef enum {
+	SWITCH_FILE_FLAG_READ = (1 << 0),
+	SWITCH_FILE_FLAG_WRITE = (1 << 1),
+	SWITCH_FILE_FLAG_FREE_POOL = (1 << 2),
+	SWITCH_FILE_DATA_SHORT = (1 << 3),
+	SWITCH_FILE_DATA_INT = (1 << 4),
+	SWITCH_FILE_DATA_FLOAT = (1 << 5),
+	SWITCH_FILE_DATA_DOUBLE = (1 << 6),
+	SWITCH_FILE_DATA_RAW = (1 << 7),
+	SWITCH_FILE_PAUSE = (1 << 8),
+	SWITCH_FILE_NATIVE = (1 << 9),
+	SWITCH_FILE_SEEK = (1 << 10),
+	SWITCH_FILE_OPEN = (1 << 11),
+	SWITCH_FILE_CALLBACK = (1 << 12),
+	SWITCH_FILE_DONE = (1 << 13),
+	SWITCH_FILE_BUFFER_DONE = (1 << 14),
+	SWITCH_FILE_WRITE_APPEND = (1 << 15)
+} switch_file_flag_enum_t;
+typedef uint32_t switch_file_flag_t;
+
+typedef enum {
+	SWITCH_IO_FLAG_NONE = 0,
+	SWITCH_IO_FLAG_NOBLOCK = (1 << 0)
+} switch_io_flag_enum_t;
+typedef uint32_t switch_io_flag_t;
+
+/* make sure this is synced with the EVENT_NAMES array in switch_event.c
+   also never put any new ones before EVENT_ALL
+*/
+/*!
+  \enum switch_event_types_t
+  \brief Built-in Events
+
+<pre>
+    SWITCH_EVENT_CUSTOM				- A custom event
+    SWITCH_EVENT_CHANNEL_CREATE		- A channel has been created
+    SWITCH_EVENT_CHANNEL_DESTROY	- A channel has been destroyed
+    SWITCH_EVENT_CHANNEL_STATE		- A channel has changed state
+    SWITCH_EVENT_CHANNEL_ANSWER		- A channel has been answered
+    SWITCH_EVENT_CHANNEL_HANGUP		- A channel has been hungup
+    SWITCH_EVENT_CHANNEL_EXECUTE	- A channel has executed a module's application
+    SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE	- A channel has finshed executing a module's application
+	SWITCH_EVENT_CHANNEL_BRIDGE     - A channel has bridged to another channel
+	SWITCH_EVENT_CHANNEL_UNBRIDGE   - A channel has unbridged from another channel
+    SWITCH_EVENT_CHANNEL_PROGRESS	- A channel has started ringing
+    SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA	- A channel has started early media
+    SWITCH_EVENT_CHANNEL_OUTGOING	- A channel has been unparked
+	SWITCH_EVENT_CHANNEL_PARK 		- A channel has been parked
+	SWITCH_EVENT_CHANNEL_UNPARK 	- A channel has been unparked
+	SWITCH_EVENT_CHANNEL_APPLICATION- A channel has called and event from an application
+	SWITCH_EVENT_CHANNEL_ORIGINATE  - A channel has been originated
+	SWITCH_EVENT_CHANNEL_UUID       - A channel has changed uuid
+    SWITCH_EVENT_API				- An API call has been executed
+    SWITCH_EVENT_LOG				- A LOG event has been triggered
+    SWITCH_EVENT_INBOUND_CHAN		- A new inbound channel has been created
+    SWITCH_EVENT_OUTBOUND_CHAN		- A new outbound channel has been created
+    SWITCH_EVENT_STARTUP			- The system has been started
+    SWITCH_EVENT_SHUTDOWN			- The system has been shutdown
+	SWITCH_EVENT_PUBLISH			- Publish
+	SWITCH_EVENT_UNPUBLISH			- UnPublish
+	SWITCH_EVENT_TALK				- Talking Detected
+	SWITCH_EVENT_NOTALK				- Not Talking Detected
+	SWITCH_EVENT_SESSION_CRASH		- Session Crashed
+	SWITCH_EVENT_MODULE_LOAD		- Module was loaded
+	SWITCH_EVENT_MODULE_UNLOAD		- Module was unloaded
+	SWITCH_EVENT_DTMF				- DTMF was sent
+	SWITCH_EVENT_MESSAGE			- A Basic Message
+	SWITCH_EVENT_PRESENCE_IN		- Presence in
+	SWITCH_EVENT_NOTIFY_IN			- Received incoming NOTIFY from gateway subscription
+	SWITCH_EVENT_PRESENCE_OUT		- Presence out
+	SWITCH_EVENT_PRESENCE_PROBE		- Presence probe
+	SWITCH_EVENT_MESSAGE_WAITING	- A message is waiting
+	SWITCH_EVENT_MESSAGE_QUERY		- A query for MESSAGE_WAITING events
+	SWITCH_EVENT_CODEC				- Codec Change
+	SWITCH_EVENT_BACKGROUND_JOB		- Background Job
+	SWITCH_EVENT_DETECTED_SPEECH	- Detected Speech
+	SWITCH_EVENT_DETECTED_TONE      - Detected Tone
+	SWITCH_EVENT_PRIVATE_COMMAND	- A private command event 
+	SWITCH_EVENT_HEARTBEAT			- Machine is alive
+	SWITCH_EVENT_TRAP				- Error Trap
+	SWITCH_EVENT_ADD_SCHEDULE		- Something has been scheduled
+	SWITCH_EVENT_DEL_SCHEDULE		- Something has been unscheduled
+	SWITCH_EVENT_EXE_SCHEDULE		- Something scheduled has been executed
+	SWITCH_EVENT_RE_SCHEDULE		- Something scheduled has been rescheduled
+	SWITCH_EVENT_RELOADXML			- XML registry has been reloaded
+	SWITCH_EVENT_NOTIFY				- Notification
+	SWITCH_EVENT_SEND_MESSAGE		- Message
+	SWITCH_EVENT_RECV_MESSAGE		- Message
+	SWITCH_EVENT_NAT            - NAT Management (new/del/status)
+	SWITCH_EVENT_FAILURE            - A failure occurred which might impact the normal functioning of the switch
+    SWITCH_EVENT_ALL				- All events at once
+</pre>
+
+ */
+typedef enum {
+	SWITCH_EVENT_CUSTOM,
+	SWITCH_EVENT_CLONE,
+	SWITCH_EVENT_CHANNEL_CREATE,
+	SWITCH_EVENT_CHANNEL_DESTROY,
+	SWITCH_EVENT_CHANNEL_STATE,
+	SWITCH_EVENT_CHANNEL_ANSWER,
+	SWITCH_EVENT_CHANNEL_HANGUP,
+	SWITCH_EVENT_CHANNEL_HANGUP_COMPLETE,
+	SWITCH_EVENT_CHANNEL_EXECUTE,
+	SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE,
+	SWITCH_EVENT_CHANNEL_BRIDGE,
+	SWITCH_EVENT_CHANNEL_UNBRIDGE,
+	SWITCH_EVENT_CHANNEL_PROGRESS,
+	SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA,
+	SWITCH_EVENT_CHANNEL_OUTGOING,
+	SWITCH_EVENT_CHANNEL_PARK,
+	SWITCH_EVENT_CHANNEL_UNPARK,
+	SWITCH_EVENT_CHANNEL_APPLICATION,
+	SWITCH_EVENT_CHANNEL_ORIGINATE,
+	SWITCH_EVENT_CHANNEL_UUID,
+	SWITCH_EVENT_API,
+	SWITCH_EVENT_LOG,
+	SWITCH_EVENT_INBOUND_CHAN,
+	SWITCH_EVENT_OUTBOUND_CHAN,
+	SWITCH_EVENT_STARTUP,
+	SWITCH_EVENT_SHUTDOWN,
+	SWITCH_EVENT_PUBLISH,
+	SWITCH_EVENT_UNPUBLISH,
+	SWITCH_EVENT_TALK,
+	SWITCH_EVENT_NOTALK,
+	SWITCH_EVENT_SESSION_CRASH,
+	SWITCH_EVENT_MODULE_LOAD,
+	SWITCH_EVENT_MODULE_UNLOAD,
+	SWITCH_EVENT_DTMF,
+	SWITCH_EVENT_MESSAGE,
+	SWITCH_EVENT_PRESENCE_IN,
+	SWITCH_EVENT_NOTIFY_IN,
+	SWITCH_EVENT_PRESENCE_OUT,
+	SWITCH_EVENT_PRESENCE_PROBE,
+	SWITCH_EVENT_MESSAGE_WAITING,
+	SWITCH_EVENT_MESSAGE_QUERY,
+	SWITCH_EVENT_ROSTER,
+	SWITCH_EVENT_CODEC,
+	SWITCH_EVENT_BACKGROUND_JOB,
+	SWITCH_EVENT_DETECTED_SPEECH,
+	SWITCH_EVENT_DETECTED_TONE,
+	SWITCH_EVENT_PRIVATE_COMMAND,
+	SWITCH_EVENT_HEARTBEAT,
+	SWITCH_EVENT_TRAP,
+	SWITCH_EVENT_ADD_SCHEDULE,
+	SWITCH_EVENT_DEL_SCHEDULE,
+	SWITCH_EVENT_EXE_SCHEDULE,
+	SWITCH_EVENT_RE_SCHEDULE,
+	SWITCH_EVENT_RELOADXML,
+	SWITCH_EVENT_NOTIFY,
+	SWITCH_EVENT_SEND_MESSAGE,
+	SWITCH_EVENT_RECV_MESSAGE,
+	SWITCH_EVENT_REQUEST_PARAMS,
+	SWITCH_EVENT_CHANNEL_DATA,
+	SWITCH_EVENT_GENERAL,
+	SWITCH_EVENT_COMMAND,
+	SWITCH_EVENT_SESSION_HEARTBEAT,
+	SWITCH_EVENT_CLIENT_DISCONNECTED,
+	SWITCH_EVENT_SERVER_DISCONNECTED,
+	SWITCH_EVENT_SEND_INFO,
+	SWITCH_EVENT_RECV_INFO,
+	SWITCH_EVENT_RECV_RTCP_MESSAGE,
+	SWITCH_EVENT_CALL_SECURE,
+	SWITCH_EVENT_NAT,
+	SWITCH_EVENT_RECORD_START,
+	SWITCH_EVENT_RECORD_STOP,
+	SWITCH_EVENT_CALL_UPDATE,
+	SWITCH_EVENT_FAILURE,
+	SWITCH_EVENT_SOCKET_DATA,
+	SWITCH_EVENT_MEDIA_BUG_START,
+	SWITCH_EVENT_MEDIA_BUG_STOP,
+	SWITCH_EVENT_ALL
+} switch_event_types_t;
+
+typedef enum {
+	SWITCH_INPUT_TYPE_DTMF,
+	SWITCH_INPUT_TYPE_EVENT
+} switch_input_type_t;
+
+typedef enum {
+	SWITCH_CAUSE_NONE = 0,
+	SWITCH_CAUSE_UNALLOCATED_NUMBER = 1,
+	SWITCH_CAUSE_NO_ROUTE_TRANSIT_NET = 2,
+	SWITCH_CAUSE_NO_ROUTE_DESTINATION = 3,
+	SWITCH_CAUSE_CHANNEL_UNACCEPTABLE = 6,
+	SWITCH_CAUSE_CALL_AWARDED_DELIVERED = 7,
+	SWITCH_CAUSE_NORMAL_CLEARING = 16,
+	SWITCH_CAUSE_USER_BUSY = 17,
+	SWITCH_CAUSE_NO_USER_RESPONSE = 18,
+	SWITCH_CAUSE_NO_ANSWER = 19,
+	SWITCH_CAUSE_SUBSCRIBER_ABSENT = 20,
+	SWITCH_CAUSE_CALL_REJECTED = 21,
+	SWITCH_CAUSE_NUMBER_CHANGED = 22,
+	SWITCH_CAUSE_REDIRECTION_TO_NEW_DESTINATION = 23,
+	SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR = 25,
+	SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER = 27,
+	SWITCH_CAUSE_INVALID_NUMBER_FORMAT = 28,
+	SWITCH_CAUSE_FACILITY_REJECTED = 29,
+	SWITCH_CAUSE_RESPONSE_TO_STATUS_ENQUIRY = 30,
+	SWITCH_CAUSE_NORMAL_UNSPECIFIED = 31,
+	SWITCH_CAUSE_NORMAL_CIRCUIT_CONGESTION = 34,
+	SWITCH_CAUSE_NETWORK_OUT_OF_ORDER = 38,
+	SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE = 41,
+	SWITCH_CAUSE_SWITCH_CONGESTION = 42,
+	SWITCH_CAUSE_ACCESS_INFO_DISCARDED = 43,
+	SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL = 44,
+	SWITCH_CAUSE_PRE_EMPTED = 45,
+	SWITCH_CAUSE_FACILITY_NOT_SUBSCRIBED = 50,
+	SWITCH_CAUSE_OUTGOING_CALL_BARRED = 52,
+	SWITCH_CAUSE_INCOMING_CALL_BARRED = 54,
+	SWITCH_CAUSE_BEARERCAPABILITY_NOTAUTH = 57,
+	SWITCH_CAUSE_BEARERCAPABILITY_NOTAVAIL = 58,
+	SWITCH_CAUSE_SERVICE_UNAVAILABLE = 63,
+	SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL = 65,
+	SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED = 66,
+	SWITCH_CAUSE_FACILITY_NOT_IMPLEMENTED = 69,
+	SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED = 79,
+	SWITCH_CAUSE_INVALID_CALL_REFERENCE = 81,
+	SWITCH_CAUSE_INCOMPATIBLE_DESTINATION = 88,
+	SWITCH_CAUSE_INVALID_MSG_UNSPECIFIED = 95,
+	SWITCH_CAUSE_MANDATORY_IE_MISSING = 96,
+	SWITCH_CAUSE_MESSAGE_TYPE_NONEXIST = 97,
+	SWITCH_CAUSE_WRONG_MESSAGE = 98,
+	SWITCH_CAUSE_IE_NONEXIST = 99,
+	SWITCH_CAUSE_INVALID_IE_CONTENTS = 100,
+	SWITCH_CAUSE_WRONG_CALL_STATE = 101,
+	SWITCH_CAUSE_RECOVERY_ON_TIMER_EXPIRE = 102,
+	SWITCH_CAUSE_MANDATORY_IE_LENGTH_ERROR = 103,
+	SWITCH_CAUSE_PROTOCOL_ERROR = 111,
+	SWITCH_CAUSE_INTERWORKING = 127,
+	SWITCH_CAUSE_SUCCESS = 142,
+	SWITCH_CAUSE_ORIGINATOR_CANCEL = 487,
+	SWITCH_CAUSE_CRASH = 500,
+	SWITCH_CAUSE_SYSTEM_SHUTDOWN = 501,
+	SWITCH_CAUSE_LOSE_RACE = 502,
+	SWITCH_CAUSE_MANAGER_REQUEST = 503,
+	SWITCH_CAUSE_BLIND_TRANSFER = 600,
+	SWITCH_CAUSE_ATTENDED_TRANSFER = 601,
+	SWITCH_CAUSE_ALLOTTED_TIMEOUT = 602,
+	SWITCH_CAUSE_USER_CHALLENGE = 603,
+	SWITCH_CAUSE_MEDIA_TIMEOUT = 604,
+	SWITCH_CAUSE_PICKED_OFF = 605,
+	SWITCH_CAUSE_USER_NOT_REGISTERED = 606,
+	SWITCH_CAUSE_PROGRESS_TIMEOUT = 607
+} switch_call_cause_t;
+
+typedef enum {
+	SCSC_PAUSE_INBOUND,
+	SCSC_HUPALL,
+	SCSC_SHUTDOWN,
+	SCSC_CHECK_RUNNING,
+	SCSC_LOGLEVEL,
+	SCSC_SPS,
+	SCSC_LAST_SPS,
+	SCSC_RECLAIM,
+	SCSC_MAX_SESSIONS,
+	SCSC_SYNC_CLOCK,
+	SCSC_MAX_DTMF_DURATION,
+	SCSC_MIN_DTMF_DURATION,
+	SCSC_DEFAULT_DTMF_DURATION,
+	SCSC_SHUTDOWN_ELEGANT,
+	SCSC_SHUTDOWN_ASAP,
+	SCSC_CANCEL_SHUTDOWN,
+	SCSC_SEND_SIGHUP,
+	SCSC_DEBUG_LEVEL,
+	SCSC_FLUSH_DB_HANDLES,
+	SCSC_SHUTDOWN_NOW,
+	SCSC_CALIBRATE_CLOCK,
+	SCSC_SAVE_HISTORY,
+	SCSC_CRASH,
+	SCSC_MIN_IDLE_CPU
+} switch_session_ctl_t;
+
+typedef enum {
+	SSH_FLAG_STICKY = (1 << 0)
+} switch_state_handler_flag_t;
+
+typedef struct apr_pool_t switch_memory_pool_t;
+typedef uint16_t switch_port_t;
+typedef uint8_t switch_payload_t;
+typedef struct switch_app_log switch_app_log_t;
+typedef struct switch_rtp switch_rtp_t;
+typedef struct switch_rtcp switch_rtcp_t;
+typedef struct switch_core_session_message switch_core_session_message_t;
+typedef struct switch_event_header switch_event_header_t;
+typedef struct switch_event switch_event_t;
+typedef struct switch_event_subclass switch_event_subclass_t;
+typedef struct switch_event_node switch_event_node_t;
+typedef struct switch_loadable_module switch_loadable_module_t;
+typedef struct switch_frame switch_frame_t;
+typedef struct switch_rtcp_frame switch_rtcp_frame_t;
+typedef struct switch_channel switch_channel_t;
+typedef struct switch_file_handle switch_file_handle_t;
+typedef struct switch_core_session switch_core_session_t;
+typedef struct switch_caller_profile switch_caller_profile_t;
+typedef struct switch_caller_extension switch_caller_extension_t;
+typedef struct switch_caller_application switch_caller_application_t;
+typedef struct switch_state_handler_table switch_state_handler_table_t;
+typedef struct switch_timer switch_timer_t;
+typedef struct switch_codec switch_codec_t;
+typedef struct switch_core_thread_session switch_core_thread_session_t;
+typedef struct switch_codec_implementation switch_codec_implementation_t;
+typedef struct switch_buffer switch_buffer_t;
+typedef struct switch_codec_settings switch_codec_settings_t;
+typedef struct switch_odbc_handle switch_odbc_handle_t;
+
+typedef struct switch_io_routines switch_io_routines_t;
+typedef struct switch_speech_handle switch_speech_handle_t;
+typedef struct switch_asr_handle switch_asr_handle_t;
+typedef struct switch_directory_handle switch_directory_handle_t;
+typedef struct switch_loadable_module_interface switch_loadable_module_interface_t;
+typedef struct switch_endpoint_interface switch_endpoint_interface_t;
+typedef struct switch_timer_interface switch_timer_interface_t;
+typedef struct switch_dialplan_interface switch_dialplan_interface_t;
+typedef struct switch_codec_interface switch_codec_interface_t;
+typedef struct switch_application_interface switch_application_interface_t;
+typedef struct switch_api_interface switch_api_interface_t;
+typedef struct switch_file_interface switch_file_interface_t;
+typedef struct switch_speech_interface switch_speech_interface_t;
+typedef struct switch_asr_interface switch_asr_interface_t;
+typedef struct switch_directory_interface switch_directory_interface_t;
+typedef struct switch_chat_interface switch_chat_interface_t;
+typedef struct switch_management_interface switch_management_interface_t;
+typedef struct switch_core_port_allocator switch_core_port_allocator_t;
+typedef struct switch_media_bug switch_media_bug_t;
+
+struct switch_console_callback_match_node {
+	char *val;
+	struct switch_console_callback_match_node *next;
+};
+typedef struct switch_console_callback_match_node switch_console_callback_match_node_t;
+
+struct switch_console_callback_match {
+	struct switch_console_callback_match_node *head;
+	struct switch_console_callback_match_node *end;
+	int count;
+	int dynamic;
+};
+typedef struct switch_console_callback_match switch_console_callback_match_t;
+
+typedef switch_status_t (*switch_console_complete_callback_t) (const char *, const char *, switch_console_callback_match_t **matches);
+typedef switch_bool_t (*switch_media_bug_callback_t) (switch_media_bug_t *, void *, switch_abc_type_t);
+typedef switch_bool_t (*switch_tone_detect_callback_t) (switch_core_session_t *, const char *, const char *);
+typedef struct switch_xml_binding switch_xml_binding_t;
+
+typedef switch_status_t (*switch_core_codec_encode_func_t) (switch_codec_t *codec,
+															switch_codec_t *other_codec,
+															void *decoded_data,
+															uint32_t decoded_data_len,
+															uint32_t decoded_rate,
+															void *encoded_data, uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag);
+
+
+typedef switch_status_t (*switch_core_codec_decode_func_t) (switch_codec_t *codec,
+															switch_codec_t *other_codec,
+															void *encoded_data,
+															uint32_t encoded_data_len,
+															uint32_t encoded_rate,
+															void *decoded_data, uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag);
+
+typedef switch_status_t (*switch_core_codec_init_func_t) (switch_codec_t *, switch_codec_flag_t, const switch_codec_settings_t *codec_settings);
+typedef switch_status_t (*switch_core_codec_destroy_func_t) (switch_codec_t *);
+
+
+
+
+typedef void (*switch_application_function_t) (switch_core_session_t *, const char *);
+#define SWITCH_STANDARD_APP(name) static void name (switch_core_session_t *session, const char *data)
+
+typedef void (*switch_event_callback_t) (switch_event_t *);
+typedef switch_caller_extension_t *(*switch_dialplan_hunt_function_t) (switch_core_session_t *, void *, switch_caller_profile_t *);
+#define SWITCH_STANDARD_DIALPLAN(name) static switch_caller_extension_t *name (switch_core_session_t *session, void *arg, switch_caller_profile_t *caller_profile)
+
+typedef switch_bool_t (*switch_hash_delete_callback_t) (_In_ const void *key, _In_ const void *val, _In_opt_ void *pData);
+#define SWITCH_HASH_DELETE_FUNC(name) static switch_bool_t name (const void *key, const void *val, void *pData)
+
+typedef struct switch_scheduler_task switch_scheduler_task_t;
+
+typedef void (*switch_scheduler_func_t) (switch_scheduler_task_t *task);
+
+#define SWITCH_STANDARD_SCHED_FUNC(name) static void name (switch_scheduler_task_t *task)
+
+typedef switch_status_t (*switch_state_handler_t) (switch_core_session_t *);
+typedef struct switch_stream_handle switch_stream_handle_t;
+typedef switch_status_t (*switch_stream_handle_write_function_t) (switch_stream_handle_t *handle, const char *fmt, ...);
+typedef switch_status_t (*switch_stream_handle_raw_write_function_t) (switch_stream_handle_t *handle, uint8_t *data, switch_size_t datalen);
+
+typedef switch_status_t (*switch_api_function_t) (_In_opt_z_ const char *cmd, _In_opt_ switch_core_session_t *session,
+												  _In_ switch_stream_handle_t *stream);
+
+#define SWITCH_STANDARD_API(name) static switch_status_t name (_In_opt_z_ const char *cmd, _In_opt_ switch_core_session_t *session, _In_ switch_stream_handle_t *stream)
+
+typedef switch_status_t (*switch_input_callback_function_t) (switch_core_session_t *session, void *input,
+															 switch_input_type_t input_type, void *buf, unsigned int buflen);
+typedef switch_status_t (*switch_read_frame_callback_function_t) (switch_core_session_t *session, switch_frame_t *frame, void *user_data);
+typedef struct switch_say_interface switch_say_interface_t;
+typedef struct {
+	switch_input_callback_function_t input_callback;
+	void *buf;
+	uint32_t buflen;
+	switch_read_frame_callback_function_t read_frame_callback;
+	void *user_data;
+} switch_input_args_t;
+
+typedef struct {
+	switch_say_type_t type;
+	switch_say_method_t method;
+	switch_say_gender_t gender;
+} switch_say_args_t;
+
+typedef switch_status_t (*switch_say_callback_t) (switch_core_session_t *session,
+												  char *tosay,
+												  switch_say_args_t *say_args,
+												  switch_input_args_t *args);
+
+typedef struct switch_xml *switch_xml_t;
+typedef struct switch_core_time_duration switch_core_time_duration_t;
+typedef switch_xml_t(*switch_xml_search_function_t) (const char *section,
+													 const char *tag_name, const char *key_name, const char *key_value, switch_event_t *params,
+													 void *user_data);
+
+typedef struct switch_hash switch_hash_t;
+struct HashElem;
+typedef struct HashElem switch_hash_index_t;
+
+struct switch_network_list;
+typedef struct switch_network_list switch_network_list_t;
+
+
+#define SWITCH_API_VERSION 4
+#define SWITCH_MODULE_LOAD_ARGS (switch_loadable_module_interface_t **module_interface, switch_memory_pool_t *pool)
+#define SWITCH_MODULE_RUNTIME_ARGS (void)
+#define SWITCH_MODULE_SHUTDOWN_ARGS (void)
+typedef switch_status_t (*switch_module_load_t) SWITCH_MODULE_LOAD_ARGS;
+typedef switch_status_t (*switch_module_runtime_t) SWITCH_MODULE_RUNTIME_ARGS;
+typedef switch_status_t (*switch_module_shutdown_t) SWITCH_MODULE_SHUTDOWN_ARGS;
+#define SWITCH_MODULE_LOAD_FUNCTION(name) switch_status_t name SWITCH_MODULE_LOAD_ARGS
+#define SWITCH_MODULE_RUNTIME_FUNCTION(name) switch_status_t name SWITCH_MODULE_RUNTIME_ARGS
+#define SWITCH_MODULE_SHUTDOWN_FUNCTION(name) switch_status_t name SWITCH_MODULE_SHUTDOWN_ARGS
+
+typedef enum {
+	SMODF_NONE = 0,
+	SMODF_GLOBAL_SYMBOLS = (1 << 0)
+} switch_module_flag_enum_t;
+typedef uint32_t switch_module_flag_t;
+
+typedef struct switch_loadable_module_function_table {
+	int switch_api_version;
+	switch_module_load_t load;
+	switch_module_shutdown_t shutdown;
+	switch_module_runtime_t runtime;
+	switch_module_flag_t flags;
+} switch_loadable_module_function_table_t;
+
+#define SWITCH_MODULE_DEFINITION_EX(name, load, shutdown, runtime, flags)					\
+static const char modname[] =  #name ;														\
+SWITCH_MOD_DECLARE_DATA switch_loadable_module_function_table_t name##_module_interface = {	\
+	SWITCH_API_VERSION,																		\
+	load,																					\
+	shutdown,																				\
+	runtime,																				\
+	flags																					\
+}
+
+#define SWITCH_MODULE_DEFINITION(name, load, shutdown, runtime)								\
+		SWITCH_MODULE_DEFINITION_EX(name, load, shutdown, runtime, SMODF_NONE)
+
+/* things we don't deserve to know about */
+/*! \brief A channel */
+struct switch_channel;
+/*! \brief A core session representing a call and all of it's resources */
+struct switch_core_session;
+/*! \brief An audio bug */
+struct switch_media_bug;
+/*! \brief A digit stream parser object */
+struct switch_ivr_digit_stream_parser;
+
+SWITCH_END_EXTERN_C
+#endif
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
diff --git a/src/mod/applications/mod_conference/mod_conference.c.orig b/src/mod/applications/mod_conference/mod_conference.c.orig
new file mode 100644
index 0000000000..c85e6b6ef0
--- /dev/null
+++ b/src/mod/applications/mod_conference/mod_conference.c.orig
@@ -0,0 +1,6343 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ * Copyright (C) 2005-2010, Anthony Minessale II <anthm@freeswitch.org>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis, 
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Neal Horman <neal at wanlink dot com>
+ * Bret McDanel <trixter at 0xdecafbad dot com>
+ * Dale Thatcher <freeswitch at dalethatcher dot com>
+ * Chris Danielson <chris at maxpowersoft dot com>
+ * Rupa Schomaker <rupa@rupa.com>
+ * David Weekly <david@weekly.org>
+ *
+ * mod_conference.c -- Software Conference Bridge
+ *
+ */
+#include <switch.h>
+//#define INTENSE_DEBUG
+SWITCH_MODULE_LOAD_FUNCTION(mod_conference_load);
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_conference_shutdown);
+SWITCH_MODULE_DEFINITION(mod_conference, mod_conference_load, mod_conference_shutdown, NULL);
+
+static const char global_app_name[] = "conference";
+static char *global_cf_name = "conference.conf";
+static char *cf_pin_url_param_name = "X-ConfPin=";
+static char *api_syntax;
+static int EC = 0;
+
+/* Size to allocate for audio buffers */
+#define CONF_BUFFER_SIZE 1024 * 128
+#define CONF_EVENT_MAINT "conference::maintenance"
+#define CONF_DEFAULT_LEADIN 20
+
+#define CONF_DBLOCK_SIZE CONF_BUFFER_SIZE
+#define CONF_DBUFFER_SIZE CONF_BUFFER_SIZE
+#define CONF_DBUFFER_MAX 0
+#define CONF_CHAT_PROTO "conf"
+
+#ifndef MIN
+#define MIN(a, b) ((a)<(b)?(a):(b))
+#endif
+
+/* the rate at which the infinite impulse response filter on speaker score will decay. */
+#define SCORE_DECAY 0.8
+/* the maximum value for the IIR score [keeps loud & longwinded people from getting overweighted] */
+#define SCORE_MAX_IIR 25000
+/* the minimum score for which you can be considered to be loud enough to now have the floor */
+#define SCORE_IIR_SPEAKING_MAX 3000
+/* the threshold below which you cede the floor to someone loud (see above value). */
+#define SCORE_IIR_SPEAKING_MIN 100
+
+
+#define test_eflag(conference, flag) ((conference)->eflags & flag)
+
+typedef enum {
+	FILE_STOP_CURRENT,
+	FILE_STOP_ALL,
+	FILE_STOP_ASYNC
+} file_stop_t;
+
+/* Global Values */
+static struct {
+	switch_memory_pool_t *conference_pool;
+	switch_mutex_t *conference_mutex;
+	switch_hash_t *conference_hash;
+	switch_mutex_t *id_mutex;
+	switch_mutex_t *hash_mutex;
+	switch_mutex_t *setup_mutex;
+	uint32_t id_pool;
+	int32_t running;
+	uint32_t threads;
+	switch_event_node_t *node;
+} globals;
+
+typedef enum {
+	CALLER_CONTROL_MUTE,
+	CALLER_CONTROL_MUTE_ON,
+	CALLER_CONTROL_MUTE_OFF,
+	CALLER_CONTROL_DEAF_MUTE,
+	CALLER_CONTROL_ENERGY_UP,
+	CALLER_CONTROL_ENERGY_EQU_CONF,
+	CALLER_CONTROL_ENERGEY_DN,
+	CALLER_CONTROL_VOL_TALK_UP,
+	CALLER_CONTROL_VOL_TALK_ZERO,
+	CALLER_CONTROL_VOL_TALK_DN,
+	CALLER_CONTROL_VOL_LISTEN_UP,
+	CALLER_CONTROL_VOL_LISTEN_ZERO,
+	CALLER_CONTROL_VOL_LISTEN_DN,
+	CALLER_CONTROL_HANGUP,
+	CALLER_CONTROL_MENU,
+	CALLER_CONTROL_DIAL,
+	CALLER_CONTROL_EVENT,
+	CALLER_CONTROL_LOCK,
+	CALLER_CONTROL_TRANSFER,
+	CALLER_CONTROL_EXEC_APP
+} caller_control_t;
+
+/* forward declaration for conference_obj and caller_control */
+struct conference_member;
+typedef struct conference_member conference_member_t;
+
+struct call_list {
+	char *string;
+	int itteration;
+	struct call_list *next;
+};
+typedef struct call_list call_list_t;
+
+struct caller_control_actions;
+
+typedef struct caller_control_fn_table {
+	char *key;
+	char *digits;
+	caller_control_t action;
+	void (*handler) (conference_member_t *, struct caller_control_actions *);
+} caller_control_fn_table_t;
+
+typedef struct caller_control_actions {
+	caller_control_fn_table_t *fndesc;
+	char *binded_dtmf;
+	void *data;
+} caller_control_action_t;
+
+typedef struct caller_control_menu_info {
+	switch_ivr_menu_t *stack;
+	char *name;
+} caller_control_menu_info_t;
+
+typedef enum {
+	MFLAG_RUNNING = (1 << 0),
+	MFLAG_CAN_SPEAK = (1 << 1),
+	MFLAG_CAN_HEAR = (1 << 2),
+	MFLAG_KICKED = (1 << 3),
+	MFLAG_ITHREAD = (1 << 4),
+	MFLAG_NOCHANNEL = (1 << 5),
+	MFLAG_INTREE = (1 << 6),
+	MFLAG_WASTE_BANDWIDTH = (1 << 7),
+	MFLAG_FLUSH_BUFFER = (1 << 8),
+	MFLAG_ENDCONF = (1 << 9),
+	MFLAG_HAS_AUDIO = (1 << 10),
+	MFLAG_TALKING = (1 << 11),
+	MFLAG_RESTART = (1 << 12),
+	MFLAG_MINTWO = (1 << 13),
+	MFLAG_MUTE_DETECT = (1 << 14),
+	MFLAG_DIST_DTMF = (1 << 15),
+	MFLAG_MOD = (1 << 16)
+} member_flag_t;
+
+typedef enum {
+	CFLAG_RUNNING = (1 << 0),
+	CFLAG_DYNAMIC = (1 << 1),
+	CFLAG_ENFORCE_MIN = (1 << 2),
+	CFLAG_DESTRUCT = (1 << 3),
+	CFLAG_LOCKED = (1 << 4),
+	CFLAG_ANSWERED = (1 << 5),
+	CFLAG_BRIDGE_TO = (1 << 6),
+	CFLAG_WAIT_MOD = (1 << 7),
+	CFLAG_VID_FLOOR = (1 << 8),
+	CFLAG_WASTE_BANDWIDTH = (1 << 9)
+} conf_flag_t;
+
+typedef enum {
+	RFLAG_CAN_SPEAK = (1 << 0),
+	RFLAG_CAN_HEAR = (1 << 1)
+} relation_flag_t;
+
+typedef enum {
+	NODE_TYPE_FILE,
+	NODE_TYPE_SPEECH
+} node_type_t;
+
+typedef enum {
+	EFLAG_ADD_MEMBER = (1 << 0),
+	EFLAG_DEL_MEMBER = (1 << 1),
+	EFLAG_ENERGY_LEVEL = (1 << 2),
+	EFLAG_VOLUME_LEVEL = (1 << 3),
+	EFLAG_GAIN_LEVEL = (1 << 4),
+	EFLAG_DTMF = (1 << 5),
+	EFLAG_STOP_TALKING = (1 << 6),
+	EFLAG_START_TALKING = (1 << 7),
+	EFLAG_MUTE_MEMBER = (1 << 8),
+	EFLAG_UNMUTE_MEMBER = (1 << 9),
+	EFLAG_DEAF_MEMBER = (1 << 10),
+	EFLAG_UNDEAF_MEMBER = (1 << 11),
+	EFLAG_KICK_MEMBER = (1 << 12),
+	EFLAG_DTMF_MEMBER = (1 << 13),
+	EFLAG_ENERGY_LEVEL_MEMBER = (1 << 14),
+	EFLAG_VOLUME_IN_MEMBER = (1 << 15),
+	EFLAG_VOLUME_OUT_MEMBER = (1 << 16),
+	EFLAG_PLAY_FILE = (1 << 17),
+	EFLAG_PLAY_FILE_MEMBER = (1 << 18),
+	EFLAG_SPEAK_TEXT = (1 << 19),
+	EFLAG_SPEAK_TEXT_MEMBER = (1 << 20),
+	EFLAG_LOCK = (1 << 21),
+	EFLAG_UNLOCK = (1 << 22),
+	EFLAG_TRANSFER = (1 << 23),
+	EFLAG_BGDIAL_RESULT = (1 << 24),
+	EFLAG_FLOOR_CHANGE = (1 << 25),
+	EFLAG_MUTE_DETECT = (1 << 26)
+} event_type_t;
+
+typedef struct conference_file_node {
+	switch_file_handle_t fh;
+	switch_speech_handle_t *sh;
+	node_type_t type;
+	uint8_t done;
+	uint8_t async;
+	switch_memory_pool_t *pool;
+	uint32_t leadin;
+	struct conference_file_node *next;
+	char *file;
+} conference_file_node_t;
+
+/* conference xml config sections */
+typedef struct conf_xml_cfg {
+	switch_xml_t profile;
+	switch_xml_t controls;
+} conf_xml_cfg_t;
+
+/* Conference Object */
+typedef struct conference_obj {
+	char *name;
+	char *timer_name;
+	char *tts_engine;
+	char *tts_voice;
+	char *enter_sound;
+	char *exit_sound;
+	char *alone_sound;
+	char *perpetual_sound;
+	char *moh_sound;
+	char *ack_sound;
+	char *nack_sound;
+	char *muted_sound;
+	char *mute_detect_sound;
+	char *unmuted_sound;
+	char *locked_sound;
+	char *is_locked_sound;
+	char *is_unlocked_sound;
+	char *kicked_sound;
+	char *caller_id_name;
+	char *caller_id_number;
+	char *sound_prefix;
+	char *special_announce;
+	char *auto_record;
+	uint32_t max_members;
+	char *maxmember_sound;
+	uint32_t announce_count;
+	switch_ivr_digit_stream_parser_t *dtmf_parser;
+	char *pin;
+	char *pin_sound;
+	char *bad_pin_sound;
+	char *profile_name;
+	char *domain;
+	uint32_t flags;
+	member_flag_t mflags;
+	switch_call_cause_t bridge_hangup_cause;
+	switch_mutex_t *flag_mutex;
+	uint32_t rate;
+	uint32_t interval;
+	switch_mutex_t *mutex;
+	conference_member_t *members;
+	conference_member_t *floor_holder;
+	switch_mutex_t *member_mutex;
+	conference_file_node_t *fnode;
+	conference_file_node_t *async_fnode;
+	switch_memory_pool_t *pool;
+	switch_thread_rwlock_t *rwlock;
+	uint32_t count;
+	int32_t energy_level;
+	uint8_t min;
+	switch_speech_handle_t lsh;
+	switch_speech_handle_t *sh;
+	switch_byte_t *not_talking_buf;
+	uint32_t not_talking_buf_len;
+	int comfort_noise_level;
+	int is_recording;
+	int video_running;
+	uint32_t eflags;
+	uint32_t verbose_events;
+	int end_count;
+	uint32_t relationship_total;
+} conference_obj_t;
+
+/* Relationship with another member */
+typedef struct conference_relationship {
+	uint32_t id;
+	uint32_t flags;
+	struct conference_relationship *next;
+} conference_relationship_t;
+
+/* Conference Member Object */
+struct conference_member {
+	uint32_t id;
+	switch_core_session_t *session;
+	conference_obj_t *conference;
+	switch_memory_pool_t *pool;
+	switch_buffer_t *audio_buffer;
+	switch_buffer_t *mux_buffer;
+	switch_buffer_t *resample_buffer;
+	uint32_t flags;
+	uint32_t score;
+	uint32_t score_iir;
+	switch_mutex_t *flag_mutex;
+	switch_mutex_t *write_mutex;
+	switch_mutex_t *audio_in_mutex;
+	switch_mutex_t *audio_out_mutex;
+	switch_mutex_t *read_mutex;
+	switch_codec_implementation_t orig_read_impl;
+	switch_codec_t read_codec;
+	switch_codec_t write_codec;
+	char *rec_path;
+	uint8_t *frame;
+	uint32_t frame_size;
+	uint8_t *mux_frame;
+	uint32_t read;
+	int32_t energy_level;
+	int32_t volume_in_level;
+	int32_t volume_out_level;
+	uint32_t native_rate;
+	switch_audio_resampler_t *read_resampler;
+	int16_t *resample_out;
+	uint32_t resample_out_len;
+	conference_file_node_t *fnode;
+	conference_relationship_t *relationships;
+	switch_ivr_digit_stream_parser_t *dtmf_parser;
+	switch_ivr_digit_stream_t *digit_stream;
+	switch_speech_handle_t lsh;
+	switch_speech_handle_t *sh;
+	uint32_t verbose_events;
+	struct conference_member *next;
+};
+
+/* Record Node */
+typedef struct conference_record {
+	conference_obj_t *conference;
+	char *path;
+	switch_memory_pool_t *pool;
+} conference_record_t;
+
+typedef enum {
+	CONF_API_SUB_ARGS_SPLIT,
+	CONF_API_SUB_MEMBER_TARGET,
+	CONF_API_SUB_ARGS_AS_ONE
+} conference_fntype_t;
+
+typedef void (*void_fn_t) (void);
+
+/* API command parser */
+typedef struct api_command {
+	char *pname;
+	void_fn_t pfnapicmd;
+	conference_fntype_t fntype;
+	char *psyntax;
+} api_command_t;
+
+/* Function Prototypes */
+static int setup_media(conference_member_t *member, conference_obj_t *conference);
+static uint32_t next_member_id(void);
+static conference_relationship_t *member_get_relationship(conference_member_t *member, conference_member_t *other_member);
+static conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id);
+static conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id);
+static switch_status_t member_del_relationship(conference_member_t *member, uint32_t id);
+static switch_status_t conference_add_member(conference_obj_t *conference, conference_member_t *member);
+static switch_status_t conference_del_member(conference_obj_t *conference, conference_member_t *member);
+static void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj);
+static void *SWITCH_THREAD_FUNC conference_video_thread_run(switch_thread_t *thread, void *obj);
+static void conference_loop_output(conference_member_t *member);
+static uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop);
+static switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async);
+static void conference_send_all_dtmf(conference_member_t *member, conference_obj_t *conference, const char *dtmf);
+static switch_status_t conference_say(conference_obj_t *conference, const char *text, uint32_t leadin);
+static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim);
+static conference_obj_t *conference_find(char *name);
+
+SWITCH_STANDARD_API(conf_api_main);
+
+static switch_status_t conference_outcall(conference_obj_t *conference,
+										  char *conference_name,
+										  switch_core_session_t *session,
+										  char *bridgeto, uint32_t timeout, char *flags, char *cid_name, char *cid_num, switch_call_cause_t *cause);
+static switch_status_t conference_outcall_bg(conference_obj_t *conference,
+											 char *conference_name,
+											 switch_core_session_t *session, char *bridgeto, uint32_t timeout, const char *flags, const char *cid_name,
+											 const char *cid_num, const char *call_uuid);
+SWITCH_STANDARD_APP(conference_function);
+static void launch_conference_thread(conference_obj_t *conference);
+static void launch_conference_video_thread(conference_obj_t *conference);
+static void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj);
+static switch_status_t conference_local_play_file(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
+												  uint32_t buflen);
+static switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin);
+static switch_status_t conference_member_say(conference_member_t *member, char *text, uint32_t leadin);
+static uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop);
+static conference_obj_t *conference_new(char *name, conf_xml_cfg_t cfg, switch_memory_pool_t *pool);
+static switch_status_t chat_send(const char *proto, const char *from, const char *to, const char *subject,
+								 const char *body, const char *type, const char *hint);
+
+static void launch_conference_record_thread(conference_obj_t *conference, char *path);
+
+typedef switch_status_t (*conf_api_args_cmd_t) (conference_obj_t *, switch_stream_handle_t *, int, char **);
+typedef switch_status_t (*conf_api_member_cmd_t) (conference_member_t *, switch_stream_handle_t *, void *);
+typedef switch_status_t (*conf_api_text_cmd_t) (conference_obj_t *, switch_stream_handle_t *, const char *);
+
+static void conference_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, conf_api_member_cmd_t pfncallback, void *data);
+static switch_status_t conf_api_sub_mute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+static switch_status_t conf_api_sub_unmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+static switch_status_t conf_api_sub_deaf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+static switch_status_t conf_api_sub_undeaf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+static switch_status_t conference_add_event_data(conference_obj_t *conference, switch_event_t *event);
+static switch_status_t conference_add_event_member_data(conference_member_t *member, switch_event_t *event);
+
+
+#define lock_member(_member) switch_mutex_lock(_member->write_mutex); switch_mutex_lock(_member->read_mutex)
+#define unlock_member(_member) switch_mutex_unlock(_member->read_mutex); switch_mutex_unlock(_member->write_mutex)
+
+//#define lock_member(_member) switch_mutex_lock(_member->write_mutex)
+//#define unlock_member(_member) switch_mutex_unlock(_member->write_mutex)
+
+static switch_status_t conference_add_event_data(conference_obj_t *conference, switch_event_t *event)
+{
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Size", "%u", conference->count);
+	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Conference-Profile-Name", conference->profile_name);
+
+	return status;
+}
+
+static switch_status_t conference_add_event_member_data(conference_member_t *member, switch_event_t *event)
+{
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+	if (!member)
+		return status;
+
+	if (member->conference) {
+		status = conference_add_event_data(member->conference, event);
+	}
+
+	if (member->session) {
+		switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+		if (member->verbose_events) {
+			switch_channel_event_set_data(channel, event);
+		} else {
+			switch_channel_event_set_basic_data(channel, event);
+		}
+
+	}
+
+	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-Type", "%s", switch_test_flag(member, MFLAG_MOD) ? "moderator" : "member");
+
+	return status;
+}
+
+/* Return a Distinct ID # */
+static uint32_t next_member_id(void)
+{
+	uint32_t id;
+
+	switch_mutex_lock(globals.id_mutex);
+	id = ++globals.id_pool;
+	switch_mutex_unlock(globals.id_mutex);
+
+	return id;
+}
+
+/* if other_member has a relationship with member, produce it */
+static conference_relationship_t *member_get_relationship(conference_member_t *member, conference_member_t *other_member)
+{
+	conference_relationship_t *rel = NULL, *global = NULL;
+
+	if (member == NULL || other_member == NULL || member->relationships == NULL)
+		return NULL;
+
+	lock_member(member);
+	lock_member(other_member);
+
+	for (rel = member->relationships; rel; rel = rel->next) {
+		if (rel->id == other_member->id) {
+			break;
+		}
+
+		/* 0 matches everyone. (We will still test the others because a real match carries more clout) */
+		if (rel->id == 0) {
+			global = rel;
+		}
+	}
+
+	unlock_member(other_member);
+	unlock_member(member);
+
+	return rel ? rel : global;
+}
+
+/* traverse the conference member list for the specified member id and return it's pointer */
+static conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id)
+{
+	conference_member_t *member = NULL;
+
+	switch_assert(conference != NULL);
+	if (!id) {
+		return NULL;
+	}
+
+	switch_mutex_lock(conference->member_mutex);
+	for (member = conference->members; member; member = member->next) {
+
+		if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
+			continue;
+		}
+
+		if (member->id == id) {
+			break;
+		}
+	}
+
+	if (member && !switch_test_flag(member, MFLAG_INTREE)) {
+		member = NULL;
+	}
+
+	switch_mutex_unlock(conference->member_mutex);
+
+	return member;
+}
+
+/* stop the specified recording */
+static switch_status_t conference_record_stop(conference_obj_t *conference, char *path)
+{
+	conference_member_t *member = NULL;
+	int count = 0;
+
+	switch_assert(conference != NULL);
+	switch_mutex_lock(conference->member_mutex);
+	for (member = conference->members; member; member = member->next) {
+		if (switch_test_flag(member, MFLAG_NOCHANNEL) && (!path || !strcmp(path, member->rec_path))) {
+			switch_clear_flag_locked(member, MFLAG_RUNNING);
+			count++;
+		}
+	}
+	switch_mutex_unlock(conference->member_mutex);
+	return count;
+}
+
+/* Add a custom relationship to a member */
+static conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id)
+{
+	conference_relationship_t *rel = NULL;
+
+	if (member == NULL || id == 0 || !(rel = switch_core_alloc(member->pool, sizeof(*rel))))
+		return NULL;
+
+	rel->id = id;
+
+
+	lock_member(member);
+	switch_mutex_lock(member->conference->member_mutex);
+	member->conference->relationship_total++;
+	switch_mutex_unlock(member->conference->member_mutex);
+	rel->next = member->relationships;
+	member->relationships = rel;
+	unlock_member(member);
+
+	return rel;
+}
+
+/* Remove a custom relationship from a member */
+static switch_status_t member_del_relationship(conference_member_t *member, uint32_t id)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	conference_relationship_t *rel, *last = NULL;
+
+	if (member == NULL || id == 0)
+		return status;
+
+	lock_member(member);
+	for (rel = member->relationships; rel; rel = rel->next) {
+		if (rel->id == id) {
+			/* we just forget about rel here cos it was allocated by the member's pool 
+			   it will be freed when the member is */
+			status = SWITCH_STATUS_SUCCESS;
+			if (last) {
+				last->next = rel->next;
+			} else {
+				member->relationships = rel->next;
+			}
+
+			switch_mutex_lock(member->conference->member_mutex);
+			member->conference->relationship_total--;
+			switch_mutex_unlock(member->conference->member_mutex);
+
+		}
+		last = rel;
+	}
+	unlock_member(member);
+
+	return status;
+}
+
+/* Gain exclusive access and add the member to the list */
+static switch_status_t conference_add_member(conference_obj_t *conference, conference_member_t *member)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	switch_event_t *event;
+	char msg[512];				/* conference count announcement */
+	call_list_t *call_list = NULL;
+	switch_channel_t *channel;
+
+	switch_assert(conference != NULL);
+	switch_assert(member != NULL);
+
+	switch_mutex_lock(conference->mutex);
+	switch_mutex_lock(member->audio_in_mutex);
+	switch_mutex_lock(member->audio_out_mutex);
+	lock_member(member);
+	switch_mutex_lock(conference->member_mutex);
+
+	switch_clear_flag(conference, CFLAG_DESTRUCT);
+	member->conference = conference;
+	member->next = conference->members;
+	member->energy_level = conference->energy_level;
+	member->score_iir = 0;
+	member->verbose_events = conference->verbose_events;
+	conference->members = member;
+	switch_set_flag_locked(member, MFLAG_INTREE);
+	switch_mutex_unlock(conference->member_mutex);
+
+	if (!switch_test_flag(member, MFLAG_NOCHANNEL)) {
+		conference->count++;
+
+		if (switch_test_flag(member, MFLAG_ENDCONF)) {
+			if (conference->end_count++);
+		}
+
+		if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", conference->name, conference->domain);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "Active (%d caller%s)", conference->count, conference->count == 1 ? "" : "s");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", conference->name);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_ROUTING");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", conference->count == 1 ? "early" : "confirmed");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-direction", conference->count == 1 ? "outbound" : "inbound");
+			switch_event_fire(&event);
+		}
+
+		if (switch_test_flag(conference, CFLAG_WAIT_MOD) && switch_test_flag(member, MFLAG_MOD)) {
+			switch_clear_flag(conference, CFLAG_WAIT_MOD);
+		}
+
+		if (conference->count > 1) {
+			if (conference->moh_sound && !switch_test_flag(conference, CFLAG_WAIT_MOD)) {
+				/* stop MoH if any */
+				conference_stop_file(conference, FILE_STOP_ASYNC);
+			}
+			if (conference->enter_sound) {
+				conference_play_file(conference, conference->enter_sound, CONF_DEFAULT_LEADIN, switch_core_session_get_channel(member->session),
+									 switch_test_flag(conference, CFLAG_WAIT_MOD) ? 0 : 1);
+			}
+		}
+
+		channel = switch_core_session_get_channel(member->session);
+		call_list = (call_list_t *) switch_channel_get_private(channel, "_conference_autocall_list_");
+
+		if (call_list) {
+			char saymsg[1024];
+			switch_snprintf(saymsg, sizeof(saymsg), "Auto Calling %d parties", call_list->itteration);
+			conference_member_say(member, saymsg, 0);
+		} else {
+			if (zstr(conference->special_announce)) {
+				/* announce the total number of members in the conference */
+				if (conference->count >= conference->announce_count && conference->announce_count > 1) {
+					switch_snprintf(msg, sizeof(msg), "There are %d callers", conference->count);
+					conference_member_say(member, msg, CONF_DEFAULT_LEADIN);
+				} else if (conference->count == 1 && !conference->perpetual_sound && !switch_test_flag(conference, CFLAG_WAIT_MOD)) {
+					/* as long as its not a bridge_to conference, announce if person is alone */
+					if (!switch_test_flag(conference, CFLAG_BRIDGE_TO)) {
+						if (conference->alone_sound) {
+							conference_stop_file(conference, FILE_STOP_ASYNC);
+							conference_play_file(conference, conference->alone_sound, CONF_DEFAULT_LEADIN,
+												 switch_core_session_get_channel(member->session), 1);
+						} else {
+							switch_snprintf(msg, sizeof(msg), "You are currently the only person in this conference.");
+							conference_member_say(member, msg, CONF_DEFAULT_LEADIN);
+						}
+					}
+
+				}
+			}
+		}
+
+		if (conference->count == 1) {
+			conference->floor_holder = member;
+		}
+
+		if (conference->min && conference->count >= conference->min) {
+			switch_set_flag(conference, CFLAG_ENFORCE_MIN);
+		}
+
+		if (test_eflag(conference, EFLAG_ADD_MEMBER) &&
+			switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			conference_add_event_member_data(member, event);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "add-member");
+			switch_event_fire(&event);
+		}
+
+	}
+	unlock_member(member);
+	switch_mutex_unlock(member->audio_out_mutex);
+	switch_mutex_unlock(member->audio_in_mutex);
+
+	switch_mutex_unlock(conference->mutex);
+	status = SWITCH_STATUS_SUCCESS;
+
+	return status;
+}
+
+/* Gain exclusive access and remove the member from the list */
+static switch_status_t conference_del_member(conference_obj_t *conference, conference_member_t *member)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	conference_member_t *imember, *last = NULL;
+	switch_event_t *event;
+	conference_file_node_t *member_fnode;
+	switch_speech_handle_t *member_sh;
+
+	switch_assert(conference != NULL);
+	switch_assert(member != NULL);
+
+	lock_member(member);
+	member_fnode = member->fnode;
+	member_sh = member->sh;
+	member->fnode = NULL;
+	member->sh = NULL;
+	unlock_member(member);
+
+	switch_mutex_lock(conference->mutex);
+	switch_mutex_lock(conference->member_mutex);
+	switch_mutex_lock(member->audio_in_mutex);
+	switch_mutex_lock(member->audio_out_mutex);
+	lock_member(member);
+	switch_clear_flag(member, MFLAG_INTREE);
+
+	for (imember = conference->members; imember; imember = imember->next) {
+		if (imember == member) {
+			if (last) {
+				last->next = imember->next;
+			} else {
+				conference->members = imember->next;
+			}
+			break;
+		}
+		last = imember;
+	}
+
+	/* Close Unused Handles */
+	if (member_fnode) {
+		conference_file_node_t *fnode, *cur;
+		switch_memory_pool_t *pool;
+
+		fnode = member_fnode;
+		while (fnode) {
+			cur = fnode;
+			fnode = fnode->next;
+
+			if (cur->type != NODE_TYPE_SPEECH) {
+				switch_core_file_close(&cur->fh);
+			}
+
+			pool = cur->pool;
+			switch_core_destroy_memory_pool(&pool);
+		}
+	}
+
+	if (member_sh) {
+		switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
+		switch_core_speech_close(&member->lsh, &flags);
+	}
+
+	if (member == member->conference->floor_holder) {
+		member->conference->floor_holder = NULL;
+	}
+
+	member->conference = NULL;
+
+	if (!switch_test_flag(member, MFLAG_NOCHANNEL)) {
+		conference->count--;
+
+		if (switch_test_flag(member, MFLAG_ENDCONF)) {
+			if (!--conference->end_count) {
+				switch_set_flag_locked(conference, CFLAG_DESTRUCT);
+			}
+		}
+
+
+		if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", conference->name, conference->domain);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "Active (%d caller%s)", conference->count, conference->count == 1 ? "" : "s");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", conference->name);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_ROUTING");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", conference->count == 1 ? "early" : "confirmed");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", conference->count == 1 ? "outbound" : "inbound");
+			switch_event_fire(&event);
+		}
+
+		if ((conference->min && switch_test_flag(conference, CFLAG_ENFORCE_MIN) && conference->count < conference->min)
+			|| (switch_test_flag(conference, CFLAG_DYNAMIC) && conference->count == 0)) {
+			switch_set_flag(conference, CFLAG_DESTRUCT);
+		} else {
+			if (conference->exit_sound) {
+				conference_play_file(conference, conference->exit_sound, 0, switch_core_session_get_channel(member->session), 0);
+			}
+			if (conference->count == 1 && conference->alone_sound && !switch_test_flag(conference, CFLAG_WAIT_MOD)) {
+				conference_stop_file(conference, FILE_STOP_ASYNC);
+				conference_play_file(conference, conference->alone_sound, 0, switch_core_session_get_channel(member->session), 1);
+			}
+		}
+
+		if (conference->announce_count == 1) {
+			conference->floor_holder = conference->members;
+		}
+
+		if (test_eflag(conference, EFLAG_DEL_MEMBER) &&
+			switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			conference_add_event_member_data(member, event);
+			conference_add_event_data(conference, event);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "del-member");
+			switch_event_fire(&event);
+		}
+	}
+	switch_mutex_unlock(conference->member_mutex);
+	unlock_member(member);
+	switch_mutex_unlock(member->audio_out_mutex);
+	switch_mutex_unlock(member->audio_in_mutex);
+	switch_mutex_unlock(conference->mutex);
+	status = SWITCH_STATUS_SUCCESS;
+
+	return status;
+}
+
+/* Main video monitor thread (1 per distinct conference room) */
+static void *SWITCH_THREAD_FUNC conference_video_thread_run(switch_thread_t *thread, void *obj)
+{
+	conference_obj_t *conference = (conference_obj_t *) obj;
+	conference_member_t *imember;
+	switch_frame_t *vid_frame;
+	switch_status_t status;
+	int has_vid = 1, req_iframe = 0;
+	int yield = 0;
+	uint32_t last_member = 0;
+	switch_core_session_t *session;
+
+	conference->video_running = 1;
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Video thread started for conference %s\n", conference->name);
+
+	while (has_vid && conference->video_running == 1 && globals.running && !switch_test_flag(conference, CFLAG_DESTRUCT)) {
+		if (yield) {
+			switch_yield(yield);
+			yield = 0;
+		}
+
+		switch_mutex_lock(conference->member_mutex);
+
+		if (!conference->floor_holder) {
+			yield = 100000;
+			goto do_continue;
+		}
+
+		if (!switch_channel_test_flag(switch_core_session_get_channel(conference->floor_holder->session), CF_VIDEO)) {
+			yield = 100000;
+			goto do_continue;
+		}
+
+		session = conference->floor_holder->session;
+		switch_core_session_read_lock(session);
+		switch_mutex_unlock(conference->member_mutex);
+		status = switch_core_session_read_video_frame(session, &vid_frame, SWITCH_IO_FLAG_NONE, 0);
+		switch_mutex_lock(conference->member_mutex);
+		switch_core_session_rwunlock(session);
+
+		if (!SWITCH_READ_ACCEPTABLE(status) || !conference->floor_holder || switch_test_flag(vid_frame, SFF_CNG)) {
+			conference->floor_holder = NULL;
+			req_iframe = 0;
+			goto do_continue;
+		}
+
+		if (conference->floor_holder->id != last_member) {
+			int iframe = 0;
+#if 0
+			switch_core_session_message_t msg = { 0 };
+
+
+			if (!req_iframe) {
+				/* Tell the channel to request a fresh vid frame */
+				msg.from = __FILE__;
+				msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;
+				switch_core_session_receive_message(conference->floor_holder->session, &msg);
+				req_iframe = 1;
+			}
+#endif
+
+			if (vid_frame->codec->implementation->ianacode == 34) {	/* h.263 */
+				//iframe = (*((int16_t *) vid_frame->data) >> 12 == 6);
+				iframe = 1;
+			} else if (vid_frame->codec->implementation->ianacode == 115) {	/* h.263-1998 */
+				int y = *((int8_t *) vid_frame->data + 2) & 0xfe;
+				iframe = (y == 0x80 || y == 0x82);
+			} else if (vid_frame->codec->implementation->ianacode == 99) {	/* h.264 */
+				iframe = (*((int16_t *) vid_frame->data) >> 5 == 0x11);
+			} else {			/* we need more defs */
+				iframe = 1;
+			}
+
+			if (!iframe) {
+				goto do_continue;
+			}
+
+			req_iframe = 0;
+		}
+
+		last_member = conference->floor_holder->id;
+
+		switch_mutex_unlock(conference->member_mutex);
+		switch_mutex_lock(conference->member_mutex);
+		has_vid = 0;
+		for (imember = conference->members; imember; imember = imember->next) {
+			if (imember->session && switch_channel_test_flag(switch_core_session_get_channel(imember->session), CF_VIDEO)) {
+				has_vid++;
+				switch_core_session_write_video_frame(imember->session, vid_frame, SWITCH_IO_FLAG_NONE, 0);
+			}
+		}
+
+	  do_continue:
+
+		switch_mutex_unlock(conference->member_mutex);
+	}
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Video thread ending for conference %s\n", conference->name);
+	conference->video_running = 0;
+
+	return NULL;
+}
+
+/* Main monitor thread (1 per distinct conference room) */
+static void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj)
+{
+	conference_obj_t *conference = (conference_obj_t *) obj;
+	conference_member_t *imember, *omember;
+	uint32_t samples = switch_samples_per_packet(conference->rate, conference->interval);
+	uint32_t bytes = samples * 2;
+	uint8_t ready = 0, total = 0;
+	switch_timer_t timer = { 0 };
+	switch_event_t *event;
+	uint8_t *file_frame;
+	uint8_t *async_file_frame;
+	int16_t *bptr;
+	int x;
+	int32_t z = 0;
+
+	file_frame = switch_core_alloc(conference->pool, SWITCH_RECOMMENDED_BUFFER_SIZE);
+	async_file_frame = switch_core_alloc(conference->pool, SWITCH_RECOMMENDED_BUFFER_SIZE);
+
+	if (switch_core_timer_init(&timer, conference->timer_name, conference->interval, samples, conference->pool) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Setup timer success interval: %u  samples: %u\n", conference->interval, samples);
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Setup Failed.  Conference Cannot Start\n");
+		return NULL;
+	}
+
+	switch_mutex_lock(globals.hash_mutex);
+	globals.threads++;
+	switch_mutex_unlock(globals.hash_mutex);
+
+	conference->is_recording = 0;
+
+	while (globals.running && !switch_test_flag(conference, CFLAG_DESTRUCT)) {
+		switch_size_t file_sample_len = samples;
+		switch_size_t file_data_len = samples * 2;
+		int has_file_data = 0, members_with_video = 0;
+
+		/* Sync the conference to a single timing source */
+		if (switch_core_timer_next(&timer) != SWITCH_STATUS_SUCCESS) {
+			switch_set_flag(conference, CFLAG_DESTRUCT);
+			break;
+		}
+
+		switch_mutex_lock(conference->mutex);
+		has_file_data = ready = total = 0;
+
+		if (conference->perpetual_sound && !conference->async_fnode) {
+			conference_play_file(conference, conference->perpetual_sound, CONF_DEFAULT_LEADIN, NULL, 1);
+		} else if (conference->moh_sound && (conference->count == 1 || switch_test_flag(conference, CFLAG_WAIT_MOD)) && !conference->async_fnode) {
+			conference_play_file(conference, conference->moh_sound, CONF_DEFAULT_LEADIN, NULL, 1);
+		}
+
+		/* Read one frame of audio from each member channel and save it for redistribution */
+		for (imember = conference->members; imember; imember = imember->next) {
+			uint32_t buf_read = 0;
+			total++;
+			imember->read = 0;
+
+			if (imember->session && switch_channel_test_flag(switch_core_session_get_channel(imember->session), CF_VIDEO)) {
+				members_with_video++;
+			}
+
+			switch_clear_flag_locked(imember, MFLAG_HAS_AUDIO);
+			switch_mutex_lock(imember->audio_in_mutex);
+
+			if (switch_buffer_inuse(imember->audio_buffer) >= bytes
+				&& (buf_read = (uint32_t) switch_buffer_read(imember->audio_buffer, imember->frame, bytes))) {
+				imember->read = buf_read;
+				switch_set_flag_locked(imember, MFLAG_HAS_AUDIO);
+				ready++;
+			}
+			switch_mutex_unlock(imember->audio_in_mutex);
+		}
+
+		/* Start recording if there's more than one participant. */
+		if (conference->auto_record && !conference->is_recording && conference->count > 1) {
+			conference->is_recording = 1;
+			imember = conference->members;
+			if (imember) {
+				switch_channel_t *channel = switch_core_session_get_channel(imember->session);
+				char *rfile = switch_channel_expand_variables(channel, conference->auto_record);
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Auto recording file: %s\n", rfile);
+				launch_conference_record_thread(conference, rfile);
+				if (rfile != conference->auto_record) {
+					switch_safe_free(rfile);
+				}
+			} else {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Auto Record Failed.  No members in conference.\n");
+			}
+		}
+
+
+		if (members_with_video && conference->video_running != 1) {
+			launch_conference_video_thread(conference);
+		}
+
+		/* If a file or speech event is being played */
+		if (conference->fnode) {
+			/* Lead in time */
+			if (conference->fnode->leadin) {
+				conference->fnode->leadin--;
+			} else if (!conference->fnode->done) {
+				file_sample_len = samples;
+				if (conference->fnode->type == NODE_TYPE_SPEECH) {
+					switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_BLOCKING;
+
+					if (switch_core_speech_read_tts(conference->fnode->sh, file_frame, &file_data_len, &flags) == SWITCH_STATUS_SUCCESS) {
+						file_sample_len = file_data_len / 2;
+					} else {
+						file_sample_len = file_data_len = 0;
+					}
+				} else if (conference->fnode->type == NODE_TYPE_FILE) {
+					switch_core_file_read(&conference->fnode->fh, file_frame, &file_sample_len);
+				}
+
+				if (file_sample_len <= 0) {
+					if (test_eflag(conference, EFLAG_PLAY_FILE) &&
+						switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+						conference_add_event_data(conference, event);
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "play-file-done");
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File", conference->fnode->file);
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Async", "true");
+						switch_event_fire(&event);
+					}
+
+					conference->fnode->done++;
+				} else {
+					has_file_data = 1;
+				}
+			}
+		}
+
+		if (conference->async_fnode) {
+			/* Lead in time */
+			if (conference->async_fnode->leadin) {
+				conference->async_fnode->leadin--;
+			} else if (!conference->async_fnode->done) {
+				file_sample_len = samples;
+				switch_core_file_read(&conference->async_fnode->fh, async_file_frame, &file_sample_len);
+
+				if (file_sample_len <= 0) {
+					if (test_eflag(conference, EFLAG_PLAY_FILE) &&
+						switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+						conference_add_event_data(conference, event);
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "play-file-done");
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File", conference->async_fnode->file);
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Async", "true");
+						switch_event_fire(&event);
+					}
+					conference->async_fnode->done++;
+				} else {
+					if (has_file_data) {
+						switch_size_t x;
+
+						for (x = 0; x < file_sample_len; x++) {
+							int32_t z;
+							int16_t *muxed;
+
+							muxed = (int16_t *) file_frame;
+							bptr = (int16_t *) async_file_frame;
+							z = muxed[x] + bptr[x];
+							switch_normalize_to_16bit(z);
+							muxed[x] = (int16_t) z;
+						}
+					} else {
+						memcpy(file_frame, async_file_frame, file_sample_len * 2);
+						has_file_data = 1;
+					}
+				}
+			}
+		}
+
+		if (switch_test_flag(conference, CFLAG_WASTE_BANDWIDTH) && !has_file_data) {
+			file_sample_len = bytes / 2;
+
+			if (conference->comfort_noise_level) {
+				switch_generate_sln_silence((int16_t *) file_frame, file_sample_len, conference->comfort_noise_level);
+			} else {
+				memset(file_frame, 255, bytes);
+			}
+			has_file_data = 1;
+		}
+
+
+		if (ready || has_file_data) {
+			/* Use more bits in the main_frame to preserve the exact sum of the audio samples. */
+			int main_frame[SWITCH_RECOMMENDED_BUFFER_SIZE / 2] = { 0 };
+			int16_t write_frame[SWITCH_RECOMMENDED_BUFFER_SIZE / 2] = { 0 };
+
+
+			/* Init the main frame with file data if there is any. */
+			bptr = (int16_t *) file_frame;
+			if (has_file_data && file_sample_len) {
+				for (x = 0; x < bytes / 2; x++) {
+					if (x <= file_sample_len) {
+						main_frame[x] = (int32_t) bptr[x];
+					} else {
+						main_frame[x] = 255;
+					}
+				}
+			}
+
+			/* Copy audio from every member known to be producing audio into the main frame. */
+			for (omember = conference->members; omember; omember = omember->next) {
+				if (!(switch_test_flag(omember, MFLAG_RUNNING) && switch_test_flag(omember, MFLAG_HAS_AUDIO))) {
+					continue;
+				}
+				bptr = (int16_t *) omember->frame;
+				for (x = 0; x < omember->read / 2; x++) {
+					main_frame[x] += (int32_t) bptr[x];
+				}
+			}
+
+			/* Create write frame once per member who is not deaf for each sample in the main frame
+			   check if our audio is involved and if so, subtract it from the sample so we don't hear ourselves.
+			   Since main frame was 32 bit int, we did not lose any detail, now that we have to convert to 16 bit we can
+			   cut it off at the min and max range if need be and write the frame to the output buffer.
+			 */
+			for (omember = conference->members; omember; omember = omember->next) {
+				switch_size_t ok = 1;
+
+				if (!switch_test_flag(omember, MFLAG_RUNNING)) {
+					continue;
+				}
+
+				if (!switch_test_flag(omember, MFLAG_CAN_HEAR) && !switch_test_flag(omember, MFLAG_WASTE_BANDWIDTH)
+					&& !switch_test_flag(conference, CFLAG_WASTE_BANDWIDTH)) {
+					continue;
+				}
+
+				bptr = (int16_t *) omember->frame;
+				for (x = 0; x < bytes / 2; x++) {
+					z = main_frame[x];
+					/* bptr[x] represents my own contribution to this audio sample */
+					if (switch_test_flag(omember, MFLAG_HAS_AUDIO) && x <= omember->read / 2) {
+						z -= (int32_t) bptr[x];
+					}
+
+					/* when there are relationships, we have to do more work by scouring all the members to see if there are any 
+					   reasons why we should not be hearing a paticular member, and if not, delete their samples as well.
+					 */
+					if (conference->relationship_total) {
+						for (imember = conference->members; imember; imember = imember->next) {
+							conference_relationship_t *rel;
+							for (rel = imember->relationships; rel; rel = rel->next) {
+								if (imember != omember && switch_test_flag(imember, MFLAG_HAS_AUDIO)) {
+									int16_t *rptr = (int16_t *) imember->frame;
+									if ((rel->id == omember->id || rel->id == 0) && !switch_test_flag(rel, RFLAG_CAN_SPEAK)) {
+										z -= (int32_t) rptr[x];
+									}
+									if ((rel->id == imember->id || rel->id == 0) && !switch_test_flag(rel, RFLAG_CAN_HEAR)) {
+										z -= (int32_t) rptr[x];
+									}
+								}
+
+							}
+						}
+					}
+
+					/* Now we can convert to 16 bit. */
+					switch_normalize_to_16bit(z);
+					write_frame[x] = (int16_t) z;
+				}
+
+				switch_mutex_lock(omember->audio_out_mutex);
+				ok = switch_buffer_write(omember->mux_buffer, write_frame, bytes);
+				switch_mutex_unlock(omember->audio_out_mutex);
+
+				if (!ok) {
+					goto end;
+				}
+			}
+		}
+
+		if (conference->async_fnode && conference->async_fnode->done) {
+			switch_memory_pool_t *pool;
+			switch_core_file_close(&conference->async_fnode->fh);
+			pool = conference->async_fnode->pool;
+			conference->async_fnode = NULL;
+			switch_core_destroy_memory_pool(&pool);
+		}
+
+		if (conference->fnode && conference->fnode->done) {
+			conference_file_node_t *fnode;
+			switch_memory_pool_t *pool;
+
+			if (conference->fnode->type != NODE_TYPE_SPEECH) {
+				switch_core_file_close(&conference->fnode->fh);
+			}
+
+			fnode = conference->fnode;
+			conference->fnode = conference->fnode->next;
+
+			pool = fnode->pool;
+			fnode = NULL;
+			switch_core_destroy_memory_pool(&pool);
+		}
+
+		switch_mutex_unlock(conference->mutex);
+	}
+	/* Rinse ... Repeat */
+  end:
+
+	if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", conference->name);
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", conference->name, conference->domain);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", "Inactive");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", "idle");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", conference->name);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_HANGUP");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", "terminated");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", "inbound");
+		switch_event_fire(&event);
+	}
+
+	switch_mutex_lock(conference->mutex);
+	conference_stop_file(conference, FILE_STOP_ASYNC);
+	conference_stop_file(conference, FILE_STOP_ALL);
+	/* Close Unused Handles */
+	if (conference->fnode) {
+		conference_file_node_t *fnode, *cur;
+		switch_memory_pool_t *pool;
+
+		fnode = conference->fnode;
+		while (fnode) {
+			cur = fnode;
+			fnode = fnode->next;
+
+			if (cur->type != NODE_TYPE_SPEECH) {
+				switch_core_file_close(&cur->fh);
+			}
+
+			pool = cur->pool;
+			switch_core_destroy_memory_pool(&pool);
+		}
+		conference->fnode = NULL;
+	}
+
+	if (conference->async_fnode) {
+		switch_memory_pool_t *pool;
+		switch_core_file_close(&conference->async_fnode->fh);
+		pool = conference->async_fnode->pool;
+		conference->async_fnode = NULL;
+		switch_core_destroy_memory_pool(&pool);
+	}
+
+	switch_mutex_lock(conference->member_mutex);
+	for (imember = conference->members; imember; imember = imember->next) {
+		switch_channel_t *channel;
+
+		if (!switch_test_flag(imember, MFLAG_NOCHANNEL)) {
+			channel = switch_core_session_get_channel(imember->session);
+
+			/* add this little bit to preserve the bridge cause code in case of an early media call that */
+			/* never answers */
+			if (switch_test_flag(conference, CFLAG_ANSWERED)) {
+				switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
+			} else {
+				/* put actual cause code from outbound channel hangup here */
+				switch_channel_hangup(channel, conference->bridge_hangup_cause);
+			}
+		}
+
+		switch_clear_flag_locked(imember, MFLAG_RUNNING);
+	}
+	switch_mutex_unlock(conference->member_mutex);
+	switch_mutex_unlock(conference->mutex);
+
+	if (conference->video_running == 1) {
+		conference->video_running = -1;
+		while (conference->video_running) {
+			switch_cond_next();
+		}
+	}
+
+	if (switch_test_flag(conference, CFLAG_DESTRUCT)) {
+		switch_core_timer_destroy(&timer);
+		switch_mutex_lock(globals.hash_mutex);
+		switch_core_hash_delete(globals.conference_hash, conference->name);
+		switch_mutex_unlock(globals.hash_mutex);
+
+		/* Wait till everybody is out */
+		switch_clear_flag_locked(conference, CFLAG_RUNNING);
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Lock ON\n");
+		switch_thread_rwlock_wrlock(conference->rwlock);
+		switch_thread_rwlock_unlock(conference->rwlock);
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Lock OFF\n");
+
+		switch_ivr_digit_stream_parser_destroy(conference->dtmf_parser);
+
+		if (conference->sh) {
+			switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
+			switch_core_speech_close(&conference->lsh, &flags);
+			conference->sh = NULL;
+		}
+
+		if (conference->pool) {
+			switch_memory_pool_t *pool = conference->pool;
+			switch_core_destroy_memory_pool(&pool);
+		}
+	}
+
+	switch_mutex_lock(globals.hash_mutex);
+	globals.threads--;
+	switch_mutex_unlock(globals.hash_mutex);
+
+	return NULL;
+}
+
+static void conference_loop_fn_mute_toggle(conference_member_t *member, caller_control_action_t *action)
+{
+	if (member == NULL)
+		return;
+
+	if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+		conf_api_sub_mute(member, NULL, NULL);
+	} else {
+		conf_api_sub_unmute(member, NULL, NULL);
+		if (!switch_test_flag(member, MFLAG_CAN_HEAR)) {
+			conf_api_sub_undeaf(member, NULL, NULL);
+		}
+	}
+}
+
+static void conference_loop_fn_mute_on(conference_member_t *member, caller_control_action_t *action)
+{
+	if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+		conf_api_sub_mute(member, NULL, NULL);
+	}
+}
+
+static void conference_loop_fn_mute_off(conference_member_t *member, caller_control_action_t *action)
+{
+	if (!switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+		conf_api_sub_unmute(member, NULL, NULL);
+		if (!switch_test_flag(member, MFLAG_CAN_HEAR)) {
+			conf_api_sub_undeaf(member, NULL, NULL);
+		}
+	}
+}
+
+static void conference_loop_fn_lock_toggle(conference_member_t *member, caller_control_action_t *action)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	if (!switch_test_flag(member->conference, CFLAG_LOCKED)) {
+		if (member->conference->is_locked_sound) {
+			conference_play_file(member->conference, member->conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+		}
+
+		switch_set_flag_locked(member->conference, CFLAG_LOCKED);
+		if (test_eflag(member->conference, EFLAG_LOCK) &&
+			switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			conference_add_event_data(member->conference, event);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "lock");
+			switch_event_fire(&event);
+		}
+	} else {
+		if (member->conference->is_unlocked_sound) {
+			conference_play_file(member->conference, member->conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+		}
+
+		switch_clear_flag_locked(member->conference, CFLAG_LOCKED);
+		if (test_eflag(member->conference, EFLAG_UNLOCK) &&
+			switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			conference_add_event_data(member->conference, event);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
+			switch_event_fire(&event);
+		}
+	}
+
+}
+
+static void conference_loop_fn_deafmute_toggle(conference_member_t *member, caller_control_action_t *action)
+{
+	if (member == NULL)
+		return;
+
+	if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+		conf_api_sub_mute(member, NULL, NULL);
+		if (switch_test_flag(member, MFLAG_CAN_HEAR)) {
+			conf_api_sub_deaf(member, NULL, NULL);
+		}
+	} else {
+		conf_api_sub_unmute(member, NULL, NULL);
+		if (!switch_test_flag(member, MFLAG_CAN_HEAR)) {
+			conf_api_sub_undeaf(member, NULL, NULL);
+		}
+	}
+}
+
+static void conference_loop_fn_energy_up(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->energy_level += 200;
+	if (member->energy_level > 3000) {
+		member->energy_level = 3000;
+	}
+
+	if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_energy_equ_conf(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->energy_level = member->conference->energy_level;
+
+	if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_energy_dn(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->energy_level -= 100;
+	if (member->energy_level < 0) {
+		member->energy_level = 0;
+	}
+
+	if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_volume_talk_up(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->volume_out_level++;
+	switch_normalize_volume(member->volume_out_level);
+
+	if (test_eflag(member->conference, EFLAG_VOLUME_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_volume_talk_zero(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->volume_out_level = 0;
+
+	if (test_eflag(member->conference, EFLAG_VOLUME_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_volume_talk_dn(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->volume_out_level--;
+	switch_normalize_volume(member->volume_out_level);
+
+	if (test_eflag(member->conference, EFLAG_VOLUME_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_volume_listen_up(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->volume_in_level++;
+	switch_normalize_volume(member->volume_in_level);
+
+	if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_volume_listen_zero(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->volume_in_level = 0;
+
+	if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_volume_listen_dn(conference_member_t *member, caller_control_action_t *action)
+{
+	char msg[512];
+	switch_event_t *event;
+
+	if (member == NULL)
+		return;
+
+	lock_member(member);
+	member->volume_in_level--;
+	switch_normalize_volume(member->volume_in_level);
+
+	if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
+		switch_event_fire(&event);
+	}
+	unlock_member(member);
+
+	switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
+	conference_member_say(member, msg, 0);
+}
+
+static void conference_loop_fn_event(conference_member_t *member, caller_control_action_t *action)
+{
+	switch_event_t *event;
+	if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "dtmf");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "DTMF-Key", action->binded_dtmf);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Data", action->data);
+		switch_event_fire(&event);
+	}
+}
+
+static void conference_loop_fn_transfer(conference_member_t *member, caller_control_action_t *action)
+{
+	char *exten = NULL;
+	char *dialplan = "XML";
+	char *context = "default";
+
+	char *argv[3] = { 0 };
+	int argc;
+	char *mydata = NULL;
+	switch_event_t *event;
+
+	if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Dialplan", action->data);
+		switch_event_fire(&event);
+	}
+	switch_clear_flag_locked(member, MFLAG_RUNNING);
+
+	if ((mydata = switch_core_session_strdup(member->session, action->data))) {
+		if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
+			if (argc > 0) {
+				exten = argv[0];
+			}
+			if (argc > 1) {
+				dialplan = argv[1];
+			}
+			if (argc > 2) {
+				context = argv[2];
+			}
+
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Empty transfer string [%s]\n", (char *) action->data);
+			goto done;
+		}
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to allocate memory to duplicate transfer data.\n");
+		goto done;
+	}
+	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Transfering to: %s, %s, %s\n", exten, dialplan, context);
+
+	switch_ivr_session_transfer(member->session, exten, dialplan, context);
+
+  done:
+	return;
+}
+
+static void conference_loop_fn_exec_app(conference_member_t *member, caller_control_action_t *action)
+{
+	char *app = NULL;
+	char *arg = "";
+
+	char *argv[2] = { 0 };
+	int argc;
+	char *mydata = NULL;
+	switch_event_t *event = NULL;
+	switch_channel_t *channel = NULL;
+
+	if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "execute_app");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", action->data);
+		switch_event_fire(&event);
+	}
+
+	if ((mydata = switch_core_session_strdup(member->session, action->data))) {
+		if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
+			if (argc > 0) {
+				app = argv[0];
+			}
+			if (argc > 1) {
+				arg = argv[1];
+			}
+
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Empty execute app string [%s]\n", (char *) action->data);
+			goto done;
+		}
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to allocate memory to duplicate execute_app data.\n");
+		goto done;
+	}
+
+	if (!app) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to find application.\n");
+		goto done;
+	}
+	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Execute app: %s, %s\n", app, arg);
+
+	channel = switch_core_session_get_channel(member->session);
+
+	switch_channel_set_app_flag(channel, CF_APP_TAGGED);
+	switch_core_session_set_read_codec(member->session, NULL);
+	switch_core_session_execute_application(member->session, app, arg);
+	switch_core_session_set_read_codec(member->session, &member->read_codec);
+	switch_channel_clear_app_flag(channel, CF_APP_TAGGED);
+  done:
+	return;
+}
+
+static void conference_loop_fn_hangup(conference_member_t *member, caller_control_action_t *action)
+{
+	switch_clear_flag_locked(member, MFLAG_RUNNING);
+}
+
+/* marshall frames from the call leg to the conference thread for muxing to other call legs */
+static void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj)
+{
+	conference_member_t *member = obj;
+	switch_channel_t *channel;
+	switch_status_t status;
+	switch_frame_t *read_frame = NULL;
+	uint32_t hangover = 40, hangunder = 15, hangover_hits = 0, hangunder_hits = 0, energy_level = 0, diff_level = 400;
+	switch_codec_implementation_t read_impl = { 0 };
+	switch_core_session_t *session = member->session;
+	switch_assert(member != NULL);
+
+	switch_clear_flag_locked(member, MFLAG_TALKING);
+
+	channel = switch_core_session_get_channel(session);
+
+	switch_core_session_get_read_impl(session, &read_impl);
+
+	/* As long as we have a valid read, feed that data into an input buffer where the conference thread will take it 
+	   and mux it with any audio from other channels. */
+
+	while (switch_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {
+
+		if (switch_channel_ready(channel) && switch_channel_test_app_flag(channel, CF_APP_TAGGED)) {
+			switch_yield(100000);
+			continue;
+		}
+
+		/* Read a frame. */
+		status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
+
+		switch_mutex_lock(member->read_mutex);
+
+		/* end the loop, if appropriate */
+		if (!SWITCH_READ_ACCEPTABLE(status) || !switch_test_flag(member, MFLAG_RUNNING)) {
+			switch_mutex_unlock(member->read_mutex);
+			break;
+		}
+
+		if (switch_test_flag(read_frame, SFF_CNG)) {
+			if (hangunder_hits) {
+				hangunder_hits--;
+			}
+			if (switch_test_flag(member, MFLAG_TALKING)) {
+				switch_event_t *event;
+				if (++hangover_hits >= hangover) {
+					hangover_hits = hangunder_hits = 0;
+					switch_clear_flag_locked(member, MFLAG_TALKING);
+
+					if (test_eflag(member->conference, EFLAG_STOP_TALKING) &&
+						switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+						conference_add_event_member_data(member, event);
+						switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking");
+						switch_event_fire(&event);
+					}
+				}
+			}
+
+			goto do_continue;
+		}
+
+		energy_level = member->energy_level;
+
+		/* if the member can speak, compute the audio energy level and */
+		/* generate events when the level crosses the threshold        */
+		if ((switch_test_flag(member, MFLAG_CAN_SPEAK) || switch_test_flag(member, MFLAG_MUTE_DETECT)) && energy_level) {
+			uint32_t energy = 0, i = 0, samples = 0, j = 0;
+			int16_t *data;
+			int divisor = 0;
+
+			data = read_frame->data;
+
+			if (!(divisor = read_impl.actual_samples_per_second / 8000)) {
+				divisor = 1;
+			}
+
+			member->score = 0;
+
+			if ((samples = read_frame->datalen / sizeof(*data))) {
+				for (i = 0; i < samples; i++) {
+					energy += abs(data[j]);
+					j += read_impl.number_of_channels;
+				}
+				member->score = energy / (samples / divisor);
+			}
+
+			member->score_iir = (int) (((1.0 - SCORE_DECAY) * (float) member->score) + (SCORE_DECAY * (float) member->score_iir));
+
+			if (member->score_iir > SCORE_MAX_IIR) {
+				member->score_iir = SCORE_MAX_IIR;
+			}
+
+			if (member->score > energy_level) {
+				uint32_t diff = member->score - energy_level;
+				if (hangover_hits) {
+					hangover_hits--;
+				}
+
+				if (diff >= diff_level || ++hangunder_hits >= hangunder) {
+					hangover_hits = hangunder_hits = 0;
+
+					if (!switch_test_flag(member, MFLAG_TALKING)) {
+						switch_event_t *event;
+						switch_set_flag_locked(member, MFLAG_TALKING);
+						switch_mutex_lock(member->conference->member_mutex);
+						if ((!member->conference->floor_holder ||
+							 !switch_test_flag(member->conference->floor_holder, MFLAG_TALKING) ||
+							 ((member->score_iir > SCORE_IIR_SPEAKING_MAX) && (member->conference->floor_holder->score_iir < SCORE_IIR_SPEAKING_MIN))) &&
+							(!switch_test_flag(member->conference, CFLAG_VID_FLOOR) || switch_channel_test_flag(channel, CF_VIDEO))) {
+
+							if (test_eflag(member->conference, EFLAG_FLOOR_CHANGE) &&
+								switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+								conference_add_event_member_data(member, event);
+								switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "floor-change");
+								switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Old-ID", "%d",
+														member->conference->floor_holder ? member->conference->floor_holder->id : 0);
+								switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-ID", "%d", member->conference->floor_holder ? member->id : 0);
+								switch_event_fire(&event);
+							}
+							member->conference->floor_holder = member;
+						}
+						switch_mutex_unlock(member->conference->member_mutex);
+
+						if (test_eflag(member->conference, EFLAG_START_TALKING) && switch_test_flag(member, MFLAG_CAN_SPEAK) &&
+							switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+							conference_add_event_member_data(member, event);
+							switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "start-talking");
+							switch_event_fire(&event);
+						}
+
+						if (switch_test_flag(member, MFLAG_MUTE_DETECT) && !switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+
+							if (!zstr(member->conference->mute_detect_sound)) {
+								conference_member_play_file(member, member->conference->mute_detect_sound, 0);
+							}
+
+							if (test_eflag(member->conference, EFLAG_MUTE_DETECT) &&
+								switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+								conference_add_event_member_data(member, event);
+								switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "mute-detect");
+								switch_event_fire(&event);
+							}
+
+						}
+
+					}
+				}
+			} else {
+				if (hangunder_hits) {
+					hangunder_hits--;
+				}
+				if (switch_test_flag(member, MFLAG_TALKING) && switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+					switch_event_t *event;
+					if (++hangover_hits >= hangover) {
+						hangover_hits = hangunder_hits = 0;
+						switch_clear_flag_locked(member, MFLAG_TALKING);
+
+						if (test_eflag(member->conference, EFLAG_STOP_TALKING) &&
+							switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+							conference_add_event_member_data(member, event);
+							switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking");
+							switch_event_fire(&event);
+						}
+					}
+				}
+			}
+		}
+
+		/* skip frames that are not actual media or when we are muted or silent */
+		if ((switch_test_flag(member, MFLAG_TALKING) || energy_level == 0) && switch_test_flag(member, MFLAG_CAN_SPEAK) &&
+			!switch_test_flag(member->conference, CFLAG_WAIT_MOD)) {
+			switch_audio_resampler_t *read_resampler = member->read_resampler;
+			void *data;
+			uint32_t datalen;
+
+			if (read_resampler) {
+				int16_t *bptr = (int16_t *) read_frame->data;
+				int len = (int) read_frame->datalen;
+
+				switch_resample_process(read_resampler, bptr, len / 2);
+				memcpy(member->resample_out, read_resampler->to, read_resampler->to_len * 2);
+				len = read_resampler->to_len * 2;
+				datalen = len;
+				data = member->resample_out;
+			} else {
+				data = read_frame->data;
+				datalen = read_frame->datalen;
+			}
+
+			/* Check for input volume adjustments */
+			if (member->volume_in_level) {
+				switch_change_sln_volume(data, datalen / 2, member->volume_in_level);
+			}
+
+			if (datalen) {
+				switch_size_t ok = 1;
+
+				/* Write the audio into the input buffer */
+				switch_mutex_lock(member->audio_in_mutex);
+				ok = switch_buffer_write(member->audio_buffer, data, datalen);
+				switch_mutex_unlock(member->audio_in_mutex);
+				if (!ok) {
+					switch_mutex_unlock(member->read_mutex);
+					break;
+				}
+			}
+		}
+
+	  do_continue:
+
+		switch_mutex_unlock(member->read_mutex);
+	}
+
+
+	switch_resample_destroy(&member->read_resampler);
+	switch_clear_flag_locked(member, MFLAG_ITHREAD);
+
+	return NULL;
+}
+
+
+static void member_add_file_data(conference_member_t *member, int16_t *data, switch_size_t file_data_len)
+{
+	switch_size_t file_sample_len = file_data_len / 2;
+	int16_t file_frame[SWITCH_RECOMMENDED_BUFFER_SIZE / 2] = { 0 };
+
+	if (!member->fnode) {
+		return;
+	}
+
+	/* if we are done, clean it up */
+	if (member->fnode->done) {
+		conference_file_node_t *fnode;
+		switch_memory_pool_t *pool;
+
+		if (member->fnode->type != NODE_TYPE_SPEECH) {
+			switch_core_file_close(&member->fnode->fh);
+		}
+
+		fnode = member->fnode;
+		member->fnode = member->fnode->next;
+
+		pool = fnode->pool;
+		fnode = NULL;
+		switch_core_destroy_memory_pool(&pool);
+	} else {
+		/* skip this frame until leadin time has expired */
+		if (member->fnode->leadin) {
+			member->fnode->leadin--;
+		} else {
+			if (member->fnode->type == NODE_TYPE_SPEECH) {
+				switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_BLOCKING;
+
+				if (switch_core_speech_read_tts(member->fnode->sh, file_frame, &file_data_len, &flags) == SWITCH_STATUS_SUCCESS) {
+					file_sample_len = file_data_len / 2;
+				} else {
+					file_sample_len = file_data_len = 0;
+				}
+			} else if (member->fnode->type == NODE_TYPE_FILE) {
+				switch_core_file_read(&member->fnode->fh, file_frame, &file_sample_len);
+				file_data_len = file_sample_len * 2;
+			}
+
+			if (file_sample_len <= 0) {
+				switch_event_t *event;
+				member->fnode->done++;
+
+				if (test_eflag(member->conference, EFLAG_PLAY_FILE) &&
+					switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+					conference_add_event_data(member->conference, event);
+					conference_add_event_member_data(member, event);
+					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "play-file-member-done");
+					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File", member->fnode->file);
+					switch_event_fire(&event);
+				}
+			} else {			/* there is file node data to mix into the frame */
+				int32_t i, sample;
+
+				/* Check for output volume adjustments */
+				if (member->volume_out_level) {
+					switch_change_sln_volume(file_frame, file_sample_len, member->volume_out_level);
+				}
+
+				for (i = 0; i < file_sample_len; i++) {
+					sample = data[i] + file_frame[i];
+					switch_normalize_to_16bit(sample);
+					data[i] = sample;
+				}
+
+			}
+		}
+	}
+}
+
+
+
+/* launch an input thread for the call leg */
+static void launch_conference_loop_input(conference_member_t *member, switch_memory_pool_t *pool)
+{
+	switch_thread_t *thread;
+	switch_threadattr_t *thd_attr = NULL;
+
+	if (member == NULL)
+		return;
+
+	switch_threadattr_create(&thd_attr, pool);
+	switch_threadattr_detach_set(thd_attr, 1);
+	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+	switch_set_flag_locked(member, MFLAG_ITHREAD);
+	switch_thread_create(&thread, thd_attr, conference_loop_input, member, pool);
+}
+
+static caller_control_fn_table_t ccfntbl[] = {
+	{"mute", "0", CALLER_CONTROL_MUTE, conference_loop_fn_mute_toggle},
+	{"mute on", NULL, CALLER_CONTROL_MUTE_ON, conference_loop_fn_mute_on},
+	{"mute off", NULL, CALLER_CONTROL_MUTE_OFF, conference_loop_fn_mute_off},
+	{"deaf mute", "*", CALLER_CONTROL_DEAF_MUTE, conference_loop_fn_deafmute_toggle},
+	{"energy up", "9", CALLER_CONTROL_ENERGY_UP, conference_loop_fn_energy_up},
+	{"energy equ", "8", CALLER_CONTROL_ENERGY_EQU_CONF, conference_loop_fn_energy_equ_conf},
+	{"energy dn", "7", CALLER_CONTROL_ENERGEY_DN, conference_loop_fn_energy_dn},
+	{"vol talk up", "3", CALLER_CONTROL_VOL_TALK_UP, conference_loop_fn_volume_talk_up},
+	{"vol talk zero", "2", CALLER_CONTROL_VOL_TALK_ZERO, conference_loop_fn_volume_talk_zero},
+	{"vol talk dn", "1", CALLER_CONTROL_VOL_TALK_DN, conference_loop_fn_volume_talk_dn},
+	{"vol listen up", "6", CALLER_CONTROL_VOL_LISTEN_UP, conference_loop_fn_volume_listen_up},
+	{"vol listen zero", "5", CALLER_CONTROL_VOL_LISTEN_ZERO, conference_loop_fn_volume_listen_zero},
+	{"vol listen dn", "4", CALLER_CONTROL_VOL_LISTEN_DN, conference_loop_fn_volume_listen_dn},
+	{"hangup", "#", CALLER_CONTROL_HANGUP, conference_loop_fn_hangup},
+	{"event", NULL, CALLER_CONTROL_EVENT, conference_loop_fn_event},
+	{"lock", NULL, CALLER_CONTROL_LOCK, conference_loop_fn_lock_toggle},
+	{"transfer", NULL, CALLER_CONTROL_TRANSFER, conference_loop_fn_transfer},
+	{"execute_application", NULL, CALLER_CONTROL_EXEC_APP, conference_loop_fn_exec_app}
+};
+
+#define CCFNTBL_QTY (sizeof(ccfntbl)/sizeof(ccfntbl[0]))
+
+/* marshall frames from the conference (or file or tts output) to the call leg */
+/* NB. this starts the input thread after some initial setup for the call leg */
+static void conference_loop_output(conference_member_t *member)
+{
+	switch_channel_t *channel;
+	switch_frame_t write_frame = { 0 };
+	uint8_t *data = NULL;
+	switch_timer_t timer = { 0 };
+	uint32_t interval;
+	uint32_t samples;
+	uint32_t csamples;
+	uint32_t tsamples;
+	uint32_t flush_len;
+	uint32_t low_count, bytes;
+	call_list_t *call_list, *cp;
+	int restarting = -1;
+	switch_codec_implementation_t read_impl = { 0 };
+
+  top:
+
+	switch_core_session_get_read_impl(member->session, &read_impl);
+
+	restarting++;
+
+	if (switch_test_flag(member, MFLAG_RESTART)) {
+		switch_clear_flag(member, MFLAG_RESTART);
+		switch_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+		switch_core_timer_destroy(&timer);
+	}
+
+	channel = switch_core_session_get_channel(member->session);
+	interval = read_impl.microseconds_per_packet / 1000;
+	samples = switch_samples_per_packet(member->conference->rate, interval);
+	csamples = samples;
+	tsamples = member->orig_read_impl.samples_per_packet;
+	flush_len = 0;
+	low_count = 0;
+	bytes = samples * 2;
+	call_list = NULL;
+	cp = NULL;
+
+
+
+	switch_assert(member->conference != NULL);
+
+	flush_len = switch_samples_per_packet(member->conference->rate, member->conference->interval) * 10;
+
+	if (switch_core_timer_init(&timer, member->conference->timer_name, interval, tsamples, NULL) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Timer Setup Failed.  Conference Cannot Start\n");
+		return;
+	}
+
+	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Setup timer %s success interval: %u  samples: %u\n",
+					  member->conference->timer_name, interval, tsamples);
+
+	if (!restarting) {
+		write_frame.data = data = switch_core_session_alloc(member->session, SWITCH_RECOMMENDED_BUFFER_SIZE);
+		write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
+	}
+
+	write_frame.codec = &member->write_codec;
+
+	if (!switch_test_flag(member->conference, CFLAG_ANSWERED)) {
+		switch_channel_answer(channel);
+	}
+
+	if (!restarting) {
+		/* Start the input thread */
+		launch_conference_loop_input(member, switch_core_session_get_pool(member->session));
+
+		/* build a digit stream object */
+		if (member->conference->dtmf_parser != NULL
+			&& switch_ivr_digit_stream_new(member->conference->dtmf_parser, &member->digit_stream) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR,
+							  "Danger Will Robinson, there is no digit parser stream object\n");
+		}
+
+		if ((call_list = switch_channel_get_private(channel, "_conference_autocall_list_"))) {
+			const char *cid_name = switch_channel_get_variable(channel, "conference_auto_outcall_caller_id_name");
+			const char *cid_num = switch_channel_get_variable(channel, "conference_auto_outcall_caller_id_number");
+			const char *toval = switch_channel_get_variable(channel, "conference_auto_outcall_timeout");
+			const char *flags = switch_channel_get_variable(channel, "conference_auto_outcall_flags");
+			const char *ann = switch_channel_get_variable(channel, "conference_auto_outcall_announce");
+			const char *prefix = switch_channel_get_variable(channel, "conference_auto_outcall_prefix");
+			int to = 60;
+
+			if (ann) {
+				member->conference->special_announce = switch_core_strdup(member->conference->pool, ann);
+			}
+
+			switch_channel_set_private(channel, "_conference_autocall_list_", NULL);
+
+			if (toval) {
+				to = atoi(toval);
+				if (to < 10 || to > 500) {
+					to = 60;
+				}
+			}
+
+			for (cp = call_list; cp; cp = cp->next) {
+				int argc;
+				char *argv[512] = { 0 };
+				char *cpstr = strdup(cp->string);
+				int x = 0;
+
+				switch_assert(cpstr);
+				argc = switch_separate_string(cpstr, ',', argv, (sizeof(argv) / sizeof(argv[0])));
+				for (x = 0; x < argc; x++) {
+					char *dial_str = switch_mprintf("%s%s", switch_str_nil(prefix), argv[x]);
+					switch_assert(dial_str);
+					conference_outcall_bg(member->conference, NULL, NULL, dial_str, to, switch_str_nil(flags), cid_name, cid_num, NULL);
+					switch_safe_free(dial_str);
+				}
+				switch_safe_free(cpstr);
+			}
+		}
+	}
+
+	if (restarting) {
+		switch_channel_clear_app_flag(channel, CF_APP_TAGGED);
+	}
+
+	/* Fair WARNING, If you expect the caller to hear anything or for digit handling to be processed,      */
+	/* you better not block this thread loop for more than the duration of member->conference->timer_name!  */
+	while (switch_test_flag(member, MFLAG_RUNNING) && switch_test_flag(member, MFLAG_ITHREAD)
+		   && switch_channel_ready(channel)) {
+		char dtmf[128] = "";
+		char *digit;
+		switch_event_t *event;
+		caller_control_action_t *caller_action = NULL;
+		int use_timer = 0;
+		switch_buffer_t *use_buffer = NULL;
+		uint32_t mux_used = 0;
+
+		switch_mutex_lock(member->write_mutex);
+
+		if (switch_test_flag(member, MFLAG_RESTART)) {
+			switch_mutex_unlock(member->write_mutex);
+			goto top;
+		}
+
+		if (switch_core_session_dequeue_event(member->session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
+			if (event->event_id == SWITCH_EVENT_MESSAGE) {
+				char *from = switch_event_get_header(event, "from");
+				char *to = switch_event_get_header(event, "to");
+				char *proto = switch_event_get_header(event, "proto");
+				char *subject = switch_event_get_header(event, "subject");
+				char *hint = switch_event_get_header(event, "hint");
+				char *body = switch_event_get_body(event);
+				char *p, *freeme = NULL;
+
+				if (to && from && body) {
+					if ((p = strchr(to, '+')) && strncmp(to, CONF_CHAT_PROTO, strlen(CONF_CHAT_PROTO))) {
+						freeme = switch_mprintf("%s+%s@%s", CONF_CHAT_PROTO, member->conference->name, member->conference->domain);
+						to = freeme;
+					}
+					chat_send(proto, from, to, subject, body, NULL, hint);
+					switch_safe_free(freeme);
+				}
+			}
+			switch_event_destroy(&event);
+		}
+
+		if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+			/* test to see if outbound channel has answered */
+			if (switch_channel_test_flag(channel, CF_ANSWERED) && !switch_test_flag(member->conference, CFLAG_ANSWERED)) {
+				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG,
+								  "Outbound conference channel answered, setting CFLAG_ANSWERED\n");
+				switch_set_flag(member->conference, CFLAG_ANSWERED);
+			}
+		} else {
+			if (switch_test_flag(member->conference, CFLAG_ANSWERED) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
+				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "CLFAG_ANSWERED set, answering inbound channel\n");
+				switch_channel_answer(channel);
+			}
+		}
+
+		/* if we have caller digits, feed them to the parser to find an action */
+		if (switch_channel_has_dtmf(channel)) {
+			switch_channel_dequeue_dtmf_string(channel, dtmf, sizeof(dtmf));
+
+			if (switch_test_flag(member, MFLAG_DIST_DTMF)) {
+				conference_send_all_dtmf(member, member->conference, dtmf);
+			} else {
+				if (member->conference->dtmf_parser != NULL) {
+					for (digit = dtmf; *digit && caller_action == NULL; digit++) {
+						caller_action = (caller_control_action_t *)
+							switch_ivr_digit_stream_parser_feed(member->conference->dtmf_parser, member->digit_stream, *digit);
+					}
+				}
+			}
+			/* otherwise, clock the parser so that it can handle digit timeout detection */
+		} else if (member->conference->dtmf_parser != NULL) {
+			caller_action = (caller_control_action_t *) switch_ivr_digit_stream_parser_feed(member->conference->dtmf_parser, member->digit_stream, '\0');
+		}
+
+		/* if a caller action has been detected, handle it */
+		if (caller_action != NULL && caller_action->fndesc != NULL && caller_action->fndesc->handler != NULL) {
+			char *param = NULL;
+
+			if (caller_action->fndesc->action != CALLER_CONTROL_MENU) {
+				param = caller_action->data;
+			}
+#ifdef INTENSE_DEBUG
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session),
+							  SWITCH_LOG_INFO,
+							  "executing caller control '%s' param '%s' on call '%u, %s\n",
+							  caller_action->fndesc->key, param ? param : "none", member->id, switch_channel_get_name(channel));
+#endif
+
+			caller_action->fndesc->handler(member, caller_action);
+
+			/* set up for next pass */
+			caller_action = NULL;
+		}
+
+
+		use_buffer = NULL;
+		mux_used = (uint32_t) switch_buffer_inuse(member->mux_buffer);
+
+		if (mux_used) {
+			if (mux_used < bytes) {
+				if (++low_count >= 5) {
+					/* partial frame sitting around this long is useless and builds delay */
+					switch_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+				}
+			} else if (mux_used > flush_len) {
+				/* getting behind, clear the buffer */
+				switch_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+			}
+		}
+
+
+		use_timer = 1;
+
+		if (mux_used) {
+			/* Flush the output buffer and write all the data (presumably muxed) back to the channel */
+			switch_mutex_lock(member->audio_out_mutex);
+			write_frame.data = data;
+			use_buffer = member->mux_buffer;
+			low_count = 0;
+			if ((write_frame.datalen = (uint32_t) switch_buffer_read(use_buffer, write_frame.data, bytes))) {
+				if (write_frame.datalen) {
+               write_frame.samples = write_frame.datalen / 2;
+				   
+				   if( !switch_test_flag(member, MFLAG_CAN_HEAR)) {
+				      memset(write_frame.data, 255, write_frame.datalen);
+				   }
+				   else {
+   					/* Check for output volume adjustments */
+   					if (member->volume_out_level) {
+   						switch_change_sln_volume(write_frame.data, write_frame.samples, member->volume_out_level);
+   					}
+				   }
+					write_frame.timestamp = timer.samplecount;
+					if (member->fnode) {
+						member_add_file_data(member, write_frame.data, write_frame.datalen);
+					}
+					switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
+				}
+			}
+
+			switch_mutex_unlock(member->audio_out_mutex);
+		} else if (member->fnode) {
+			write_frame.datalen = bytes;
+			write_frame.samples = samples;
+			memset(write_frame.data, 255, write_frame.datalen);
+			member_add_file_data(member, write_frame.data, write_frame.datalen);
+			switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
+		} else if (!switch_test_flag(member->conference, CFLAG_WASTE_BANDWIDTH)) {
+			if (switch_test_flag(member, MFLAG_WASTE_BANDWIDTH)) {
+				if (member->conference->comfort_noise_level) {
+					switch_generate_sln_silence(write_frame.data, samples, member->conference->comfort_noise_level);
+				} else {
+					memset(write_frame.data, 255, bytes);
+				}
+
+				write_frame.datalen = bytes;
+				write_frame.samples = samples;
+				write_frame.timestamp = timer.samplecount;
+
+				switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
+			}
+		}
+
+		if (switch_test_flag(member, MFLAG_FLUSH_BUFFER)) {
+			if (switch_buffer_inuse(member->mux_buffer)) {
+				switch_mutex_lock(member->audio_out_mutex);
+				switch_buffer_zero(member->mux_buffer);
+				switch_mutex_unlock(member->audio_out_mutex);
+			}
+			switch_clear_flag_locked(member, MFLAG_FLUSH_BUFFER);
+		}
+
+		switch_mutex_unlock(member->write_mutex);
+
+
+		if (switch_core_session_private_event_count(member->session)) {
+			switch_channel_set_app_flag(channel, CF_APP_TAGGED);
+			switch_ivr_parse_all_events(member->session);
+			switch_channel_clear_app_flag(channel, CF_APP_TAGGED);
+			switch_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+			switch_core_session_set_read_codec(member->session, &member->read_codec);
+		} else {
+			switch_ivr_parse_all_messages(member->session);
+		}
+
+		if (use_timer) {
+			switch_core_timer_next(&timer);
+		} else {
+			switch_cond_next();
+		}
+
+	}							/* Rinse ... Repeat */
+
+
+	if (member->digit_stream != NULL) {
+		switch_ivr_digit_stream_destroy(&member->digit_stream);
+	}
+
+	switch_clear_flag_locked(member, MFLAG_RUNNING);
+	switch_core_timer_destroy(&timer);
+
+	switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "Channel leaving conference, cause: %s\n",
+					  switch_channel_cause2str(switch_channel_get_cause(channel)));
+
+	/* if it's an outbound channel, store the release cause in the conference struct, we might need it */
+	if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+		member->conference->bridge_hangup_cause = switch_channel_get_cause(channel);
+	}
+
+	/* Wait for the input thread to end */
+	while (switch_test_flag(member, MFLAG_ITHREAD)) {
+		switch_cond_next();
+	}
+}
+
+/* Sub-Routine called by a record entity inside a conference */
+static void *SWITCH_THREAD_FUNC conference_record_thread_run(switch_thread_t *thread, void *obj)
+{
+	int16_t *data_buf;
+	switch_file_handle_t fh = { 0 };
+	conference_member_t smember = { 0 }, *member;
+	conference_record_t *rec = (conference_record_t *) obj;
+	conference_obj_t *conference = rec->conference;
+	uint32_t samples = switch_samples_per_packet(conference->rate, conference->interval);
+	uint32_t low_count = 0, mux_used;
+	char *vval;
+	switch_timer_t timer = { 0 };
+	uint32_t rlen;
+	switch_size_t data_buf_len;
+
+	data_buf_len = samples * sizeof(int16_t);
+
+	switch_zmalloc(data_buf, data_buf_len);
+
+	if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Read Lock Fail\n");
+		return NULL;
+	}
+
+	switch_mutex_lock(globals.hash_mutex);
+	globals.threads++;
+	switch_mutex_unlock(globals.hash_mutex);
+
+	member = &smember;
+
+	member->flags = MFLAG_CAN_HEAR | MFLAG_NOCHANNEL | MFLAG_RUNNING;
+
+	member->conference = conference;
+	member->native_rate = conference->rate;
+	member->rec_path = rec->path;
+	fh.channels = 1;
+	fh.samplerate = conference->rate;
+	member->id = next_member_id();
+	member->pool = rec->pool;
+
+	member->frame_size = SWITCH_RECOMMENDED_BUFFER_SIZE;
+	member->frame = switch_core_alloc(member->pool, member->frame_size);
+	member->mux_frame = switch_core_alloc(member->pool, member->frame_size);
+
+
+	switch_mutex_init(&member->write_mutex, SWITCH_MUTEX_NESTED, rec->pool);
+	switch_mutex_init(&member->flag_mutex, SWITCH_MUTEX_NESTED, rec->pool);
+	switch_mutex_init(&member->audio_in_mutex, SWITCH_MUTEX_NESTED, rec->pool);
+	switch_mutex_init(&member->audio_out_mutex, SWITCH_MUTEX_NESTED, rec->pool);
+	switch_mutex_init(&member->read_mutex, SWITCH_MUTEX_NESTED, rec->pool);
+
+	/* Setup an audio buffer for the incoming audio */
+	if (switch_buffer_create_dynamic(&member->audio_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, 0) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
+		goto end;
+	}
+
+	/* Setup an audio buffer for the outgoing audio */
+	if (switch_buffer_create_dynamic(&member->mux_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, 0) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
+		goto end;
+	}
+
+	if (conference_add_member(conference, member) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Joining Conference\n");
+		goto end;
+	}
+
+	fh.pre_buffer_datalen = SWITCH_DEFAULT_FILE_BUFFER_LEN;
+
+	if (switch_core_file_open(&fh,
+							  rec->path, (uint8_t) 1, conference->rate, SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT,
+							  rec->pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening File [%s]\n", rec->path);
+		goto end;
+	}
+
+
+	if (switch_core_timer_init(&timer, conference->timer_name, conference->interval, samples, rec->pool) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Setup timer success interval: %u  samples: %u\n", conference->interval, samples);
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Setup Failed.  Conference Cannot Start\n");
+		goto end;
+	}
+
+	if ((vval = switch_mprintf("Conference %s", conference->name))) {
+		switch_core_file_set_string(&fh, SWITCH_AUDIO_COL_STR_TITLE, vval);
+		switch_safe_free(vval);
+	}
+
+	switch_core_file_set_string(&fh, SWITCH_AUDIO_COL_STR_ARTIST, "FreeSWITCH mod_conference Software Conference Module");
+
+	while (switch_test_flag(member, MFLAG_RUNNING) && switch_test_flag(conference, CFLAG_RUNNING) && conference->count) {
+		switch_size_t len = 0;
+		mux_used = (uint32_t) switch_buffer_inuse(member->mux_buffer);
+
+		if (switch_test_flag(member, MFLAG_FLUSH_BUFFER)) {
+			if (mux_used) {
+				switch_mutex_lock(member->audio_out_mutex);
+				switch_buffer_zero(member->mux_buffer);
+				switch_mutex_unlock(member->audio_out_mutex);
+				mux_used = 0;
+			}
+			switch_clear_flag_locked(member, MFLAG_FLUSH_BUFFER);
+		}
+
+		if (switch_test_flag((&fh), SWITCH_FILE_PAUSE)) {
+			switch_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+		} else {
+			if (mux_used) {
+				/* Flush the output buffer and write all the data (presumably muxed) to the file */
+				switch_mutex_lock(member->audio_out_mutex);
+				low_count = 0;
+
+				if ((rlen = (uint32_t) switch_buffer_read(member->mux_buffer, data_buf, data_buf_len))) {
+					len = (switch_size_t) rlen / sizeof(int16_t);
+				}
+				switch_mutex_unlock(member->audio_out_mutex);
+			}
+
+			if (len < (switch_size_t) samples) {
+				memset(data_buf + (len * sizeof(int16_t)), 255, ((switch_size_t) samples - len) * sizeof(int16_t));
+				len = (switch_size_t) samples;
+			}
+
+			if (!len || switch_core_file_write(&fh, data_buf, &len) != SWITCH_STATUS_SUCCESS) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Failed\n");
+				switch_clear_flag_locked(member, MFLAG_RUNNING);
+			}
+		}
+
+		switch_core_timer_next(&timer);
+	}							/* Rinse ... Repeat */
+
+  end:
+
+	switch_safe_free(data_buf);
+	switch_core_timer_destroy(&timer);
+	conference_del_member(conference, member);
+	switch_buffer_destroy(&member->audio_buffer);
+	switch_buffer_destroy(&member->mux_buffer);
+	switch_clear_flag_locked(member, MFLAG_RUNNING);
+	if (switch_test_flag((&fh), SWITCH_FILE_OPEN)) {
+		switch_core_file_close(&fh);
+	}
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Recording of %s Stopped\n", rec->path);
+
+	if (rec->pool) {
+		switch_memory_pool_t *pool = rec->pool;
+		rec = NULL;
+		switch_core_destroy_memory_pool(&pool);
+	}
+
+	switch_mutex_lock(globals.hash_mutex);
+	globals.threads--;
+	switch_mutex_unlock(globals.hash_mutex);
+
+	switch_thread_rwlock_unlock(conference->rwlock);
+	return NULL;
+}
+
+/* Make files stop playing in a conference either the current one or all of them */
+static uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop)
+{
+	uint32_t count = 0;
+	conference_file_node_t *nptr;
+
+	switch_assert(conference != NULL);
+
+	switch_mutex_lock(conference->mutex);
+
+	if (stop == FILE_STOP_ALL) {
+		for (nptr = conference->fnode; nptr; nptr = nptr->next) {
+			nptr->done++;
+			count++;
+		}
+		if (conference->async_fnode) {
+			conference->async_fnode->done++;
+			count++;
+		}
+	} else if (stop == FILE_STOP_ASYNC) {
+		if (conference->async_fnode) {
+			conference->async_fnode->done++;
+			count++;
+		}
+	} else {
+		if (conference->fnode) {
+			conference->fnode->done++;
+			count++;
+		}
+	}
+
+	switch_mutex_unlock(conference->mutex);
+
+	return count;
+}
+
+/* stop playing a file for the member of the conference */
+static uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop)
+{
+	conference_file_node_t *nptr;
+	uint32_t count = 0;
+
+	if (member == NULL)
+		return count;
+
+	lock_member(member);
+
+	if (stop == FILE_STOP_ALL) {
+		for (nptr = member->fnode; nptr; nptr = nptr->next) {
+			nptr->done++;
+			count++;
+		}
+	} else {
+		if (member->fnode) {
+			member->fnode->done++;
+			count++;
+		}
+	}
+
+	unlock_member(member);
+
+	return count;
+}
+
+static void conference_send_all_dtmf(conference_member_t *member, conference_obj_t *conference, const char *dtmf)
+{
+	conference_member_t *imember;
+
+	switch_mutex_lock(conference->mutex);
+	switch_mutex_lock(conference->member_mutex);
+
+	for (imember = conference->members; imember; imember = imember->next) {
+		/* don't send to self */
+		if (imember->id == member->id) {
+			continue;
+		}
+		if (imember->session) {
+			const char *p;
+			for (p = dtmf; p && *p; p++) {
+				switch_dtmf_t digit = { *p, SWITCH_DEFAULT_DTMF_DURATION };
+				lock_member(imember);
+				switch_core_session_kill_channel(imember->session, SWITCH_SIG_BREAK);
+				switch_core_session_send_dtmf(imember->session, &digit);
+				unlock_member(imember);
+			}
+		}
+	}
+
+	switch_mutex_unlock(conference->member_mutex);
+	switch_mutex_unlock(conference->mutex);
+}
+
+/* Play a file in the conference room */
+static switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async)
+{
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+	conference_file_node_t *fnode, *nptr = NULL;
+	switch_memory_pool_t *pool;
+	uint32_t count;
+	char *dfile = NULL, *expanded = NULL;
+	int say = 0;
+
+	switch_assert(conference != NULL);
+
+	switch_mutex_lock(conference->mutex);
+	switch_mutex_lock(conference->member_mutex);
+	count = conference->count;
+	switch_mutex_unlock(conference->member_mutex);
+	switch_mutex_unlock(conference->mutex);
+
+	if (!count)
+		return SWITCH_STATUS_FALSE;
+
+	if (channel) {
+		if ((expanded = switch_channel_expand_variables(channel, file)) != file) {
+			file = expanded;
+		} else {
+			expanded = NULL;
+		}
+	}
+
+	if (!strncasecmp(file, "say:", 4)) {
+		say = 1;
+	}
+
+	if (!async && say) {
+		status = conference_say(conference, file + 4, leadin);
+		goto done;
+	}
+
+	if (!switch_is_file_path(file)) {
+		if (!say && conference->sound_prefix) {
+			if (!(dfile = switch_mprintf("%s%s%s", conference->sound_prefix, SWITCH_PATH_SEPARATOR, file))) {
+				goto done;
+			}
+			file = dfile;
+		} else if (!async) {
+			status = conference_say(conference, file, leadin);
+			goto done;
+		} else {
+			goto done;
+		}
+	}
+
+	/* Setup a memory pool to use. */
+	if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+		status = SWITCH_STATUS_MEMERR;
+		goto done;
+	}
+
+	/* Create a node object */
+	if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n");
+		switch_core_destroy_memory_pool(&pool);
+		status = SWITCH_STATUS_MEMERR;
+		goto done;
+	}
+
+	fnode->type = NODE_TYPE_FILE;
+	fnode->leadin = leadin;
+
+	/* Open the file */
+	fnode->fh.pre_buffer_datalen = SWITCH_DEFAULT_FILE_BUFFER_LEN;
+	if (switch_core_file_open(&fnode->fh, file, (uint8_t) 1, conference->rate, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, pool) !=
+		SWITCH_STATUS_SUCCESS) {
+		switch_core_destroy_memory_pool(&pool);
+		status = SWITCH_STATUS_NOTFOUND;
+		goto done;
+	}
+
+	fnode->pool = pool;
+	fnode->async = async;
+	fnode->file = switch_core_strdup(fnode->pool, file);
+
+	/* Queue the node */
+	switch_mutex_lock(conference->mutex);
+
+	if (async) {
+		if (conference->async_fnode) {
+			nptr = conference->async_fnode;
+		}
+		conference->async_fnode = fnode;
+
+		if (nptr) {
+			switch_memory_pool_t *tmppool;
+			switch_core_file_close(&nptr->fh);
+			tmppool = nptr->pool;
+			switch_core_destroy_memory_pool(&tmppool);
+		}
+
+	} else {
+		for (nptr = conference->fnode; nptr && nptr->next; nptr = nptr->next);
+
+		if (nptr) {
+			nptr->next = fnode;
+		} else {
+			conference->fnode = fnode;
+		}
+	}
+
+	switch_mutex_unlock(conference->mutex);
+
+  done:
+
+	switch_safe_free(expanded);
+	switch_safe_free(dfile);
+
+	return status;
+}
+
+/* Play a file in the conference room to a member */
+static switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	char *dfile = NULL, *expanded = NULL;
+	conference_file_node_t *fnode, *nptr = NULL;
+	switch_memory_pool_t *pool;
+
+	if (member == NULL || file == NULL)
+		return status;
+
+	if ((expanded = switch_channel_expand_variables(switch_core_session_get_channel(member->session), file)) != file) {
+		file = expanded;
+	} else {
+		expanded = NULL;
+	}
+	if (!strncasecmp(file, "say:", 4)) {
+		if (!zstr(file + 4)) {
+			status = conference_member_say(member, file + 4, leadin);
+		}
+		goto done;
+	}
+	if (!switch_is_file_path(file)) {
+		if (member->conference->sound_prefix) {
+			if (!(dfile = switch_mprintf("%s%s%s", member->conference->sound_prefix, SWITCH_PATH_SEPARATOR, file))) {
+				goto done;
+			}
+			file = dfile;
+		} else if (!zstr(file)) {
+			status = conference_member_say(member, file, leadin);
+			goto done;
+		}
+	}
+	/* Setup a memory pool to use. */
+	if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Pool Failure\n");
+		status = SWITCH_STATUS_MEMERR;
+		goto done;
+	}
+	/* Create a node object */
+	if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Alloc Failure\n");
+		switch_core_destroy_memory_pool(&pool);
+		status = SWITCH_STATUS_MEMERR;
+		goto done;
+	}
+	fnode->type = NODE_TYPE_FILE;
+	fnode->leadin = leadin;
+	/* Open the file */
+	fnode->fh.pre_buffer_datalen = SWITCH_DEFAULT_FILE_BUFFER_LEN;
+	if (switch_core_file_open(&fnode->fh,
+							  file, (uint8_t) 1, member->conference->rate, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT,
+							  pool) != SWITCH_STATUS_SUCCESS) {
+		switch_core_destroy_memory_pool(&pool);
+		status = SWITCH_STATUS_NOTFOUND;
+		goto done;
+	}
+	fnode->pool = pool;
+	fnode->file = switch_core_strdup(fnode->pool, file);
+	/* Queue the node */
+	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Queueing file '%s' for play\n", file);
+	lock_member(member);
+	for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next);
+	if (nptr) {
+		nptr->next = fnode;
+	} else {
+		member->fnode = fnode;
+	}
+	unlock_member(member);
+	status = SWITCH_STATUS_SUCCESS;
+
+  done:
+
+	switch_safe_free(expanded);
+	switch_safe_free(dfile);
+
+	return status;
+}
+
+/* Say some thing with TTS in the conference room */
+static switch_status_t conference_member_say(conference_member_t *member, char *text, uint32_t leadin)
+{
+	conference_obj_t *conference = (member != NULL ? member->conference : NULL);
+	conference_file_node_t *fnode, *nptr;
+	switch_memory_pool_t *pool;
+	switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+
+	if (member == NULL || zstr(text))
+		return SWITCH_STATUS_FALSE;
+
+	switch_assert(conference != NULL);
+
+	if (!(conference->tts_engine && conference->tts_voice)) {
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	/* Setup a memory pool to use. */
+	if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Pool Failure\n");
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	/* Create a node object */
+	if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Alloc Failure\n");
+		switch_core_destroy_memory_pool(&pool);
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	fnode->type = NODE_TYPE_SPEECH;
+	fnode->leadin = leadin;
+	fnode->pool = pool;
+
+	if (!member->sh) {
+		memset(&member->lsh, 0, sizeof(member->lsh));
+		if (switch_core_speech_open(&member->lsh, conference->tts_engine, conference->tts_voice,
+									conference->rate, conference->interval, &flags, switch_core_session_get_pool(member->session)) !=
+			SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine);
+			return SWITCH_STATUS_FALSE;
+		}
+		member->sh = &member->lsh;
+	}
+
+	/* Queue the node */
+	lock_member(member);
+	for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next);
+
+	if (nptr) {
+		nptr->next = fnode;
+	} else {
+		member->fnode = fnode;
+	}
+
+	fnode->sh = member->sh;
+	/* Begin Generation */
+	switch_sleep(200000);
+
+	if (*text == '#') {
+		char *tmp = (char *) text + 1;
+		char *vp = tmp, voice[128] = "";
+		if ((tmp = strchr(tmp, '#'))) {
+			text = tmp + 1;
+			switch_copy_string(voice, vp, (tmp - vp) + 1);
+			switch_core_speech_text_param_tts(fnode->sh, "voice", voice);
+		}
+	} else {
+		switch_core_speech_text_param_tts(fnode->sh, "voice", conference->tts_voice);
+	}
+
+	switch_core_speech_feed_tts(fnode->sh, text, &flags);
+	unlock_member(member);
+
+	status = SWITCH_STATUS_SUCCESS;
+
+	return status;
+}
+
+/* Say some thing with TTS in the conference room */
+static switch_status_t conference_say(conference_obj_t *conference, const char *text, uint32_t leadin)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	conference_file_node_t *fnode, *nptr;
+	switch_memory_pool_t *pool;
+	switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
+	uint32_t count;
+
+	switch_assert(conference != NULL);
+
+	if (zstr(text)) {
+		return SWITCH_STATUS_GENERR;
+	}
+
+	switch_mutex_lock(conference->mutex);
+	switch_mutex_lock(conference->member_mutex);
+	count = conference->count;
+	if (!(conference->tts_engine && conference->tts_voice)) {
+		count = 0;
+	}
+	switch_mutex_unlock(conference->member_mutex);
+	switch_mutex_unlock(conference->mutex);
+
+	if (!count) {
+		return SWITCH_STATUS_FALSE;
+	}
+
+	/* Setup a memory pool to use. */
+	if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	/* Create a node object */
+	if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n");
+		switch_core_destroy_memory_pool(&pool);
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	fnode->type = NODE_TYPE_SPEECH;
+	fnode->leadin = leadin;
+
+	if (!conference->sh) {
+		memset(&conference->lsh, 0, sizeof(conference->lsh));
+		if (switch_core_speech_open(&conference->lsh, conference->tts_engine, conference->tts_voice,
+									conference->rate, conference->interval, &flags, NULL) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine);
+			return SWITCH_STATUS_FALSE;
+		}
+		conference->sh = &conference->lsh;
+	}
+
+	fnode->pool = pool;
+
+	/* Queue the node */
+	switch_mutex_lock(conference->mutex);
+	for (nptr = conference->fnode; nptr && nptr->next; nptr = nptr->next);
+
+	if (nptr) {
+		nptr->next = fnode;
+	} else {
+		conference->fnode = fnode;
+	}
+
+	fnode->sh = conference->sh;
+	if (*text == '#') {
+		char *tmp = (char *) text + 1;
+		char *vp = tmp, voice[128] = "";
+		if ((tmp = strchr(tmp, '#'))) {
+			text = tmp + 1;
+			switch_copy_string(voice, vp, (tmp - vp) + 1);
+			switch_core_speech_text_param_tts(fnode->sh, "voice", voice);
+		}
+	} else {
+		switch_core_speech_text_param_tts(fnode->sh, "voice", conference->tts_voice);
+	}
+
+	/* Begin Generation */
+	switch_sleep(200000);
+	switch_core_speech_feed_tts(fnode->sh, (char *) text, &flags);
+	switch_mutex_unlock(conference->mutex);
+	status = SWITCH_STATUS_SUCCESS;
+
+	return status;
+}
+
+/* execute a callback for every member of the conference */
+static void conference_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, conf_api_member_cmd_t pfncallback, void *data)
+{
+	conference_member_t *member = NULL;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+	switch_assert(pfncallback != NULL);
+
+	switch_mutex_lock(conference->member_mutex);
+	for (member = conference->members; member; member = member->next) {
+		if (member->session && !switch_test_flag(member, MFLAG_NOCHANNEL)) {
+			pfncallback(member, stream, data);
+		}
+	}
+	switch_mutex_unlock(conference->member_mutex);
+}
+
+static void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream)
+{
+	conference_member_t *member = NULL;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	switch_mutex_lock(conference->member_mutex);
+
+	for (member = conference->members; member; member = member->next) {
+		switch_channel_t *channel;
+		switch_caller_profile_t *profile;
+
+		if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
+			continue;
+		}
+		channel = switch_core_session_get_channel(member->session);
+		profile = switch_channel_get_caller_profile(channel);
+
+		stream->write_function(stream, "%u) %s (%s)\n", member->id, profile->caller_id_name, profile->caller_id_number);
+	}
+
+	switch_mutex_unlock(conference->member_mutex);
+}
+
+static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim)
+{
+	conference_member_t *member = NULL;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+	switch_assert(delim != NULL);
+
+	switch_mutex_lock(conference->member_mutex);
+
+	for (member = conference->members; member; member = member->next) {
+		switch_channel_t *channel;
+		switch_caller_profile_t *profile;
+		char *uuid;
+		char *name;
+		uint32_t count = 0;
+
+		if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
+			continue;
+		}
+
+		uuid = switch_core_session_get_uuid(member->session);
+		channel = switch_core_session_get_channel(member->session);
+		profile = switch_channel_get_caller_profile(channel);
+		name = switch_channel_get_name(channel);
+
+		stream->write_function(stream, "%u%s%s%s%s%s%s%s%s%s",
+							   member->id, delim, name, delim, uuid, delim, profile->caller_id_name, delim, profile->caller_id_number, delim);
+
+		if (switch_test_flag(member, MFLAG_CAN_HEAR)) {
+			stream->write_function(stream, "hear");
+			count++;
+		}
+
+		if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+			stream->write_function(stream, "%s%s", count ? "|" : "", "speak");
+			count++;
+		}
+
+		if (switch_test_flag(member, MFLAG_TALKING)) {
+			stream->write_function(stream, "%s%s", count ? "|" : "", "talking");
+			count++;
+		}
+
+		if (switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO)) {
+			stream->write_function(stream, "%s%s", count ? "|" : "", "video");
+			count++;
+		}
+
+		if (member == member->conference->floor_holder) {
+			stream->write_function(stream, "%s%s", count ? "|" : "", "floor");
+			count++;
+		}
+
+		stream->write_function(stream, "%s%d%s%d%s%d\n", delim, member->volume_in_level, delim, member->volume_out_level, delim, member->energy_level);
+	}
+
+	switch_mutex_unlock(conference->member_mutex);
+}
+
+static switch_status_t conf_api_sub_mute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	switch_clear_flag_locked(member, MFLAG_CAN_SPEAK);
+	if (!zstr(member->conference->muted_sound)) {
+		conference_member_play_file(member, member->conference->muted_sound, 0);
+	} else {
+		char msg[512];
+
+		switch_snprintf(msg, sizeof(msg), "Muted");
+		conference_member_say(member, msg, 0);
+	}
+	if (stream != NULL) {
+		stream->write_function(stream, "OK mute %u\n", member->id);
+	}
+	if (test_eflag(member->conference, EFLAG_MUTE_MEMBER) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "mute-member");
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_unmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	switch_set_flag_locked(member, MFLAG_CAN_SPEAK);
+	if (stream != NULL) {
+		stream->write_function(stream, "OK unmute %u\n", member->id);
+	}
+	if (!zstr(member->conference->unmuted_sound)) {
+		conference_member_play_file(member, member->conference->unmuted_sound, 0);
+	} else {
+		char msg[512];
+
+		switch_snprintf(msg, sizeof(msg), "Un-Muted");
+		conference_member_say(member, msg, 0);
+	}
+	if (test_eflag(member->conference, EFLAG_UNMUTE_MEMBER) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unmute-member");
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_deaf(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	switch_clear_flag_locked(member, MFLAG_CAN_HEAR);
+	if (stream != NULL) {
+		stream->write_function(stream, "OK deaf %u\n", member->id);
+	}
+	if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "deaf-member");
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_undeaf(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	switch_set_flag_locked(member, MFLAG_CAN_HEAR);
+	if (stream != NULL) {
+		stream->write_function(stream, "OK undeaf %u\n", member->id);
+	}
+	if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "undeaf-member");
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_kick(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	lock_member(member);
+	switch_clear_flag(member, MFLAG_RUNNING);
+	switch_set_flag_locked(member, MFLAG_KICKED);
+
+	switch_core_session_kill_channel(member->session, SWITCH_SIG_BREAK);
+	unlock_member(member);
+	if (stream != NULL) {
+		stream->write_function(stream, "OK kicked %u\n", member->id);
+	}
+	if (member->conference && test_eflag(member->conference, EFLAG_KICK_MEMBER)) {
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			conference_add_event_member_data(member, event);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "kick-member");
+			switch_event_fire(&event);
+		}
+	}
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+static switch_status_t conf_api_sub_dtmf(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+	char *dtmf = (char *) data;
+
+	if (member == NULL) {
+		stream->write_function(stream, "Invalid member!\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	if (zstr(dtmf)) {
+		stream->write_function(stream, "Invalid input!\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	lock_member(member);
+	switch_core_session_kill_channel(member->session, SWITCH_SIG_BREAK);
+	switch_core_session_send_dtmf_string(member->session, (char *) data);
+	unlock_member(member);
+
+	if (stream != NULL) {
+		stream->write_function(stream, "OK sent %s to %u\n", (char *) data, member->id);
+	}
+
+	if (test_eflag(member->conference, EFLAG_DTMF_MEMBER) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "dtmf-member");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Digits", dtmf);
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	if (data) {
+		lock_member(member);
+		member->energy_level = atoi((char *) data);
+		unlock_member(member);
+	}
+	if (stream != NULL) {
+		stream->write_function(stream, "Energy %u = %d\n", member->id, member->energy_level);
+	}
+	if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL_MEMBER) &&
+		data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level-member");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Energy-Level", "%d", member->energy_level);
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_volume_in(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	if (data) {
+		lock_member(member);
+		member->volume_in_level = atoi((char *) data);
+		switch_normalize_volume(member->volume_in_level);
+		unlock_member(member);
+	}
+	if (stream != NULL) {
+		stream->write_function(stream, "Volume IN %u = %d\n", member->id, member->volume_in_level);
+	}
+	if (test_eflag(member->conference, EFLAG_VOLUME_IN_MEMBER) &&
+		data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-in-member");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%u", member->volume_in_level);
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_volume_out(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+	switch_event_t *event;
+
+	if (member == NULL)
+		return SWITCH_STATUS_GENERR;
+
+	if (data) {
+		lock_member(member);
+		member->volume_out_level = atoi((char *) data);
+		switch_normalize_volume(member->volume_out_level);
+		unlock_member(member);
+	}
+	if (stream != NULL) {
+		stream->write_function(stream, "Volume OUT %u = %d\n", member->id, member->volume_out_level);
+	}
+	if (test_eflag(member->conference, EFLAG_VOLUME_OUT_MEMBER) && data &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-out-member");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%u", member->volume_out_level);
+		switch_event_fire(&event);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	int ret_status = SWITCH_STATUS_GENERR;
+	int count = 0;
+	switch_hash_index_t *hi;
+	void *val;
+	char *d = ";";
+	int pretty = 0;
+	int summary = 0;
+	int argofs = (argc >= 2 && strcasecmp(argv[1], "list") == 0);	/* detect being called from chat vs. api */
+
+	if (argv[1 + argofs]) {
+		if (argv[2 + argofs] && !strcasecmp(argv[1 + argofs], "delim")) {
+			d = argv[2 + argofs];
+
+			if (*d == '"') {
+				if (++d) {
+					char *p;
+					if ((p = strchr(d, '"'))) {
+						*p = '\0';
+					}
+				} else {
+					d = ";";
+				}
+			}
+		} else if (strcasecmp(argv[1 + argofs], "pretty") == 0) {
+			pretty = 1;
+		} else if (strcasecmp(argv[1 + argofs], "summary") == 0) {
+			summary = 1;
+		}
+	}
+
+	if (conference == NULL) {
+		switch_mutex_lock(globals.hash_mutex);
+		for (hi = switch_hash_first(NULL, globals.conference_hash); hi; hi = switch_hash_next(hi)) {
+			switch_hash_this(hi, NULL, NULL, &val);
+			conference = (conference_obj_t *) val;
+
+			stream->write_function(stream, "Conference %s (%u member%s rate: %u%s)\n",
+								   conference->name,
+								   conference->count,
+								   conference->count == 1 ? "" : "s", conference->rate, switch_test_flag(conference, CFLAG_LOCKED) ? " locked" : "");
+			count++;
+			if (!summary) {
+				if (pretty) {
+					conference_list_pretty(conference, stream);
+				} else {
+					conference_list(conference, stream, d);
+				}
+			}
+		}
+		switch_mutex_unlock(globals.hash_mutex);
+	} else {
+		count++;
+		if (pretty) {
+			conference_list_pretty(conference, stream);
+		} else {
+			conference_list(conference, stream, d);
+		}
+	}
+
+	if (!count) {
+		stream->write_function(stream, "No active conferences.\n");
+	}
+
+	ret_status = SWITCH_STATUS_SUCCESS;
+
+	return ret_status;
+}
+
+
+static void add_x_tag(switch_xml_t x_member, const char *name, const char *value, int off)
+{
+	switch_size_t dlen = strlen(value) * 3;
+	char *data;
+	switch_xml_t x_tag;
+
+	x_tag = switch_xml_add_child_d(x_member, name, off);
+	switch_assert(x_tag);
+
+	switch_zmalloc(data, dlen);
+
+	switch_url_encode(value, data, dlen);
+	switch_xml_set_txt_d(x_tag, data);
+	free(data);
+}
+
+static void conference_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off)
+{
+	conference_member_t *member = NULL;
+	switch_xml_t x_member = NULL, x_members = NULL, x_flags;
+	int moff = 0;
+	char i[30] = "";
+	char *ival = i;
+	switch_assert(conference != NULL);
+	switch_assert(x_conference != NULL);
+
+	switch_xml_set_attr_d(x_conference, "name", conference->name);
+	switch_snprintf(i, sizeof(i), "%d", conference->count);
+	switch_xml_set_attr_d(x_conference, "member-count", ival);
+	switch_snprintf(i, sizeof(i), "%u", conference->rate);
+	switch_xml_set_attr_d(x_conference, "rate", ival);
+
+	if (switch_test_flag(conference, CFLAG_LOCKED)) {
+		switch_xml_set_attr_d(x_conference, "locked", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_DESTRUCT)) {
+		switch_xml_set_attr_d(x_conference, "destruct", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_WAIT_MOD)) {
+		switch_xml_set_attr_d(x_conference, "wait_mod", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_RUNNING)) {
+		switch_xml_set_attr_d(x_conference, "running", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_ANSWERED)) {
+		switch_xml_set_attr_d(x_conference, "answered", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_ENFORCE_MIN)) {
+		switch_xml_set_attr_d(x_conference, "enforce_min", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_BRIDGE_TO)) {
+		switch_xml_set_attr_d(x_conference, "bridge_to", "true");
+	}
+
+	if (switch_test_flag(conference, CFLAG_DYNAMIC)) {
+		switch_xml_set_attr_d(x_conference, "dynamic", "true");
+	}
+
+	x_members = switch_xml_add_child_d(x_conference, "members", 0);
+	switch_assert(x_members);
+
+	switch_mutex_lock(conference->member_mutex);
+
+	for (member = conference->members; member; member = member->next) {
+		switch_channel_t *channel;
+		switch_caller_profile_t *profile;
+		char *uuid;
+		char *name;
+		uint32_t count = 0;
+		switch_xml_t x_tag;
+		int toff = 0;
+
+		if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
+			continue;
+		}
+
+		uuid = switch_core_session_get_uuid(member->session);
+		channel = switch_core_session_get_channel(member->session);
+		profile = switch_channel_get_caller_profile(channel);
+		name = switch_channel_get_name(channel);
+
+
+		x_member = switch_xml_add_child_d(x_members, "member", moff++);
+		switch_assert(x_member);
+
+		switch_snprintf(i, sizeof(i), "%d", member->id);
+
+		add_x_tag(x_member, "id", i, toff++);
+		add_x_tag(x_member, "uuid", uuid, toff++);
+		add_x_tag(x_member, "caller_id_name", profile->caller_id_name, toff++);
+		add_x_tag(x_member, "caller_id_number", profile->caller_id_number, toff++);
+
+
+		x_flags = switch_xml_add_child_d(x_member, "flags", count++);
+		switch_assert(x_flags);
+
+		x_tag = switch_xml_add_child_d(x_flags, "can_hear", count++);
+		switch_xml_set_txt_d(x_tag, switch_test_flag(member, MFLAG_CAN_HEAR) ? "true" : "false");
+
+		x_tag = switch_xml_add_child_d(x_flags, "can_speak", count++);
+		switch_xml_set_txt_d(x_tag, switch_test_flag(member, MFLAG_CAN_SPEAK) ? "true" : "false");
+
+		x_tag = switch_xml_add_child_d(x_flags, "talking", count++);
+		switch_xml_set_txt_d(x_tag, switch_test_flag(member, MFLAG_TALKING) ? "true" : "false");
+
+		x_tag = switch_xml_add_child_d(x_flags, "has_video", count++);
+		switch_xml_set_txt_d(x_tag, switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO) ? "true" : "false");
+
+		x_tag = switch_xml_add_child_d(x_flags, "has_floor", count++);
+		switch_xml_set_txt_d(x_tag, (member == member->conference->floor_holder) ? "true" : "false");
+
+		x_tag = switch_xml_add_child_d(x_flags, "is_moderator", count++);
+		switch_xml_set_txt_d(x_tag, switch_test_flag(member, MFLAG_MOD) ? "true" : "false");
+
+		x_tag = switch_xml_add_child_d(x_flags, "end_conference", count++);
+		switch_xml_set_txt_d(x_tag, switch_test_flag(member, MFLAG_ENDCONF) ? "true" : "false");
+
+	}
+
+	switch_mutex_unlock(conference->member_mutex);
+}
+static switch_status_t conf_api_sub_xml_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	int count = 0;
+	switch_hash_index_t *hi;
+	void *val;
+	switch_xml_t x_conference, x_conferences;
+	int off = 0;
+	char *ebuf;
+
+	x_conferences = switch_xml_new("conferences");
+	switch_assert(x_conferences);
+
+	if (conference == NULL) {
+		switch_mutex_lock(globals.hash_mutex);
+		for (hi = switch_hash_first(NULL, globals.conference_hash); hi; hi = switch_hash_next(hi)) {
+			switch_hash_this(hi, NULL, NULL, &val);
+			conference = (conference_obj_t *) val;
+
+			x_conference = switch_xml_add_child_d(x_conferences, "conference", off++);
+			switch_assert(conference);
+
+			count++;
+			conference_xlist(conference, x_conference, off);
+
+		}
+		switch_mutex_unlock(globals.hash_mutex);
+	} else {
+		x_conference = switch_xml_add_child_d(x_conferences, "conference", off++);
+		switch_assert(conference);
+		count++;
+		conference_xlist(conference, x_conference, off);
+	}
+
+
+	ebuf = switch_xml_toxml(x_conferences, SWITCH_TRUE);
+
+	stream->write_function(stream, "%s", ebuf);
+
+	switch_xml_free(x_conferences);
+	free(ebuf);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	int ret_status = SWITCH_STATUS_GENERR;
+	switch_event_t *event;
+	uint8_t async = 0;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if ((argc == 4 && !strcasecmp(argv[3], "async")) || (argc == 5 && !strcasecmp(argv[4], "async"))) {
+		argc--;
+		async++;
+	}
+
+	if (argc == 3) {
+		if (conference_play_file(conference, argv[2], 0, NULL, async) == SWITCH_STATUS_SUCCESS) {
+			stream->write_function(stream, "(play) Playing file %s\n", argv[2]);
+			if (test_eflag(conference, EFLAG_PLAY_FILE) &&
+				switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+				conference_add_event_data(conference, event);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "play-file");
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File", argv[2]);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Async", async ? "true" : "false");
+				switch_event_fire(&event);
+			}
+		} else {
+			stream->write_function(stream, "(play) File: %s not found.\n", argv[2] ? argv[2] : "(unspecified)");
+		}
+		ret_status = SWITCH_STATUS_SUCCESS;
+	} else if (argc == 4) {
+		uint32_t id = atoi(argv[3]);
+		conference_member_t *member;
+
+		if ((member = conference_member_get(conference, id))) {
+			if (conference_member_play_file(member, argv[2], 0) == SWITCH_STATUS_SUCCESS) {
+				stream->write_function(stream, "(play) Playing file %s to member %u\n", argv[2], id);
+				if (test_eflag(conference, EFLAG_PLAY_FILE_MEMBER) &&
+					switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+					conference_add_event_member_data(member, event);
+					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "play-file-member");
+					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File", argv[2]);
+					switch_event_fire(&event);
+				}
+			} else {
+				stream->write_function(stream, "(play) File: %s not found.\n", argv[2] ? argv[2] : "(unspecified)");
+			}
+			ret_status = SWITCH_STATUS_SUCCESS;
+		} else {
+			stream->write_function(stream, "Member: %u not found.\n", id);
+		}
+	}
+
+	return ret_status;
+}
+
+static switch_status_t conf_api_sub_say(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text)
+{
+	switch_event_t *event;
+
+	if (zstr(text)) {
+		stream->write_function(stream, "(say) Error! No text.\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	if (conference_say(conference, text, 0) != SWITCH_STATUS_SUCCESS) {
+		stream->write_function(stream, "(say) Error!\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	stream->write_function(stream, "(say) OK\n");
+	if (test_eflag(conference, EFLAG_SPEAK_TEXT) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_data(conference, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "speak-text");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Text", text);
+		switch_event_fire(&event);
+	}
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_saymember(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text)
+{
+	int ret_status = SWITCH_STATUS_GENERR;
+	char *expanded = NULL;
+	char *start_text = NULL;
+	char *workspace = NULL;
+	uint32_t id = 0;
+	conference_member_t *member;
+	switch_event_t *event;
+
+	if (zstr(text)) {
+		stream->write_function(stream, "(saymember) No Text!\n");
+		goto done;
+	}
+
+	if (!(workspace = strdup(text))) {
+		stream->write_function(stream, "(saymember) Memory Error!\n");
+		goto done;
+	}
+
+	if ((start_text = strchr(workspace, ' '))) {
+		*start_text++ = '\0';
+		text = start_text;
+	}
+
+	id = atoi(workspace);
+
+	if (!id || zstr(text)) {
+		stream->write_function(stream, "(saymember) No Text!\n");
+		goto done;
+	}
+
+	if (!(member = conference_member_get(conference, id))) {
+		stream->write_function(stream, "(saymember) Unknown Member %u!\n", id);
+		goto done;
+	}
+
+	if ((expanded = switch_channel_expand_variables(switch_core_session_get_channel(member->session), (char *) text)) != text) {
+		text = expanded;
+	} else {
+		expanded = NULL;
+	}
+
+	if (!text || conference_member_say(member, (char *) text, 0) != SWITCH_STATUS_SUCCESS) {
+		stream->write_function(stream, "(saymember) Error!\n");
+		goto done;
+	}
+
+	stream->write_function(stream, "(saymember) OK\n");
+	if (test_eflag(member->conference, EFLAG_SPEAK_TEXT_MEMBER) &&
+		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_member_data(member, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "speak-text-member");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Text", text);
+		switch_event_fire(&event);
+	}
+	ret_status = SWITCH_STATUS_SUCCESS;
+
+  done:
+	switch_safe_free(workspace);
+	switch_safe_free(expanded);
+	return ret_status;
+}
+
+static switch_status_t conf_api_sub_stop(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	uint8_t current = 0, all = 0, async = 0;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (argc > 2) {
+		current = strcasecmp(argv[2], "current") ? 0 : 1;
+		all = strcasecmp(argv[2], "all") ? 0 : 1;
+		async = strcasecmp(argv[2], "async") ? 0 : 1;
+	} else {
+		all = 1;
+	}
+
+	if (!(current || all || async))
+		return SWITCH_STATUS_GENERR;
+
+	if (argc == 4) {
+		uint32_t id = atoi(argv[3]);
+		conference_member_t *member;
+
+		if ((member = conference_member_get(conference, id))) {
+			uint32_t stopped = conference_member_stop_file(member, async ? FILE_STOP_ASYNC : current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
+			stream->write_function(stream, "Stopped %u files.\n", stopped);
+		} else {
+			stream->write_function(stream, "Member: %u not found.\n", id);
+		}
+	} else {
+		uint32_t stopped = conference_stop_file(conference, async ? FILE_STOP_ASYNC : current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
+		stream->write_function(stream, "Stopped %u files.\n", stopped);
+	}
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_relate(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	uint8_t nospeak = 0, nohear = 0, clear = 0;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (argc <= 4)
+		return SWITCH_STATUS_GENERR;
+
+	nospeak = strstr(argv[4], "nospeak") ? 1 : 0;
+	nohear = strstr(argv[4], "nohear") ? 1 : 0;
+
+	if (!strcasecmp(argv[4], "clear")) {
+		clear = 1;
+	}
+
+	if (!(clear || nospeak || nohear)) {
+		return SWITCH_STATUS_GENERR;
+	}
+
+	if (clear) {
+		conference_member_t *member = NULL;
+		uint32_t id = atoi(argv[2]);
+		uint32_t oid = atoi(argv[3]);
+
+		if ((member = conference_member_get(conference, id))) {
+			member_del_relationship(member, oid);
+			stream->write_function(stream, "relationship %u->%u cleared.\n", id, oid);
+		} else {
+			stream->write_function(stream, "relationship %u->%u not found.\n", id, oid);
+		}
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	if (nospeak || nohear) {
+		conference_member_t *member = NULL, *other_member = NULL;
+		uint32_t id = atoi(argv[2]);
+		uint32_t oid = atoi(argv[3]);
+
+		if ((member = conference_member_get(conference, id))
+			&& (other_member = conference_member_get(conference, oid))) {
+			conference_relationship_t *rel = NULL;
+			if ((rel = member_get_relationship(member, other_member))) {
+				rel->flags = 0;
+			} else {
+				rel = member_add_relationship(member, oid);
+			}
+
+			if (rel) {
+				switch_set_flag(rel, RFLAG_CAN_SPEAK | RFLAG_CAN_HEAR);
+				if (nospeak) {
+					switch_clear_flag(rel, RFLAG_CAN_SPEAK);
+				}
+				if (nohear) {
+					switch_clear_flag(rel, RFLAG_CAN_HEAR);
+				}
+				stream->write_function(stream, "ok %u->%u set\n", id, oid);
+			} else {
+				stream->write_function(stream, "error!\n");
+			}
+		} else {
+			stream->write_function(stream, "relationship %u->%u not found.\n", id, oid);
+		}
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_lock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_event_t *event;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (conference->is_locked_sound) {
+		conference_play_file(conference, conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+	}
+
+	switch_set_flag_locked(conference, CFLAG_LOCKED);
+	stream->write_function(stream, "OK %s locked\n", argv[0]);
+	if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_data(conference, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "lock");
+		switch_event_fire(&event);
+	}
+
+	return 0;
+}
+
+static switch_status_t conf_api_sub_unlock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_event_t *event;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (conference->is_unlocked_sound) {
+		conference_play_file(conference, conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+	}
+
+	switch_clear_flag_locked(conference, CFLAG_LOCKED);
+	stream->write_function(stream, "OK %s unlocked\n", argv[0]);
+	if (test_eflag(conference, EFLAG_UNLOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+		conference_add_event_data(conference, event);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
+		switch_event_fire(&event);
+	}
+
+	return 0;
+}
+
+static switch_status_t conf_api_sub_dial(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_call_cause_t cause;
+
+	switch_assert(stream != NULL);
+
+	if (argc <= 2) {
+		stream->write_function(stream, "Bad Args\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	if (conference) {
+		conference_outcall(conference, NULL, NULL, argv[2], 60, NULL, argv[4], argv[3], &cause);
+	} else {
+		conference_outcall(NULL, argv[0], NULL, argv[2], 60, NULL, argv[4], argv[3], &cause);
+	}
+	stream->write_function(stream, "Call Requested: result: [%s]\n", switch_channel_cause2str(cause));
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_bgdial(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_uuid_t uuid;
+	char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
+
+	switch_assert(stream != NULL);
+
+	if (argc <= 2) {
+		stream->write_function(stream, "Bad Args\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	switch_uuid_get(&uuid);
+	switch_uuid_format(uuid_str, &uuid);
+
+	if (conference) {
+		conference_outcall_bg(conference, NULL, NULL, argv[2], 60, NULL, argv[4], argv[3], uuid_str);
+	} else {
+		conference_outcall_bg(NULL, argv[0], NULL, argv[2], 60, NULL, argv[4], argv[3], uuid_str);
+	}
+
+	stream->write_function(stream, "OK Job-UUID: %s\n", uuid_str);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_transfer(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
+	char *conf_name = NULL, *profile_name;
+	switch_event_t *params = NULL;
+	conference_obj_t *new_conference = NULL;
+	int locked = 0;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (argc > 3 && !zstr(argv[2])) {
+		int x;
+
+		conf_name = strdup(argv[2]);
+
+		if ((profile_name = strchr(conf_name, '@'))) {
+			*profile_name++ = '\0';
+		} else {
+			profile_name = "default";
+		}
+
+		for (x = 3; x < argc; x++) {
+			conference_member_t *member = NULL;
+			uint32_t id = atoi(argv[x]);
+			switch_channel_t *channel;
+			switch_event_t *event;
+			switch_xml_t cxml = NULL, cfg = NULL, profiles = NULL;
+
+			if (!id || !(member = conference_member_get(conference, id))) {
+				stream->write_function(stream, "No Member %u in conference %s.\n", id, conference->name);
+				continue;
+			}
+
+			channel = switch_core_session_get_channel(member->session);
+
+			if (!new_conference) {
+				if (!locked) {
+					switch_mutex_lock(globals.setup_mutex);
+					locked = 1;
+				}
+
+				if ((new_conference = conference_find(conf_name))) {
+					if (locked) {
+						switch_mutex_unlock(globals.setup_mutex);
+						locked = 0;
+					}
+				}
+
+				if (!(new_conference = conference_find(conf_name))) {
+					/* build a new conference if it doesn't exist */
+					switch_memory_pool_t *pool = NULL;
+					conf_xml_cfg_t xml_cfg = { 0 };
+
+					/* Setup a memory pool to use. */
+					if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+						goto done;
+					}
+
+					switch_event_create(&params, SWITCH_EVENT_REQUEST_PARAMS);
+					switch_assert(params);
+					switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "conf_name", conf_name);
+					switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "profile_name", profile_name);
+					switch_channel_event_set_data(channel, params);
+
+					/* Open the config from the xml registry  */
+					if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, params))) {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", global_cf_name);
+						goto done;
+					}
+
+					if ((profiles = switch_xml_child(cfg, "profiles"))) {
+						xml_cfg.profile = switch_xml_find_child(profiles, "profile", "name", profile_name);
+					}
+
+					xml_cfg.controls = switch_xml_child(cfg, "caller-controls");
+
+					/* Release the config registry handle */
+					if (cxml) {
+						switch_xml_free(cxml);
+						cxml = NULL;
+					}
+
+					/* Create the conference object. */
+					new_conference = conference_new(conf_name, xml_cfg, pool);
+
+					if (!new_conference) {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
+						if (pool != NULL) {
+							switch_core_destroy_memory_pool(&pool);
+						}
+						goto done;
+					}
+
+					if (locked) {
+						switch_mutex_unlock(globals.setup_mutex);
+						locked = 0;
+					}
+
+					/* Set the minimum number of members (once you go above it you cannot go below it) */
+					new_conference->min = 1;
+
+					/* Indicate the conference is dynamic */
+					switch_set_flag_locked(new_conference, CFLAG_DYNAMIC);
+
+					switch_mutex_lock(new_conference->mutex);
+
+					/* Start the conference thread for this conference */
+					launch_conference_thread(new_conference);
+				} else {
+					switch_mutex_lock(new_conference->mutex);
+				}
+			}
+
+			/* move the member from the old conference to the new one */
+			lock_member(member);
+
+			if (conference != new_conference) {
+				conference_del_member(conference, member);
+				conference_add_member(new_conference, member);
+
+				if (conference->rate != new_conference->rate) {
+					if (setup_media(member, new_conference)) {
+						switch_clear_flag_locked(member, MFLAG_RUNNING);
+					} else {
+						switch_channel_set_app_flag(channel, CF_APP_TAGGED);
+						switch_set_flag_locked(member, MFLAG_RESTART);
+					}
+				}
+			}
+
+			unlock_member(member);
+
+			stream->write_function(stream, "OK Member '%d' sent to conference %s.\n", member->id, argv[2]);
+
+			/* tell them what happened */
+			if (test_eflag(conference, EFLAG_TRANSFER) &&
+				switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+				conference_add_event_member_data(member, event);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Old-Conference-Name", conference->name);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "New-Conference-Name", argv[3]);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
+				switch_event_fire(&event);
+			}
+		}
+
+		if (new_conference) {
+			switch_mutex_unlock(new_conference->mutex);
+		}
+
+	} else {
+		ret_status = SWITCH_STATUS_GENERR;
+	}
+
+  done:
+
+	if (locked) {
+		switch_mutex_unlock(globals.setup_mutex);
+		locked = 0;
+	}
+
+	if (params) {
+		switch_event_destroy(&params);
+	}
+	switch_safe_free(conf_name);
+	return ret_status;
+}
+
+static switch_status_t conf_api_sub_record(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (argc <= 2)
+		return SWITCH_STATUS_GENERR;
+
+	stream->write_function(stream, "Record file %s\n", argv[2]);
+	launch_conference_record_thread(conference, argv[2]);
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_norecord(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	int all;
+
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if (argc <= 2)
+		return SWITCH_STATUS_GENERR;
+
+	all = (strcasecmp(argv[2], "all") == 0);
+	stream->write_function(stream, "Stop recording file %s\n", argv[2]);
+	if (!conference_record_stop(conference, all ? NULL : argv[2]) && !all) {
+		stream->write_function(stream, "non-existant recording '%s'\n", argv[2]);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_api_sub_pin(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
+{
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	if ((argc == 3) && (!strcmp(argv[1], "pin"))) {
+		conference->pin = switch_core_strdup(conference->pool, argv[2]);
+		stream->write_function(stream, "Pin for conference %s set: %s\n", argv[0], conference->pin);
+		return SWITCH_STATUS_SUCCESS;
+	} else if (argc == 2 && (!strcmp(argv[1], "nopin"))) {
+		conference->pin = NULL;
+		stream->write_function(stream, "Pin for conference %s deleted\n", argv[0]);
+		return SWITCH_STATUS_SUCCESS;
+	} else {
+		stream->write_function(stream, "Invalid parameters:\n");
+		return SWITCH_STATUS_GENERR;
+	}
+}
+
+typedef enum {
+	CONF_API_COMMAND_LIST = 0,
+	CONF_API_COMMAND_ENERGY,
+	CONF_API_COMMAND_VOLUME_IN,
+	CONF_API_COMMAND_VOLUME_OUT,
+	CONF_API_COMMAND_PLAY,
+	CONF_API_COMMAND_SAY,
+	CONF_API_COMMAND_SAYMEMBER,
+	CONF_API_COMMAND_STOP,
+	CONF_API_COMMAND_DTMF,
+	CONF_API_COMMAND_KICK,
+	CONF_API_COMMAND_MUTE,
+	CONF_API_COMMAND_UNMUTE,
+	CONF_API_COMMAND_DEAF,
+	CONF_API_COMMAND_UNDEAF,
+	CONF_API_COMMAND_RELATE,
+	CONF_API_COMMAND_LOCK,
+	CONF_API_COMMAND_UNLOCK,
+	CONF_API_COMMAND_DIAL,
+	CONF_API_COMMAND_BGDIAL,
+	CONF_API_COMMAND_TRANSFER,
+	CONF_API_COMMAND_RECORD,
+	CONF_API_COMMAND_NORECORD
+} api_command_type_t;
+
+/* API Interface Function sub-commands */
+/* Entries in this list should be kept in sync with the enum above */
+static api_command_t conf_api_sub_commands[] = {
+	{"list", (void_fn_t) & conf_api_sub_list, CONF_API_SUB_ARGS_SPLIT, "<confname> list [delim <string>]"},
+	{"xml_list", (void_fn_t) & conf_api_sub_xml_list, CONF_API_SUB_ARGS_SPLIT, "<confname> xml_list"},
+	{"energy", (void_fn_t) & conf_api_sub_energy, CONF_API_SUB_MEMBER_TARGET,
+	 "<confname> energy <member_id|all|last> [<newval>]"},
+	{"volume_in", (void_fn_t) & conf_api_sub_volume_in, CONF_API_SUB_MEMBER_TARGET,
+	 "<confname> volume_in <member_id|all|last> [<newval>]"},
+	{"volume_out", (void_fn_t) & conf_api_sub_volume_out, CONF_API_SUB_MEMBER_TARGET,
+	 "<confname> volume_out <member_id|all|last> [<newval>]"},
+	{"play", (void_fn_t) & conf_api_sub_play, CONF_API_SUB_ARGS_SPLIT, "<confname> play <file_path> [async|<member_id>]"},
+	{"say", (void_fn_t) & conf_api_sub_say, CONF_API_SUB_ARGS_AS_ONE, "<confname> say <text>"},
+	{"saymember", (void_fn_t) & conf_api_sub_saymember, CONF_API_SUB_ARGS_AS_ONE,
+	 "<confname> saymember <member_id> <text>"},
+	{"stop", (void_fn_t) & conf_api_sub_stop, CONF_API_SUB_ARGS_SPLIT,
+	 "<confname> stop <[current|all|async|last]> [<member_id>]"},
+	{"dtmf", (void_fn_t) & conf_api_sub_dtmf, CONF_API_SUB_MEMBER_TARGET,
+	 "<confname> dtmf <[member_id|all|last]> <digits>"},
+	{"kick", (void_fn_t) & conf_api_sub_kick, CONF_API_SUB_MEMBER_TARGET, "<confname> kick <[member_id|all|last]>"},
+	{"mute", (void_fn_t) & conf_api_sub_mute, CONF_API_SUB_MEMBER_TARGET, "<confname> mute <[member_id|all]|last>"},
+	{"unmute", (void_fn_t) & conf_api_sub_unmute, CONF_API_SUB_MEMBER_TARGET,
+	 "<confname> unmute <[member_id|all]|last>"},
+	{"deaf", (void_fn_t) & conf_api_sub_deaf, CONF_API_SUB_MEMBER_TARGET, "<confname> deaf <[member_id|all]|last>"},
+	{"undeaf", (void_fn_t) & conf_api_sub_undeaf, CONF_API_SUB_MEMBER_TARGET,
+	 "<confname> undeaf <[member_id|all]|last>"},
+	{"relate", (void_fn_t) & conf_api_sub_relate, CONF_API_SUB_ARGS_SPLIT,
+	 "<confname> relate <member_id> <other_member_id> [nospeak|nohear|clear]"},
+	{"lock", (void_fn_t) & conf_api_sub_lock, CONF_API_SUB_ARGS_SPLIT, "<confname> lock"},
+	{"unlock", (void_fn_t) & conf_api_sub_unlock, CONF_API_SUB_ARGS_SPLIT, "<confname> unlock"},
+	{"dial", (void_fn_t) & conf_api_sub_dial, CONF_API_SUB_ARGS_SPLIT,
+	 "<confname> dial <endpoint_module_name>/<destination> <callerid number> <callerid name>"},
+	{"bgdial", (void_fn_t) & conf_api_sub_bgdial, CONF_API_SUB_ARGS_SPLIT,
+	 "<confname> bgdial <endpoint_module_name>/<destination> <callerid number> <callerid name>"},
+	{"transfer", (void_fn_t) & conf_api_sub_transfer, CONF_API_SUB_ARGS_SPLIT,
+	 "<confname> transfer <conference_name> <member id> [...<member id>]"},
+	{"record", (void_fn_t) & conf_api_sub_record, CONF_API_SUB_ARGS_SPLIT, "<confname> record <filename>"},
+	{"norecord", (void_fn_t) & conf_api_sub_norecord, CONF_API_SUB_ARGS_SPLIT, "<confname> norecord <[filename|all]>"},
+	{"pin", (void_fn_t) & conf_api_sub_pin, CONF_API_SUB_ARGS_SPLIT, "<confname> pin <pin#>"},
+	{"nopin", (void_fn_t) & conf_api_sub_pin, CONF_API_SUB_ARGS_SPLIT, "<confname> nopin"},
+};
+
+#define CONFFUNCAPISIZE (sizeof(conf_api_sub_commands)/sizeof(conf_api_sub_commands[0]))
+
+switch_status_t conf_api_dispatch(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv, const char *cmdline, int argn)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	uint32_t i, found = 0;
+	switch_assert(conference != NULL);
+	switch_assert(stream != NULL);
+
+	/* loop through the command table to find a match */
+	for (i = 0; i < CONFFUNCAPISIZE && !found; i++) {
+		if (strcasecmp(argv[argn], conf_api_sub_commands[i].pname) == 0) {
+			found = 1;
+			switch (conf_api_sub_commands[i].fntype) {
+
+				/* commands that we've broken the command line into arguments for */
+			case CONF_API_SUB_ARGS_SPLIT:
+				{
+					conf_api_args_cmd_t pfn = (conf_api_args_cmd_t) conf_api_sub_commands[i].pfnapicmd;
+
+					if (pfn(conference, stream, argc, argv) != SWITCH_STATUS_SUCCESS) {
+						/* command returned error, so show syntax usage */
+						stream->write_function(stream, conf_api_sub_commands[i].psyntax);
+					}
+				}
+				break;
+
+				/* member specific command that can be itteratted */
+			case CONF_API_SUB_MEMBER_TARGET:
+				{
+					uint32_t id = 0;
+					uint8_t all = 0;
+					uint8_t last = 0;
+
+					if (argv[argn + 1]) {
+						if (!(id = atoi(argv[argn + 1]))) {
+							all = strcasecmp(argv[argn + 1], "all") ? 0 : 1;
+							last = strcasecmp(argv[argn + 1], "last") ? 0 : 1;
+						}
+					}
+
+					if (all) {
+						conference_member_itterator(conference, stream, (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd, argv[argn + 2]);
+					} else if (last) {
+						conference_member_t *member = NULL;
+						conference_member_t *last_member = NULL;
+
+						switch_mutex_lock(conference->member_mutex);
+
+						/* find last (oldest) member */
+						member = conference->members;
+						while (member != NULL) {
+							if (last_member == NULL || member->id > last_member->id) {
+								last_member = member;
+							}
+							member = member->next;
+						}
+
+						/* exec functio on last (oldest) member */
+						if (last_member != NULL && last_member->session && !switch_test_flag(last_member, MFLAG_NOCHANNEL)) {
+							conf_api_member_cmd_t pfn = (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd;
+							pfn(last_member, stream, argv[argn + 2]);
+						}
+
+						switch_mutex_unlock(conference->member_mutex);
+					} else if (id) {
+						conf_api_member_cmd_t pfn = (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd;
+						conference_member_t *member = conference_member_get(conference, id);
+
+						if (member != NULL) {
+							pfn(member, stream, argv[argn + 2]);
+						} else {
+							stream->write_function(stream, "Non-Existant ID %u\n", id);
+						}
+					} else {
+						stream->write_function(stream, conf_api_sub_commands[i].psyntax);
+					}
+				}
+				break;
+
+				/* commands that deals with all text after command */
+			case CONF_API_SUB_ARGS_AS_ONE:
+				{
+					conf_api_text_cmd_t pfn = (conf_api_text_cmd_t) conf_api_sub_commands[i].pfnapicmd;
+					char *start_text;
+					const char *modified_cmdline = cmdline;
+					const char *cmd = conf_api_sub_commands[i].pname;
+
+					if (!zstr(modified_cmdline) && (start_text = strstr(modified_cmdline, cmd))) {
+						modified_cmdline = start_text + strlen(cmd);
+						while (modified_cmdline && (*modified_cmdline == ' ' || *modified_cmdline == '\t')) {
+							modified_cmdline++;
+						}
+					}
+
+					/* call the command handler */
+					if (pfn(conference, stream, modified_cmdline) != SWITCH_STATUS_SUCCESS) {
+						/* command returned error, so show syntax usage */
+						stream->write_function(stream, conf_api_sub_commands[i].psyntax);
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	if (!found) {
+		stream->write_function(stream, "Confernece command '%s' not found.\n", argv[argn]);
+	} else {
+		status = SWITCH_STATUS_SUCCESS;
+	}
+
+	return status;
+}
+
+/* API Interface Function */
+SWITCH_STANDARD_API(conf_api_main)
+{
+	char *lbuf = NULL;
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+	char *http = NULL, *type = NULL;
+	int argc;
+	char *argv[25] = { 0 };
+
+	if (!cmd) {
+		cmd = "help";
+	}
+
+	if (stream->param_event) {
+		http = switch_event_get_header(stream->param_event, "http-host");
+		type = switch_event_get_header(stream->param_event, "content-type");
+	}
+
+	if (http) {
+		/* Output must be to a web browser */
+		if (type && !strcasecmp(type, "text/html")) {
+			stream->write_function(stream, "<pre>\n");
+		}
+	}
+
+	if (!(lbuf = strdup(cmd))) {
+		return status;
+	}
+
+	argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+
+	/* try to find a command to execute */
+	if (argc && argv[0]) {
+		conference_obj_t *conference = NULL;
+
+		if ((conference = conference_find(argv[0]))) {
+			if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Read Lock Fail\n");
+				goto done;
+			}
+			if (argc >= 2) {
+				conf_api_dispatch(conference, stream, argc, argv, cmd, 1);
+			} else {
+				stream->write_function(stream, "Conference command, not specified.\nTry 'help'\n");
+			}
+			switch_thread_rwlock_unlock(conference->rwlock);
+
+		} else if (argv[0]) {
+			/* special case the list command, because it doesn't require a conference argument */
+			if (strcasecmp(argv[0], "list") == 0) {
+				conf_api_sub_list(NULL, stream, argc, argv);
+			} else if (strcasecmp(argv[0], "xml_list") == 0) {
+				conf_api_sub_xml_list(NULL, stream, argc, argv);
+			} else if (strcasecmp(argv[0], "help") == 0 || strcasecmp(argv[0], "commands") == 0) {
+				stream->write_function(stream, "%s\n", api_syntax);
+			} else if (argv[1] && strcasecmp(argv[1], "dial") == 0) {
+				if (conf_api_sub_dial(NULL, stream, argc, argv) != SWITCH_STATUS_SUCCESS) {
+					/* command returned error, so show syntax usage */
+					stream->write_function(stream, conf_api_sub_commands[CONF_API_COMMAND_DIAL].psyntax);
+				}
+			} else if (argv[1] && strcasecmp(argv[1], "bgdial") == 0) {
+				if (conf_api_sub_bgdial(NULL, stream, argc, argv) != SWITCH_STATUS_SUCCESS) {
+					/* command returned error, so show syntax usage */
+					stream->write_function(stream, conf_api_sub_commands[CONF_API_COMMAND_BGDIAL].psyntax);
+				}
+			} else {
+				stream->write_function(stream, "Conference %s not found\n", argv[0]);
+			}
+		}
+
+	} else {
+		stream->write_function(stream, "No parameters specified.\nTry 'help conference'\n");
+	}
+
+  done:
+	switch_safe_free(lbuf);
+
+	return status;
+}
+
+/* generate an outbound call from the conference */
+static switch_status_t conference_outcall(conference_obj_t *conference,
+										  char *conference_name,
+										  switch_core_session_t *session,
+										  char *bridgeto, uint32_t timeout, char *flags, char *cid_name, char *cid_num, switch_call_cause_t *cause)
+{
+	switch_core_session_t *peer_session = NULL;
+	switch_channel_t *peer_channel;
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+	switch_channel_t *caller_channel = NULL;
+	char appdata[512];
+	int rdlock = 0;
+
+	*cause = SWITCH_CAUSE_NORMAL_CLEARING;
+
+	if (conference == NULL) {
+		char *dialstr = switch_mprintf("{ignore_early_media=true}%s", bridgeto);
+		status = switch_ivr_originate(NULL, &peer_session, cause, dialstr, 60, NULL, cid_name, cid_num, NULL, NULL, SOF_NONE, NULL);
+		switch_safe_free(dialstr);
+
+		if (status != SWITCH_STATUS_SUCCESS) {
+			return status;
+		}
+
+		peer_channel = switch_core_session_get_channel(peer_session);
+		rdlock = 1;
+		goto callup;
+	}
+
+	conference_name = conference->name;
+
+	if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Read Lock Fail\n");
+		return SWITCH_STATUS_FALSE;
+	}
+
+	if (session != NULL) {
+		caller_channel = switch_core_session_get_channel(session);
+	}
+
+	if (zstr(cid_name)) {
+		cid_name = conference->caller_id_name;
+	}
+
+	if (zstr(cid_num)) {
+		cid_num = conference->caller_id_number;
+	}
+
+	/* establish an outbound call leg */
+
+	if (switch_ivr_originate(session, &peer_session, cause, bridgeto, timeout, NULL, cid_name, cid_num, NULL, NULL, SOF_NONE, NULL) !=
+		SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot create outgoing channel, cause: %s\n",
+						  switch_channel_cause2str(*cause));
+		if (caller_channel) {
+			switch_channel_hangup(caller_channel, *cause);
+		}
+		goto done;
+	}
+
+	rdlock = 1;
+	peer_channel = switch_core_session_get_channel(peer_session);
+	switch_channel_set_state(peer_channel, CS_SOFT_EXECUTE);
+
+	/* make sure the conference still exists */
+	if (!switch_test_flag(conference, CFLAG_RUNNING)) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Conference is gone now, nevermind..\n");
+		if (caller_channel) {
+			switch_channel_hangup(caller_channel, SWITCH_CAUSE_NO_ROUTE_DESTINATION);
+		}
+		switch_channel_hangup(peer_channel, SWITCH_CAUSE_NO_ROUTE_DESTINATION);
+		goto done;
+	}
+
+	if (caller_channel && switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
+		switch_channel_answer(caller_channel);
+	}
+
+  callup:
+
+	/* if the outbound call leg is ready */
+	if (switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) {
+		switch_caller_extension_t *extension = NULL;
+
+		/* build an extension name object */
+		if ((extension = switch_caller_extension_new(peer_session, conference_name, conference_name)) == 0) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Memory Error!\n");
+			status = SWITCH_STATUS_MEMERR;
+			goto done;
+		}
+		/* add them to the conference */
+		if (flags && strcasecmp(flags, "none")) {
+			switch_snprintf(appdata, sizeof(appdata), "%s+flags{%s}", conference_name, flags);
+			switch_caller_extension_add_application(peer_session, extension, (char *) global_app_name, appdata);
+		} else {
+			switch_caller_extension_add_application(peer_session, extension, (char *) global_app_name, conference_name);
+		}
+
+		switch_channel_set_caller_extension(peer_channel, extension);
+		switch_channel_set_state(peer_channel, CS_EXECUTE);
+
+	} else {
+		switch_channel_hangup(peer_channel, SWITCH_CAUSE_NO_ANSWER);
+		status = SWITCH_STATUS_FALSE;
+		goto done;
+	}
+
+  done:
+	if (conference) {
+		switch_thread_rwlock_unlock(conference->rwlock);
+	}
+	if (rdlock && peer_session) {
+		switch_core_session_rwunlock(peer_session);
+	}
+
+	return status;
+}
+
+struct bg_call {
+	conference_obj_t *conference;
+	switch_core_session_t *session;
+	char *bridgeto;
+	uint32_t timeout;
+	char *flags;
+	char *cid_name;
+	char *cid_num;
+	char *conference_name;
+	char *uuid;
+	switch_memory_pool_t *pool;
+};
+
+static void *SWITCH_THREAD_FUNC conference_outcall_run(switch_thread_t *thread, void *obj)
+{
+	struct bg_call *call = (struct bg_call *) obj;
+
+	if (call) {
+		switch_call_cause_t cause;
+		switch_event_t *event;
+
+		conference_outcall(call->conference, call->conference_name,
+						   call->session, call->bridgeto, call->timeout, call->flags, call->cid_name, call->cid_num, &cause);
+
+		if (call->conference && test_eflag(call->conference, EFLAG_BGDIAL_RESULT) &&
+			switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			conference_add_event_data(call->conference, event);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "bgdial-result");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Result", switch_channel_cause2str(cause));
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Job-UUID", call->uuid);
+			switch_event_fire(&event);
+		}
+		switch_safe_free(call->bridgeto);
+		switch_safe_free(call->flags);
+		switch_safe_free(call->cid_name);
+		switch_safe_free(call->cid_num);
+		switch_safe_free(call->conference_name);
+		switch_safe_free(call->uuid);
+		if (call->pool) {
+			switch_core_destroy_memory_pool(&call->pool);
+		}
+		switch_safe_free(call);
+	}
+
+	return NULL;
+}
+
+static switch_status_t conference_outcall_bg(conference_obj_t *conference,
+											 char *conference_name,
+											 switch_core_session_t *session, char *bridgeto, uint32_t timeout, const char *flags, const char *cid_name,
+											 const char *cid_num, const char *call_uuid)
+{
+	struct bg_call *call = NULL;
+	switch_thread_t *thread;
+	switch_threadattr_t *thd_attr = NULL;
+	switch_memory_pool_t *pool = NULL;
+
+	if (!(call = malloc(sizeof(*call))))
+		return SWITCH_STATUS_MEMERR;
+
+	memset(call, 0, sizeof(*call));
+	call->conference = conference;
+	call->session = session;
+	call->timeout = timeout;
+
+	if (conference) {
+		pool = conference->pool;
+	} else {
+		switch_core_new_memory_pool(&pool);
+		call->pool = pool;
+	}
+
+	if (bridgeto) {
+		call->bridgeto = strdup(bridgeto);
+	}
+	if (flags) {
+		call->flags = strdup(flags);
+	}
+	if (cid_name) {
+		call->cid_name = strdup(cid_name);
+	}
+	if (cid_num) {
+		call->cid_num = strdup(cid_num);
+	}
+
+	if (conference_name) {
+		call->conference_name = strdup(conference_name);
+	}
+
+	if (call_uuid) {
+		call->uuid = strdup(call_uuid);
+	}
+
+	switch_threadattr_create(&thd_attr, pool);
+	switch_threadattr_detach_set(thd_attr, 1);
+	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+	switch_thread_create(&thread, thd_attr, conference_outcall_run, call, pool);
+	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Launching BG Thread for outcall\n");
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+/* Play a file */
+static switch_status_t conference_local_play_file(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
+												  uint32_t buflen)
+{
+	uint32_t x = 0;
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+	switch_channel_t *channel;
+	char *expanded = NULL;
+	switch_input_args_t args = { 0 }, *ap = NULL;
+
+	if (buf) {
+		args.buf = buf;
+		args.buflen = buflen;
+		ap = &args;
+	}
+
+	/* generate some space infront of the file to be played */
+	for (x = 0; x < leadin; x++) {
+		switch_frame_t *read_frame;
+		status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
+
+		if (!SWITCH_READ_ACCEPTABLE(status)) {
+			break;
+		}
+	}
+
+	/* if all is well, really play the file */
+	if (status == SWITCH_STATUS_SUCCESS) {
+		char *dpath = NULL;
+
+		channel = switch_core_session_get_channel(session);
+		if ((expanded = switch_channel_expand_variables(channel, path)) != path) {
+			path = expanded;
+		} else {
+			expanded = NULL;
+		}
+
+		if (!strncasecmp(path, "say:", 4)) {
+			if (!(conference->tts_engine && conference->tts_voice)) {
+				status = SWITCH_STATUS_FALSE;
+			} else {
+				status = switch_ivr_speak_text(session, conference->tts_engine, conference->tts_voice, path + 4, ap);
+			}
+			goto done;
+		}
+
+		if (conference->sound_prefix) {
+			if (!(dpath = switch_mprintf("%s%s%s", conference->sound_prefix, SWITCH_PATH_SEPARATOR, path))) {
+				status = SWITCH_STATUS_MEMERR;
+				goto done;
+			}
+			path = dpath;
+		}
+
+		status = switch_ivr_play_file(session, NULL, path, ap);
+		switch_safe_free(dpath);
+	}
+
+  done:
+	switch_safe_free(expanded);
+
+	return status;
+}
+
+static void set_mflags(const char *flags, member_flag_t *f)
+{
+	if (flags) {
+		char *dup = strdup(flags);
+		char *p;
+		char *argv[10] = { 0 };
+		int i, argc = 0;
+
+		for (p = dup; p && *p; p++) {
+			if (*p == ',') {
+				*p = '|';
+			}
+		}
+
+		argc = switch_separate_string(dup, '|', argv, (sizeof(argv) / sizeof(argv[0])));
+
+		for (i = 0; i < argc && argv[i]; i++) {
+			if (!strcasecmp(argv[i], "mute")) {
+				*f &= ~MFLAG_CAN_SPEAK;
+			} else if (!strcasecmp(argv[i], "deaf")) {
+				*f &= ~MFLAG_CAN_HEAR;
+			} else if (!strcasecmp(argv[i], "waste")) {
+				*f |= MFLAG_WASTE_BANDWIDTH;
+			} else if (!strcasecmp(argv[i], "mute-detect")) {
+				*f |= MFLAG_MUTE_DETECT;
+			} else if (!strcasecmp(argv[i], "dist-dtmf")) {
+				*f |= MFLAG_DIST_DTMF;
+			} else if (!strcasecmp(argv[i], "moderator")) {
+				*f |= MFLAG_MOD;
+			} else if (!strcasecmp(argv[i], "endconf")) {
+				*f |= MFLAG_ENDCONF;
+			} else if (!strcasecmp(argv[i], "mintwo")) {
+				*f |= MFLAG_MINTWO;
+			}
+		}
+
+		free(dup);
+	}
+}
+
+
+
+static void set_cflags(const char *flags, uint32_t *f)
+{
+	if (flags) {
+		char *dup = strdup(flags);
+		char *p;
+		char *argv[10] = { 0 };
+		int i, argc = 0;
+
+		for (p = dup; p && *p; p++) {
+			if (*p == ',') {
+				*p = '|';
+			}
+		}
+
+		argc = switch_separate_string(dup, '|', argv, (sizeof(argv) / sizeof(argv[0])));
+
+		for (i = 0; i < argc && argv[i]; i++) {
+			if (!strcasecmp(argv[i], "wait-mod")) {
+				*f |= CFLAG_WAIT_MOD;
+			} else if (!strcasecmp(argv[i], "video-floor-only")) {
+				*f |= CFLAG_VID_FLOOR;
+			} else if (!strcasecmp(argv[i], "waste-bandwidth")) {
+				*f |= CFLAG_WASTE_BANDWIDTH;
+			}
+		}
+
+		free(dup);
+	}
+}
+
+
+static void clear_eflags(char *events, uint32_t *f)
+{
+	char buf[512] = "";
+	char *next = NULL;
+	char *event = buf;
+
+	if (events) {
+		switch_copy_string(buf, events, sizeof(buf));
+
+		while (event) {
+			next = strchr(event, ',');
+			if (next) {
+				*next++ = '\0';
+			}
+
+			if (!strcmp(event, "add-member")) {
+				*f &= ~EFLAG_ADD_MEMBER;
+			} else if (!strcmp(event, "del-member")) {
+				*f &= ~EFLAG_DEL_MEMBER;
+			} else if (!strcmp(event, "energy-level")) {
+				*f &= ~EFLAG_ENERGY_LEVEL;
+			} else if (!strcmp(event, "volume-level")) {
+				*f &= ~EFLAG_VOLUME_LEVEL;
+			} else if (!strcmp(event, "gain-level")) {
+				*f &= ~EFLAG_GAIN_LEVEL;
+			} else if (!strcmp(event, "dtmf")) {
+				*f &= ~EFLAG_DTMF;
+			} else if (!strcmp(event, "stop-talking")) {
+				*f &= ~EFLAG_STOP_TALKING;
+			} else if (!strcmp(event, "start-talking")) {
+				*f &= ~EFLAG_START_TALKING;
+			} else if (!strcmp(event, "mute-detect")) {
+				*f &= ~EFLAG_MUTE_DETECT;
+			} else if (!strcmp(event, "mute-member")) {
+				*f &= ~EFLAG_MUTE_MEMBER;
+			} else if (!strcmp(event, "unmute-member")) {
+				*f &= ~EFLAG_UNMUTE_MEMBER;
+			} else if (!strcmp(event, "kick-member")) {
+				*f &= ~EFLAG_KICK_MEMBER;
+			} else if (!strcmp(event, "dtmf-member")) {
+				*f &= ~EFLAG_DTMF_MEMBER;
+			} else if (!strcmp(event, "energy-level-member")) {
+				*f &= ~EFLAG_ENERGY_LEVEL_MEMBER;
+			} else if (!strcmp(event, "volume-in-member")) {
+				*f &= ~EFLAG_VOLUME_IN_MEMBER;
+			} else if (!strcmp(event, "volume-out-member")) {
+				*f &= ~EFLAG_VOLUME_OUT_MEMBER;
+			} else if (!strcmp(event, "play-file")) {
+				*f &= ~EFLAG_PLAY_FILE;
+			} else if (!strcmp(event, "play-file-member")) {
+				*f &= ~EFLAG_PLAY_FILE_MEMBER;
+			} else if (!strcmp(event, "speak-text")) {
+				*f &= ~EFLAG_SPEAK_TEXT;
+			} else if (!strcmp(event, "speak-text-member")) {
+				*f &= ~EFLAG_SPEAK_TEXT_MEMBER;
+			} else if (!strcmp(event, "lock")) {
+				*f &= ~EFLAG_LOCK;
+			} else if (!strcmp(event, "unlock")) {
+				*f &= ~EFLAG_UNLOCK;
+			} else if (!strcmp(event, "transfer")) {
+				*f &= ~EFLAG_TRANSFER;
+			} else if (!strcmp(event, "bgdial-result")) {
+				*f &= ~EFLAG_BGDIAL_RESULT;
+			} else if (!strcmp(event, "floor-change")) {
+				*f &= ~EFLAG_FLOOR_CHANGE;
+			}
+
+			event = next;
+		}
+	}
+}
+
+SWITCH_STANDARD_APP(conference_auto_function)
+{
+	switch_channel_t *channel = switch_core_session_get_channel(session);
+	call_list_t *call_list, *np;
+
+	call_list = switch_channel_get_private(channel, "_conference_autocall_list_");
+
+	if (zstr(data)) {
+		call_list = NULL;
+	} else {
+		np = switch_core_session_alloc(session, sizeof(*np));
+		switch_assert(np != NULL);
+
+		np->string = switch_core_session_strdup(session, data);
+		if (call_list) {
+			np->next = call_list;
+			np->itteration = call_list->itteration + 1;
+		} else {
+			np->itteration = 1;
+		}
+		call_list = np;
+	}
+	switch_channel_set_private(channel, "_conference_autocall_list_", call_list);
+}
+
+
+static int setup_media(conference_member_t *member, conference_obj_t *conference)
+{
+	switch_codec_implementation_t read_impl = { 0 };
+	switch_core_session_get_read_impl(member->session, &read_impl);
+
+	switch_core_session_reset(member->session, SWITCH_TRUE, SWITCH_FALSE);
+
+	if (switch_core_codec_ready(&member->read_codec)) {
+		switch_core_codec_destroy(&member->read_codec);
+	}
+
+	if (member->read_resampler) {
+		switch_resample_destroy(&member->read_resampler);
+	}
+
+
+	switch_core_session_get_read_impl(member->session, &member->orig_read_impl);
+	member->native_rate = read_impl.samples_per_second;
+
+	/* Setup a Signed Linear codec for reading audio. */
+	if (switch_core_codec_init(&member->read_codec,
+							   "L16",
+							   NULL, read_impl.actual_samples_per_second, read_impl.microseconds_per_packet / 1000,
+							   1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, member->pool) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG,
+						  "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
+						  read_impl.actual_samples_per_second, read_impl.microseconds_per_packet / 1000);
+
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n",
+						  read_impl.actual_samples_per_second, read_impl.microseconds_per_packet / 1000);
+
+		goto done;
+	}
+
+	if (!member->frame_size) {
+		member->frame_size = SWITCH_RECOMMENDED_BUFFER_SIZE;
+		member->frame = switch_core_alloc(member->pool, member->frame_size);
+		member->mux_frame = switch_core_alloc(member->pool, member->frame_size);
+	}
+
+	if (read_impl.actual_samples_per_second != conference->rate) {
+		if (switch_resample_create(&member->read_resampler,
+								   read_impl.actual_samples_per_second,
+								   conference->rate, member->frame_size, SWITCH_RESAMPLE_QUALITY, 1) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Unable to create resampler!\n");
+			goto done;
+		}
+
+
+		member->resample_out = switch_core_alloc(member->pool, member->frame_size);
+		member->resample_out_len = member->frame_size;
+
+		/* Setup an audio buffer for the resampled audio */
+		if (switch_buffer_create_dynamic(&member->resample_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, CONF_DBUFFER_MAX)
+			!= SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
+			goto done;
+		}
+	}
+
+
+	/* Setup a Signed Linear codec for writing audio. */
+	if (switch_core_codec_init(&member->write_codec,
+							   "L16",
+							   NULL,
+							   conference->rate,
+							   read_impl.microseconds_per_packet / 1000,
+							   1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, member->pool) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG,
+						  "Raw Codec Activation Success L16@%uhz 1 channel %dms\n", conference->rate, read_impl.microseconds_per_packet / 1000);
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n",
+						  conference->rate, read_impl.microseconds_per_packet / 1000);
+		goto codec_done2;
+	}
+
+	/* Setup an audio buffer for the incoming audio */
+	if (switch_buffer_create_dynamic(&member->audio_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, CONF_DBUFFER_MAX) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
+		goto codec_done1;
+	}
+
+	/* Setup an audio buffer for the outgoing audio */
+	if (switch_buffer_create_dynamic(&member->mux_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, CONF_DBUFFER_MAX) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
+		goto codec_done1;
+	}
+
+	return 0;
+
+  codec_done1:
+	switch_core_codec_destroy(&member->read_codec);
+  codec_done2:
+	switch_core_codec_destroy(&member->write_codec);
+  done:
+
+	return -1;
+
+
+}
+
+
+/* Application interface function that is called from the dialplan to join the channel to a conference */
+SWITCH_STANDARD_APP(conference_function)
+{
+	switch_codec_t *read_codec = NULL;
+	uint32_t flags = 0;
+	conference_member_t member = { 0 };
+	conference_obj_t *conference = NULL;
+	switch_channel_t *channel = switch_core_session_get_channel(session);
+	char *mydata = NULL;
+	char *conf_name = NULL;
+	char *bridge_prefix = "bridge:";
+	char *flags_prefix = "+flags{";
+	char *bridgeto = NULL;
+	char *profile_name = NULL;
+	switch_xml_t cxml = NULL, cfg = NULL, profiles = NULL;
+	const char *flags_str;
+	member_flag_t mflags = 0;
+	switch_core_session_message_t msg = { 0 };
+	uint8_t rl = 0, isbr = 0;
+	char *dpin = NULL;
+	conf_xml_cfg_t xml_cfg = { 0 };
+	switch_event_t *params = NULL;
+	int locked = 0;
+
+	/* Save the original read codec. */
+	if (!(read_codec = switch_core_session_get_read_codec(session))) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Channel has no media!\n");
+		return;
+	}
+
+
+	if (zstr(data)) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Invalid arguments\n");
+		return;
+	}
+
+	mydata = switch_core_session_strdup(session, data);
+
+	if (!mydata) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Pool Failure\n");
+		return;
+	}
+
+	if ((flags_str = strstr(mydata, flags_prefix))) {
+		char *p;
+		*((char *) flags_str) = '\0';
+		flags_str += strlen(flags_prefix);
+		if ((p = strchr(flags_str, '}'))) {
+			*p = '\0';
+		}
+	} else {
+		flags_str = switch_channel_get_variable(channel, "conference_member_flags");
+	}
+
+	/* is this a bridging conference ? */
+	if (!strncasecmp(mydata, bridge_prefix, strlen(bridge_prefix))) {
+		isbr = 1;
+		mydata += strlen(bridge_prefix);
+		if ((bridgeto = strchr(mydata, ':'))) {
+			*bridgeto++ = '\0';
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Config Error!\n");
+			goto done;
+		}
+	}
+
+	conf_name = mydata;
+
+	/* eat all leading spaces on conference name, which can cause problems */
+	while (*conf_name == ' ') {
+		conf_name++;
+	}
+
+	/* is there a conference pin ? */
+	if ((dpin = strchr(conf_name, '+'))) {
+		*dpin++ = '\0';
+	}
+
+	/* is there profile specification ? */
+	if ((profile_name = strchr(conf_name, '@'))) {
+		*profile_name++ = '\0';
+	} else {
+		profile_name = "default";
+	}
+
+#if 0
+	if (0) {
+		member.dtmf_parser = conference->dtmf_parser;
+	} else {
+
+	}
+#endif
+
+	switch_event_create(&params, SWITCH_EVENT_COMMAND);
+	switch_assert(params);
+	switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "conf_name", conf_name);
+	switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "profile_name", profile_name);
+
+	/* Open the config from the xml registry */
+	if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, params))) {
+		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Open of %s failed\n", global_cf_name);
+		goto done;
+	}
+
+	if ((profiles = switch_xml_child(cfg, "profiles"))) {
+		xml_cfg.profile = switch_xml_find_child(profiles, "profile", "name", profile_name);
+	}
+
+	xml_cfg.controls = switch_xml_child(cfg, "caller-controls");
+
+	/* if this is a bridging call, and it's not a duplicate, build a */
+	/* conference object, and skip pin handling, and locked checking */
+
+	if (!locked) {
+		switch_mutex_lock(globals.setup_mutex);
+		locked = 1;
+	}
+
+	if (isbr) {
+		char *uuid = switch_core_session_get_uuid(session);
+
+		if (!strcmp(conf_name, "_uuid_")) {
+			conf_name = uuid;
+		}
+
+		if ((conference = conference_find(conf_name))) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Conference %s already exists!\n", conf_name);
+			goto done;
+		}
+
+		/* Create the conference object. */
+		conference = conference_new(conf_name, xml_cfg, NULL);
+
+		if (!conference) {
+			goto done;
+		}
+
+		if (locked) {
+			switch_mutex_unlock(globals.setup_mutex);
+			locked = 0;
+		}
+
+		switch_channel_set_variable(channel, "conference_name", conference->name);
+
+		/* Set the minimum number of members (once you go above it you cannot go below it) */
+		conference->min = 2;
+
+		/* Indicate the conference is dynamic */
+		switch_set_flag_locked(conference, CFLAG_DYNAMIC);
+
+		/* Indicate the conference has a bridgeto party */
+		switch_set_flag_locked(conference, CFLAG_BRIDGE_TO);
+
+		/* Start the conference thread for this conference */
+		launch_conference_thread(conference);
+
+	} else {
+		int enforce_security = !switch_channel_test_flag(channel, CF_OUTBOUND);
+		const char *pvar = switch_channel_get_variable(channel, "conference_enforce_security");
+
+		if (pvar) {
+			enforce_security = switch_true(pvar);
+		}
+
+		if ((conference = conference_find(conf_name))) {
+			if (locked) {
+				switch_mutex_unlock(globals.setup_mutex);
+				locked = 0;
+			}
+		}
+
+		/* if the conference exists, get the pointer to it */
+		if (!conference) {
+			const char *max_members_str;
+
+			/* couldn't find the conference, create one */
+			conference = conference_new(conf_name, xml_cfg, NULL);
+
+			if (!conference) {
+				goto done;
+			}
+
+			if (locked) {
+				switch_mutex_unlock(globals.setup_mutex);
+				locked = 0;
+			}
+
+			switch_channel_set_variable(channel, "conference_name", conference->name);
+
+			/* Set MOH from variable if not set */
+			if (zstr(conference->moh_sound)) {
+				conference->moh_sound = switch_core_strdup(conference->pool, switch_channel_get_variable(channel, "conference_moh_sound"));
+			}
+			/* Set perpetual-sound from variable if not set */
+			if (zstr(conference->perpetual_sound)) {
+				conference->perpetual_sound = switch_core_strdup(conference->pool, switch_channel_get_variable(channel, "conference_perpetual_sound"));
+			}
+
+			/* Set the minimum number of members (once you go above it you cannot go below it) */
+			conference->min = 1;
+
+			/* check for variable used to specify override for max_members */
+			if (!zstr(max_members_str = switch_channel_get_variable(channel, "conference_max_members"))) {
+				uint32_t max_members_val;
+				errno = 0;		/* sanity first */
+				max_members_val = strtol(max_members_str, NULL, 0);	/* base 0 lets 0x... for hex 0... for octal and base 10 otherwise through */
+				if (errno == ERANGE || errno == EINVAL || max_members_val < 0 || max_members_val == 1) {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+									  "conference_max_members variable %s is invalid, not setting a limit\n", max_members_str);
+				} else {
+					conference->max_members = max_members_val;
+				}
+			}
+
+			/* Indicate the conference is dynamic */
+			switch_set_flag_locked(conference, CFLAG_DYNAMIC);
+
+			/* Start the conference thread for this conference */
+			launch_conference_thread(conference);
+		} else {				/* setup user variable */
+			switch_channel_set_variable(channel, "conference_name", conference->name);
+		}
+
+		/* acquire a read lock on the thread so it can't leave without us */
+		if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Read Lock Fail\n");
+			goto done;
+		}
+		rl++;
+
+		if (!dpin && conference->pin) {
+			dpin = conference->pin;
+		}
+
+
+
+		/* if this is not an outbound call, deal with conference pins */
+		if (enforce_security && !zstr(dpin)) {
+			char pin_buf[80] = "";
+			int pin_retries = 3;	/* XXX - this should be configurable - i'm too lazy to do it right now... */
+			int pin_valid = 0;
+			switch_status_t status = SWITCH_STATUS_SUCCESS;
+			char *supplied_pin_value;
+
+			/* Answer the channel */
+			switch_channel_answer(channel);
+
+			/* look for PIN in channel variable first.  If not present or invalid revert to prompting user */
+			supplied_pin_value = switch_core_strdup(conference->pool, switch_channel_get_variable(channel, "supplied_pin"));
+			if (!zstr(supplied_pin_value)) {
+				char *supplied_pin_value_start;
+				int i = 0;
+				if ((supplied_pin_value_start = (char *) switch_stristr(cf_pin_url_param_name, supplied_pin_value))) {
+					/* pin supplied as a URL parameter, move pointer to start of actual pin value */
+					supplied_pin_value = supplied_pin_value_start + strlen(cf_pin_url_param_name);
+				}
+				while (*supplied_pin_value != 0 && *supplied_pin_value != ';') {
+					pin_buf[i++] = *supplied_pin_value++;
+				}
+				pin_valid = (strcmp(pin_buf, dpin) == 0);
+				memset(pin_buf, 0, sizeof(pin_buf));
+			}
+
+			if (!conference->pin_sound) {
+				conference->pin_sound = switch_core_strdup(conference->pool, "conference/conf-pin.wav");
+			}
+
+			if (!conference->bad_pin_sound) {
+				conference->bad_pin_sound = switch_core_strdup(conference->pool, "conference/conf-bad-pin.wav");
+			}
+
+			while (!pin_valid && pin_retries && status == SWITCH_STATUS_SUCCESS) {
+				switch_status_t pstatus = SWITCH_STATUS_FALSE;
+
+				/* be friendly */
+				if (conference->pin_sound) {
+					pstatus = conference_local_play_file(conference, session, conference->pin_sound, 20, pin_buf, sizeof(pin_buf));
+				} else if (conference->tts_engine && conference->tts_voice) {
+					pstatus =
+						switch_ivr_speak_text(session, conference->tts_engine, conference->tts_voice, "please enter the conference pin number", NULL);
+				} else {
+					pstatus = switch_ivr_speak_text(session, "flite", "slt", "please enter the conference pin number", NULL);
+				}
+
+				if (pstatus != SWITCH_STATUS_SUCCESS && pstatus != SWITCH_STATUS_BREAK) {
+					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Cannot ask the user for a pin, ending call");
+					switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+				}
+
+				/* wait for them if neccessary */
+				if (strlen(pin_buf) < strlen(dpin)) {
+					char *buf = pin_buf + strlen(pin_buf);
+					char term = '\0';
+
+					status = switch_ivr_collect_digits_count(session,
+															 buf,
+															 sizeof(pin_buf) - strlen(pin_buf), strlen(dpin) - strlen(pin_buf), "#", &term, 10000, 0, 0);
+					if (status == SWITCH_STATUS_TIMEOUT) {
+						status = SWITCH_STATUS_SUCCESS;
+					}
+				}
+
+				pin_valid = (status == SWITCH_STATUS_SUCCESS && strcmp(pin_buf, dpin) == 0);
+				if (!pin_valid) {
+					/* zero the collected pin */
+					memset(pin_buf, 0, sizeof(pin_buf));
+
+					/* more friendliness */
+					if (conference->bad_pin_sound) {
+						conference_local_play_file(conference, session, conference->bad_pin_sound, 20, pin_buf, sizeof(pin_buf));
+					}
+				}
+				pin_retries--;
+			}
+
+			if (!pin_valid) {
+				goto done;
+			}
+		}
+
+		if (conference->special_announce) {
+			conference_local_play_file(conference, session, conference->special_announce, CONF_DEFAULT_LEADIN, NULL, 0);
+		}
+
+		/* don't allow more callers if the conference is locked, unless we invited them */
+		if (switch_test_flag(conference, CFLAG_LOCKED) && enforce_security) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Conference %s is locked.\n", conf_name);
+			if (conference->locked_sound) {
+				/* Answer the channel */
+				switch_channel_answer(channel);
+				conference_local_play_file(conference, session, conference->locked_sound, 20, NULL, 0);
+			}
+			goto done;
+		}
+
+		/* dont allow more callers than the max_members allows for -- I explicitly didnt allow outbound calls
+		 * someone else can add that (see above) if they feel that outbound calls should be able to violate the
+		 * max_members limit
+		 */
+		if ((conference->max_members > 0) && (conference->count >= conference->max_members)) {
+			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Conference %s is full.\n", conf_name);
+			if (conference->maxmember_sound) {
+				/* Answer the channel */
+				switch_channel_answer(channel);
+				conference_local_play_file(conference, session, conference->maxmember_sound, 20, NULL, 0);
+			}
+			goto done;
+		}
+
+	}
+
+	/* Release the config registry handle */
+	if (cxml) {
+		switch_xml_free(cxml);
+		cxml = NULL;
+	}
+
+	/* if we're using "bridge:" make an outbound call and bridge it in */
+	if (!zstr(bridgeto) && strcasecmp(bridgeto, "none")) {
+		switch_call_cause_t cause;
+		if (conference_outcall(conference, NULL, session, bridgeto, 60, NULL, NULL, NULL, &cause) != SWITCH_STATUS_SUCCESS) {
+			goto done;
+		}
+	} else {
+		/* if we're not using "bridge:" set the conference answered flag */
+		/* and this isn't an outbound channel, answer the call */
+		if (!switch_channel_test_flag(channel, CF_OUTBOUND))
+			switch_set_flag(conference, CFLAG_ANSWERED);
+	}
+
+	member.session = session;
+	member.pool = switch_core_session_get_pool(session);
+
+	if (setup_media(&member, conference)) {
+		flags = 0;
+		goto done;
+	}
+
+	/* Prepare MUTEXS */
+	member.id = next_member_id();
+	switch_mutex_init(&member.flag_mutex, SWITCH_MUTEX_NESTED, member.pool);
+	switch_mutex_init(&member.write_mutex, SWITCH_MUTEX_NESTED, member.pool);
+	switch_mutex_init(&member.read_mutex, SWITCH_MUTEX_NESTED, member.pool);
+	switch_mutex_init(&member.audio_in_mutex, SWITCH_MUTEX_NESTED, member.pool);
+	switch_mutex_init(&member.audio_out_mutex, SWITCH_MUTEX_NESTED, member.pool);
+
+	/* Install our Signed Linear codec so we get the audio in that format */
+	switch_core_session_set_read_codec(member.session, &member.read_codec);
+
+
+	mflags = conference->mflags;
+	set_mflags(flags_str, &mflags);
+	switch_set_flag_locked((&member), MFLAG_RUNNING | mflags);
+
+	if (mflags & MFLAG_MINTWO) {
+		conference->min = 2;
+	}
+
+	/* Add the caller to the conference */
+	if (conference_add_member(conference, &member) != SWITCH_STATUS_SUCCESS) {
+		switch_core_codec_destroy(&member.read_codec);
+		goto done;
+	}
+
+	msg.from = __FILE__;
+
+	/* Tell the channel we are going to be in a bridge */
+	msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE;
+	switch_core_session_receive_message(session, &msg);
+
+	/* Run the confernece loop */
+	conference_loop_output(&member);
+	switch_channel_set_private(channel, "_conference_autocall_list_", NULL);
+
+	/* Tell the channel we are no longer going to be in a bridge */
+	msg.message_id = SWITCH_MESSAGE_INDICATE_UNBRIDGE;
+	switch_core_session_receive_message(session, &msg);
+
+	/* Remove the caller from the conference */
+	conference_del_member(member.conference, &member);
+
+	/* Put the original codec back */
+	switch_core_session_set_read_codec(member.session, NULL);
+
+	/* Clean Up. */
+
+  done:
+
+	if (locked) {
+		switch_mutex_unlock(globals.setup_mutex);
+		locked = 0;
+	}
+
+	if (member.read_resampler) {
+		switch_resample_destroy(&member.read_resampler);
+	}
+
+	switch_event_destroy(&params);
+	switch_buffer_destroy(&member.resample_buffer);
+	switch_buffer_destroy(&member.audio_buffer);
+	switch_buffer_destroy(&member.mux_buffer);
+	if (conference && member.dtmf_parser != conference->dtmf_parser) {
+		switch_ivr_digit_stream_parser_destroy(member.dtmf_parser);
+	}
+
+	if (conference) {
+		switch_mutex_lock(conference->mutex);
+		if (switch_test_flag(conference, CFLAG_DYNAMIC) && conference->count == 0) {
+			switch_set_flag_locked(conference, CFLAG_DESTRUCT);
+		}
+		switch_mutex_unlock(conference->mutex);
+	}
+
+	/* Release the config registry handle */
+	if (cxml) {
+		switch_xml_free(cxml);
+	}
+
+	if (conference && switch_test_flag(&member, MFLAG_KICKED) && conference->kicked_sound) {
+		char *toplay = NULL;
+		char *dfile = NULL;
+
+		if (!strncasecmp(conference->kicked_sound, "say:", 4)) {
+			if (conference->tts_engine && conference->tts_voice) {
+				switch_ivr_speak_text(session, conference->tts_engine, conference->tts_voice, conference->kicked_sound + 4, NULL);
+			}
+		} else {
+			if (conference->sound_prefix) {
+				dfile = switch_mprintf("%s%s%s", conference->sound_prefix, SWITCH_PATH_SEPARATOR, conference->kicked_sound);
+				switch_assert(dfile);
+				toplay = dfile;
+			} else {
+				toplay = conference->kicked_sound;
+			}
+
+			switch_ivr_play_file(session, NULL, toplay, NULL);
+			switch_safe_free(dfile);
+		}
+	}
+
+	switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
+
+	/* release the readlock */
+	if (rl) {
+		switch_thread_rwlock_unlock(conference->rwlock);
+	}
+}
+
+/* Create a thread for the conference and launch it */
+static void launch_conference_thread(conference_obj_t *conference)
+{
+	switch_thread_t *thread;
+	switch_threadattr_t *thd_attr = NULL;
+
+	switch_set_flag_locked(conference, CFLAG_RUNNING);
+	switch_threadattr_create(&thd_attr, conference->pool);
+	switch_threadattr_detach_set(thd_attr, 1);
+	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+	switch_mutex_lock(globals.hash_mutex);
+	switch_mutex_unlock(globals.hash_mutex);
+	switch_thread_create(&thread, thd_attr, conference_thread_run, conference, conference->pool);
+}
+
+
+/* Create a video thread for the conference and launch it */
+static void launch_conference_video_thread(conference_obj_t *conference)
+{
+	switch_thread_t *thread;
+	switch_threadattr_t *thd_attr = NULL;
+
+	switch_threadattr_create(&thd_attr, conference->pool);
+	switch_threadattr_detach_set(thd_attr, 1);
+	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+	switch_thread_create(&thread, thd_attr, conference_video_thread_run, conference, conference->pool);
+	conference->video_running = 1;
+}
+
+static void launch_conference_record_thread(conference_obj_t *conference, char *path)
+{
+	switch_thread_t *thread;
+	switch_threadattr_t *thd_attr = NULL;
+	switch_memory_pool_t *pool;
+	conference_record_t *rec;
+
+	/* Setup a memory pool to use. */
+	if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+	}
+
+	/* Create a node object */
+	if (!(rec = switch_core_alloc(pool, sizeof(*rec)))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n");
+		switch_core_destroy_memory_pool(&pool);
+		return;
+	}
+
+	rec->conference = conference;
+	rec->path = switch_core_strdup(pool, path);
+	rec->pool = pool;
+
+	switch_threadattr_create(&thd_attr, rec->pool);
+	switch_threadattr_detach_set(thd_attr, 1);
+	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+	switch_thread_create(&thread, thd_attr, conference_record_thread_run, rec, rec->pool);
+}
+
+static switch_status_t chat_send(const char *proto, const char *from, const char *to, const char *subject,
+								 const char *body, const char *type, const char *hint)
+{
+	char name[512] = "", *p, *lbuf = NULL;
+	conference_obj_t *conference = NULL;
+	switch_stream_handle_t stream = { 0 };
+
+	if ((p = strchr(to, '+'))) {
+		to = ++p;
+	}
+
+	if (!body) {
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	if ((p = strchr(to, '@'))) {
+		switch_copy_string(name, to, ++p - to);
+	} else {
+		switch_copy_string(name, to, sizeof(name));
+	}
+
+	if (!(conference = conference_find(name))) {
+		switch_core_chat_send(proto, CONF_CHAT_PROTO, to, hint && strchr(hint, '/') ? hint : from, "", "Conference not active.", NULL, NULL);
+		return SWITCH_STATUS_FALSE;
+	}
+
+	SWITCH_STANDARD_STREAM(stream);
+
+	if (body != NULL && (lbuf = strdup(body))) {
+		/* special case list */
+		if (switch_stristr("list", lbuf)) {
+			conference_list_pretty(conference, &stream);
+			/* provide help */
+		} else {
+			return SWITCH_STATUS_SUCCESS;
+		}
+	}
+
+	switch_safe_free(lbuf);
+
+	switch_core_chat_send(proto, CONF_CHAT_PROTO, to, hint && strchr(hint, '/') ? hint : from, "", stream.data, NULL, NULL);
+	switch_safe_free(stream.data);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t conf_default_controls(conference_obj_t *conference)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	uint32_t i;
+	caller_control_action_t *action;
+
+	switch_assert(conference != NULL);
+
+	for (i = 0, status = SWITCH_STATUS_SUCCESS; status == SWITCH_STATUS_SUCCESS && i < CCFNTBL_QTY; i++) {
+		if (!zstr(ccfntbl[i].digits)) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
+							  "Installing default caller control action '%s' bound to '%s'.\n", ccfntbl[i].key, ccfntbl[i].digits);
+			action = (caller_control_action_t *) switch_core_alloc(conference->pool, sizeof(caller_control_action_t));
+			if (action != NULL) {
+				action->fndesc = &ccfntbl[i];
+				action->data = NULL;
+				status = switch_ivr_digit_stream_parser_set_event(conference->dtmf_parser, ccfntbl[i].digits, action);
+			} else {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+								  "unable to alloc memory for caller control binding '%s' to '%s'\n", ccfntbl[i].key, ccfntbl[i].digits);
+				status = SWITCH_STATUS_MEMERR;
+			}
+		}
+	}
+
+	return status;
+}
+
+static switch_status_t conference_new_install_caller_controls_custom(conference_obj_t *conference, switch_xml_t xml_controls, switch_xml_t xml_menus)
+{
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	switch_xml_t xml_kvp;
+
+	switch_assert(conference != NULL);
+
+	if (!xml_controls) {
+		return status;
+	}
+
+	/* parse the controls tree for caller control digit strings */
+	for (xml_kvp = switch_xml_child(xml_controls, "control"); xml_kvp; xml_kvp = xml_kvp->next) {
+		char *key = (char *) switch_xml_attr(xml_kvp, "action");
+		char *val = (char *) switch_xml_attr(xml_kvp, "digits");
+		char *data = (char *) switch_xml_attr_soft(xml_kvp, "data");
+
+		if (!zstr(key) && !zstr(val)) {
+			uint32_t i;
+
+			/* scan through all of the valid actions, and if found, */
+			/* set the new caller control action digit string, then */
+			/* stop scanning the table, and go to the next xml kvp. */
+			for (i = 0, status = SWITCH_STATUS_NOOP; i < CCFNTBL_QTY && status == SWITCH_STATUS_NOOP; i++) {
+
+				if (strcasecmp(ccfntbl[i].key, key) == 0) {
+
+					caller_control_action_t *action;
+
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Installing caller control action '%s' bound to '%s'.\n", key, val);
+					action = (caller_control_action_t *) switch_core_alloc(conference->pool, sizeof(caller_control_action_t));
+					if (action != NULL) {
+						action->fndesc = &ccfntbl[i];
+						action->data = (void *) switch_core_strdup(conference->pool, data);
+						action->binded_dtmf = switch_core_strdup(conference->pool, val);
+						status = switch_ivr_digit_stream_parser_set_event(conference->dtmf_parser, val, action);
+					} else {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+										  "unable to alloc memory for caller control binding '%s' to '%s'\n", ccfntbl[i].key, ccfntbl[i].digits);
+						status = SWITCH_STATUS_MEMERR;
+					}
+				}
+			}
+			if (status == SWITCH_STATUS_NOOP) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid caller control action name '%s'.\n", key);
+			}
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid caller control config entry pair action = '%s' digits = '%s'\n", key, val);
+		}
+	}
+
+	return status;
+}
+
+static conference_obj_t *conference_find(char *name)
+{
+	conference_obj_t *conference;
+
+	switch_mutex_lock(globals.hash_mutex);
+	conference = switch_core_hash_find(globals.conference_hash, name);
+	switch_mutex_unlock(globals.hash_mutex);
+
+	return conference;
+}
+
+/* create a new conferene with a specific profile */
+static conference_obj_t *conference_new(char *name, conf_xml_cfg_t cfg, switch_memory_pool_t *pool)
+{
+	conference_obj_t *conference;
+	switch_xml_t xml_kvp;
+	char *timer_name = NULL;
+	char *domain = NULL;
+	char *tts_engine = NULL;
+	char *tts_voice = NULL;
+	char *enter_sound = NULL;
+	char *sound_prefix = NULL;
+	char *exit_sound = NULL;
+	char *alone_sound = NULL;
+	char *ack_sound = NULL;
+	char *nack_sound = NULL;
+	char *muted_sound = NULL;
+	char *mute_detect_sound = NULL;
+	char *unmuted_sound = NULL;
+	char *locked_sound = NULL;
+	char *is_locked_sound = NULL;
+	char *is_unlocked_sound = NULL;
+	char *kicked_sound = NULL;
+	char *pin = NULL;
+	char *pin_sound = NULL;
+	char *bad_pin_sound = NULL;
+	char *energy_level = NULL;
+	char *caller_id_name = NULL;
+	char *caller_id_number = NULL;
+	char *caller_controls = NULL;
+	char *member_flags = NULL;
+	char *conference_flags = NULL;
+	char *perpetual_sound = NULL;
+	char *moh_sound = NULL;
+	uint32_t max_members = 0;
+	uint32_t announce_count = 0;
+	char *maxmember_sound = NULL;
+	uint32_t rate = 8000, interval = 20;
+	switch_status_t status;
+	int comfort_noise_level = 0;
+	char *suppress_events = NULL;
+	char *verbose_events = NULL;
+	char *auto_record = NULL;
+
+	/* Validate the conference name */
+	if (zstr(name)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Record! no name.\n");
+		return NULL;
+	}
+
+	switch_mutex_lock(globals.hash_mutex);
+
+	/* parse the profile tree for param values */
+	if (cfg.profile)
+		for (xml_kvp = switch_xml_child(cfg.profile, "param"); xml_kvp; xml_kvp = xml_kvp->next) {
+			char *var = (char *) switch_xml_attr_soft(xml_kvp, "name");
+			char *val = (char *) switch_xml_attr_soft(xml_kvp, "value");
+			char buf[128] = "";
+			char *p;
+
+			if ((p = strchr(var, '_'))) {
+				switch_copy_string(buf, var, sizeof(buf));
+				for (p = buf; *p; p++) {
+					if (*p == '_') {
+						*p = '-';
+					}
+				}
+				var = buf;
+			}
+
+			if (!strcasecmp(var, "rate") && !zstr(val)) {
+				uint32_t tmp = atoi(val);
+				if (tmp == 8000 || tmp == 12000 || tmp == 16000 || tmp == 24000 || tmp == 32000 || tmp == 48000) {
+					rate = tmp;
+				}
+			} else if (!strcasecmp(var, "domain") && !zstr(val)) {
+				domain = val;
+			} else if (!strcasecmp(var, "interval") && !zstr(val)) {
+				uint32_t tmp = atoi(val);
+				if (SWITCH_ACCEPTABLE_INTERVAL(tmp)) {
+					interval = tmp;
+				} else {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+									  "Interval must be multipe of 10 and less than %d, Using default of 20\n", SWITCH_MAX_INTERVAL);
+				}
+			} else if (!strcasecmp(var, "timer-name") && !zstr(val)) {
+				timer_name = val;
+			} else if (!strcasecmp(var, "tts-engine") && !zstr(val)) {
+				tts_engine = val;
+			} else if (!strcasecmp(var, "tts-voice") && !zstr(val)) {
+				tts_voice = val;
+			} else if (!strcasecmp(var, "enter-sound") && !zstr(val)) {
+				enter_sound = val;
+			} else if (!strcasecmp(var, "exit-sound") && !zstr(val)) {
+				exit_sound = val;
+			} else if (!strcasecmp(var, "alone-sound") && !zstr(val)) {
+				alone_sound = val;
+			} else if (!strcasecmp(var, "perpetual-sound") && !zstr(val)) {
+				perpetual_sound = val;
+			} else if (!strcasecmp(var, "moh-sound") && !zstr(val)) {
+				moh_sound = val;
+			} else if (!strcasecmp(var, "ack-sound") && !zstr(val)) {
+				ack_sound = val;
+			} else if (!strcasecmp(var, "nack-sound") && !zstr(val)) {
+				nack_sound = val;
+			} else if (!strcasecmp(var, "muted-sound") && !zstr(val)) {
+				muted_sound = val;
+			} else if (!strcasecmp(var, "mute-detect-sound") && !zstr(val)) {
+				mute_detect_sound = val;
+			} else if (!strcasecmp(var, "unmuted-sound") && !zstr(val)) {
+				unmuted_sound = val;
+			} else if (!strcasecmp(var, "locked-sound") && !zstr(val)) {
+				locked_sound = val;
+			} else if (!strcasecmp(var, "is-locked-sound") && !zstr(val)) {
+				is_locked_sound = val;
+			} else if (!strcasecmp(var, "is-unlocked-sound") && !zstr(val)) {
+				is_unlocked_sound = val;
+			} else if (!strcasecmp(var, "member-flags") && !zstr(val)) {
+				member_flags = val;
+			} else if (!strcasecmp(var, "conference-flags") && !zstr(val)) {
+				conference_flags = val;
+			} else if (!strcasecmp(var, "kicked-sound") && !zstr(val)) {
+				kicked_sound = val;
+			} else if (!strcasecmp(var, "pin") && !zstr(val)) {
+				pin = val;
+			} else if (!strcasecmp(var, "pin-sound") && !zstr(val)) {
+				pin_sound = val;
+			} else if (!strcasecmp(var, "bad-pin-sound") && !zstr(val)) {
+				bad_pin_sound = val;
+			} else if (!strcasecmp(var, "energy-level") && !zstr(val)) {
+				energy_level = val;
+			} else if (!strcasecmp(var, "caller-id-name") && !zstr(val)) {
+				caller_id_name = val;
+			} else if (!strcasecmp(var, "caller-id-number") && !zstr(val)) {
+				caller_id_number = val;
+			} else if (!strcasecmp(var, "caller-controls") && !zstr(val)) {
+				caller_controls = val;
+			} else if (!strcasecmp(var, "comfort-noise") && !zstr(val)) {
+				int tmp;
+				tmp = atoi(val);
+				if (tmp > 1 && tmp < 10000) {
+					comfort_noise_level = tmp;
+				} else if (switch_true(val)) {
+					comfort_noise_level = 1400;
+				}
+			} else if (!strcasecmp(var, "sound-prefix") && !zstr(val)) {
+				sound_prefix = val;
+			} else if (!strcasecmp(var, "max-members") && !zstr(val)) {
+				errno = 0;		/* sanity first */
+				max_members = strtol(val, NULL, 0);	/* base 0 lets 0x... for hex 0... for octal and base 10 otherwise through */
+				if (errno == ERANGE || errno == EINVAL || max_members < 0 || max_members == 1) {
+					/* a negative wont work well, and its foolish to have a conference limited to 1 person unless the outbound 
+					 * stuff is added, see comments above
+					 */
+					max_members = 0;	/* set to 0 to disable max counts */
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "max-members %s is invalid, not setting a limit\n", val);
+				}
+			} else if (!strcasecmp(var, "max-members-sound") && !zstr(val)) {
+				maxmember_sound = val;
+			} else if (!strcasecmp(var, "announce-count") && !zstr(val)) {
+				errno = 0;		/* safety first */
+				announce_count = strtol(val, NULL, 0);
+				if (errno == ERANGE || errno == EINVAL) {
+					announce_count = 0;
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "announce-count is invalid, not anouncing member counts\n");
+				}
+			} else if (!strcasecmp(var, "suppress-events") && !zstr(val)) {
+				suppress_events = val;
+			} else if (!strcasecmp(var, "verbose-events") && !zstr(val)) {
+				verbose_events = val;
+			} else if (!strcasecmp(var, "auto-record") && !zstr(val)) {
+				auto_record = val;
+			}
+		}
+
+	/* Set defaults and various paramaters */
+
+	/* Timer module to use */
+	if (zstr(timer_name)) {
+		timer_name = "soft";
+	}
+
+	/* Caller ID Name */
+	if (zstr(caller_id_name)) {
+		caller_id_name = (char *) global_app_name;
+	}
+
+	/* Caller ID Number */
+	if (zstr(caller_id_number)) {
+		caller_id_number = "0000000000";
+	}
+
+	if (!pool) {
+		/* Setup a memory pool to use. */
+		if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+			status = SWITCH_STATUS_TERM;
+			conference = NULL;
+			goto end;
+		}
+	}
+
+	/* Create the conference object. */
+	if (!(conference = switch_core_alloc(pool, sizeof(*conference)))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
+		status = SWITCH_STATUS_TERM;
+		conference = NULL;
+		goto end;
+	}
+
+	/* initialize the conference object with settings from the specified profile */
+	conference->pool = pool;
+	conference->profile_name = switch_core_strdup(conference->pool, cfg.profile ? switch_xml_attr_soft(cfg.profile, "name") : "none");
+	if (timer_name) {
+		conference->timer_name = switch_core_strdup(conference->pool, timer_name);
+	}
+	if (tts_engine) {
+		conference->tts_engine = switch_core_strdup(conference->pool, tts_engine);
+	}
+	if (tts_voice) {
+		conference->tts_voice = switch_core_strdup(conference->pool, tts_voice);
+	}
+
+	conference->comfort_noise_level = comfort_noise_level;
+	conference->caller_id_name = switch_core_strdup(conference->pool, caller_id_name);
+	conference->caller_id_number = switch_core_strdup(conference->pool, caller_id_number);
+
+
+	if (!zstr(perpetual_sound)) {
+		conference->perpetual_sound = switch_core_strdup(conference->pool, perpetual_sound);
+	}
+
+	conference->mflags = MFLAG_CAN_SPEAK | MFLAG_CAN_HEAR;
+
+	if (!zstr(moh_sound) && switch_is_moh(moh_sound)) {
+		conference->moh_sound = switch_core_strdup(conference->pool, moh_sound);
+	}
+
+	if (member_flags) {
+		set_mflags(member_flags, &conference->mflags);
+	}
+
+	if (conference_flags) {
+		set_cflags(conference_flags, &conference->flags);
+	}
+
+	if (sound_prefix) {
+		conference->sound_prefix = switch_core_strdup(conference->pool, sound_prefix);
+	}
+
+	if (!zstr(enter_sound)) {
+		conference->enter_sound = switch_core_strdup(conference->pool, enter_sound);
+	}
+
+	if (!zstr(exit_sound)) {
+		conference->exit_sound = switch_core_strdup(conference->pool, exit_sound);
+	}
+
+	if (!zstr(ack_sound)) {
+		conference->ack_sound = switch_core_strdup(conference->pool, ack_sound);
+	}
+
+	if (!zstr(nack_sound)) {
+		conference->nack_sound = switch_core_strdup(conference->pool, nack_sound);
+	}
+
+	if (!zstr(muted_sound)) {
+		conference->muted_sound = switch_core_strdup(conference->pool, muted_sound);
+	}
+
+	if (zstr(mute_detect_sound)) {
+		if (!zstr(muted_sound)) {
+			conference->mute_detect_sound = switch_core_strdup(conference->pool, muted_sound);
+		}
+	} else {
+		conference->mute_detect_sound = switch_core_strdup(conference->pool, mute_detect_sound);
+	}
+
+	if (!zstr(unmuted_sound)) {
+		conference->unmuted_sound = switch_core_strdup(conference->pool, unmuted_sound);
+	}
+
+	if (!zstr(kicked_sound)) {
+		conference->kicked_sound = switch_core_strdup(conference->pool, kicked_sound);
+	}
+
+	if (!zstr(pin_sound)) {
+		conference->pin_sound = switch_core_strdup(conference->pool, pin_sound);
+	}
+
+	if (!zstr(bad_pin_sound)) {
+		conference->bad_pin_sound = switch_core_strdup(conference->pool, bad_pin_sound);
+	}
+
+	if (!zstr(pin)) {
+		conference->pin = switch_core_strdup(conference->pool, pin);
+	}
+
+	if (!zstr(alone_sound)) {
+		conference->alone_sound = switch_core_strdup(conference->pool, alone_sound);
+	}
+
+	if (!zstr(locked_sound)) {
+		conference->locked_sound = switch_core_strdup(conference->pool, locked_sound);
+	}
+
+	if (!zstr(is_locked_sound)) {
+		conference->is_locked_sound = switch_core_strdup(conference->pool, is_locked_sound);
+	}
+
+	if (!zstr(is_unlocked_sound)) {
+		conference->is_unlocked_sound = switch_core_strdup(conference->pool, is_unlocked_sound);
+	}
+
+	if (!zstr(energy_level)) {
+		conference->energy_level = atoi(energy_level);
+	}
+
+	if (!zstr(maxmember_sound)) {
+		conference->maxmember_sound = switch_core_strdup(conference->pool, maxmember_sound);
+	}
+	/* its going to be 0 by default, set to a value otherwise so this should be safe */
+	conference->max_members = max_members;
+	conference->announce_count = announce_count;
+
+	conference->name = switch_core_strdup(conference->pool, name);
+	if (domain) {
+		conference->domain = switch_core_strdup(conference->pool, domain);
+	} else {
+		conference->domain = "cluecon.com";
+	}
+	conference->rate = rate;
+	conference->interval = interval;
+	conference->dtmf_parser = NULL;
+
+	conference->eflags = 0xFFFFFFFF;
+	if (!zstr(suppress_events)) {
+		clear_eflags(suppress_events, &conference->eflags);
+	}
+
+	if (!zstr(auto_record)) {
+		conference->auto_record = switch_core_strdup(conference->pool, auto_record);
+	}
+
+	if (!zstr(verbose_events) && switch_true(verbose_events)) {
+		conference->verbose_events = 1;
+	}
+
+	/* caller control configuration chores */
+	if (switch_ivr_digit_stream_parser_new(conference->pool, &conference->dtmf_parser) == SWITCH_STATUS_SUCCESS) {
+
+		/* if no controls, or default controls specified, install default */
+		if (caller_controls == NULL || *caller_controls == '\0' || strcasecmp(caller_controls, "default") == 0) {
+			status = conf_default_controls(conference);
+		} else if (strcasecmp(caller_controls, "none") != 0) {
+			/* try to build caller control if the group has been specified and != "none" */
+			switch_xml_t xml_controls = switch_xml_find_child(cfg.controls, "group", "name", caller_controls);
+			status = conference_new_install_caller_controls_custom(conference, xml_controls, NULL);
+
+			if (status != SWITCH_STATUS_SUCCESS) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to install caller controls group '%s'\n", caller_controls);
+			}
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "No caller controls installed.\n");
+		}
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to allocate caller control digit parser.\n");
+	}
+
+	/* Activate the conference mutex for exclusivity */
+	switch_mutex_init(&conference->mutex, SWITCH_MUTEX_NESTED, conference->pool);
+	switch_mutex_init(&conference->flag_mutex, SWITCH_MUTEX_NESTED, conference->pool);
+	switch_thread_rwlock_create(&conference->rwlock, conference->pool);
+	switch_mutex_init(&conference->member_mutex, SWITCH_MUTEX_NESTED, conference->pool);
+	switch_mutex_lock(globals.hash_mutex);
+	switch_core_hash_insert(globals.conference_hash, conference->name, conference);
+	switch_mutex_unlock(globals.hash_mutex);
+
+  end:
+
+	switch_mutex_unlock(globals.hash_mutex);
+
+	return conference;
+}
+
+static void pres_event_handler(switch_event_t *event)
+{
+	char *to = switch_event_get_header(event, "to");
+	char *dup_to = NULL, *conf_name, *e;
+	conference_obj_t *conference;
+
+	if (!to || strncasecmp(to, "conf+", 5)) {
+		return;
+	}
+
+	if (!(dup_to = strdup(to))) {
+		return;
+	}
+
+	conf_name = dup_to + 5;
+
+	if ((e = strchr(conf_name, '@'))) {
+		*e = '\0';
+	}
+
+	if ((conference = conference_find(conf_name))) {
+		if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", conference->name, conference->domain);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "Active (%d caller%s)", conference->count, conference->count == 1 ? "" : "s");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", conf_name);
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_ROUTING");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", conference->count == 1 ? "early" : "confirmed");
+			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", conference->count == 1 ? "outbound" : "inbound");
+			switch_event_fire(&event);
+		}
+	} else if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", conf_name);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from", to);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", "Idle");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", "idle");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", conf_name);
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_HANGUP");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", "terminated");
+		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", "inbound");
+		switch_event_fire(&event);
+	}
+
+	switch_safe_free(dup_to);
+}
+
+static void send_presence(switch_event_types_t id)
+{
+	switch_xml_t cxml, cfg, advertise, room;
+	switch_event_t *params = NULL;
+
+	switch_event_create(&params, SWITCH_EVENT_COMMAND);
+	switch_assert(params);
+	switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "presence", "true");
+
+
+	/* Open the config from the xml registry */
+	if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, params))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", global_cf_name);
+		goto done;
+	}
+
+	if ((advertise = switch_xml_child(cfg, "advertise"))) {
+		for (room = switch_xml_child(advertise, "room"); room; room = room->next) {
+			char *name = (char *) switch_xml_attr_soft(room, "name");
+			char *status = (char *) switch_xml_attr_soft(room, "status");
+			switch_event_t *event;
+
+			if (name && switch_event_create(&event, id) == SWITCH_STATUS_SUCCESS) {
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", name);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from", name);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", status ? status : "Available");
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", "idle");
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+				switch_event_fire(&event);
+			}
+		}
+	}
+
+  done:
+	switch_event_destroy(&params);
+
+	/* Release the config registry handle */
+	if (cxml) {
+		switch_xml_free(cxml);
+		cxml = NULL;
+	}
+}
+
+/* Called by FreeSWITCH when the module loads */
+SWITCH_MODULE_LOAD_FUNCTION(mod_conference_load)
+{
+	uint32_t i;
+	size_t nl, ol = 0;
+	char *p = NULL, *tmp = NULL;
+	switch_chat_interface_t *chat_interface;
+	switch_api_interface_t *api_interface;
+	switch_application_interface_t *app_interface;
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+	memset(&globals, 0, sizeof(globals));
+
+	/* Connect my internal structure to the blank pointer passed to me */
+	*module_interface = switch_loadable_module_create_module_interface(pool, modname);
+
+	/* build api interface help ".syntax" field string */
+	p = strdup("");
+	for (i = 0; i < CONFFUNCAPISIZE; i++) {
+		nl = strlen(conf_api_sub_commands[i].psyntax) + 4;
+		if (p != NULL) {
+			ol = strlen(p);
+		}
+		tmp = realloc(p, ol + nl);
+		if (tmp != NULL) {
+			p = tmp;
+			strcat(p, "\t\t");
+			strcat(p, conf_api_sub_commands[i].psyntax);
+			if (i < CONFFUNCAPISIZE - 1) {
+				strcat(p, "\n");
+			}
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't realloc\n");
+			return SWITCH_STATUS_TERM;
+		}
+
+	}
+	api_syntax = p;
+
+	/* create/register custom event message type */
+	if (switch_event_reserve_subclass(CONF_EVENT_MAINT) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't register subclass %s!\n", CONF_EVENT_MAINT);
+		return SWITCH_STATUS_TERM;
+	}
+
+	/* Setup the pool */
+	globals.conference_pool = pool;
+
+	/* Setup a hash to store conferences by name */
+	switch_core_hash_init(&globals.conference_hash, globals.conference_pool);
+	switch_mutex_init(&globals.conference_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool);
+	switch_mutex_init(&globals.id_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool);
+	switch_mutex_init(&globals.hash_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool);
+	switch_mutex_init(&globals.setup_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool);
+
+	/* Subscribe to presence request events */
+	if (switch_event_bind_removable(modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, pres_event_handler, NULL, &globals.node) !=
+		SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't subscribe to presence request events!\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	SWITCH_ADD_API(api_interface, "conference", "Conference module commands", conf_api_main, p);
+	SWITCH_ADD_APP(app_interface, global_app_name, global_app_name, NULL, conference_function, NULL, SAF_NONE);
+	SWITCH_ADD_APP(app_interface, "conference_set_auto_outcall", "conference_set_auto_outcall", NULL, conference_auto_function, NULL, SAF_NONE);
+	SWITCH_ADD_CHAT(chat_interface, CONF_CHAT_PROTO, chat_send);
+
+	send_presence(SWITCH_EVENT_PRESENCE_IN);
+
+	globals.running = 1;
+	/* indicate that the module should continue to be loaded */
+	return status;
+}
+
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_conference_shutdown)
+{
+	if (globals.running) {
+
+		/* signal all threads to shutdown */
+		globals.running = 0;
+
+		/* wait for all threads */
+		while (globals.threads) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Waiting for %d threads\n", globals.threads);
+			switch_yield(100000);
+		}
+
+		switch_event_unbind(&globals.node);
+		switch_event_free_subclass(CONF_EVENT_MAINT);
+
+		/* free api interface help ".syntax" field string */
+		switch_safe_free(api_syntax);
+	}
+	switch_core_hash_destroy(&globals.conference_hash);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
diff --git a/src/mod/applications/mod_conference/mod_conference.c.rej b/src/mod/applications/mod_conference/mod_conference.c.rej
new file mode 100644
index 0000000000..a9890b9dda
--- /dev/null
+++ b/src/mod/applications/mod_conference/mod_conference.c.rej
@@ -0,0 +1,50 @@
+***************
+*** 3410,3420 ****
+  	}
+  	if (test_eflag(member->conference, EFLAG_VOLUME_IN_MEMBER) &&
+  		data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+  		conference_add_event_member_data(member, event);
+  		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-in-member");
+- 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%u", member->volume_in_level);
+  		switch_event_fire(&event);
+  	}
+  
+  	return SWITCH_STATUS_SUCCESS;
+  }
+--- 3410,3420 ----
+  	}
+  	if (test_eflag(member->conference, EFLAG_VOLUME_IN_MEMBER) &&
+  		data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+  		conference_add_event_member_data(member, event);
+  		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-in-member");
++ 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%d", member->volume_in_level);
+  		switch_event_fire(&event);
+  	}
+  
+  	return SWITCH_STATUS_SUCCESS;
+  }
+***************
+*** 3437,3447 ****
+  	}
+  	if (test_eflag(member->conference, EFLAG_VOLUME_OUT_MEMBER) && data &&
+  		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+  		conference_add_event_member_data(member, event);
+  		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-out-member");
+- 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%u", member->volume_out_level);
+  		switch_event_fire(&event);
+  	}
+  
+  	return SWITCH_STATUS_SUCCESS;
+  }
+--- 3437,3447 ----
+  	}
+  	if (test_eflag(member->conference, EFLAG_VOLUME_OUT_MEMBER) && data &&
+  		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+  		conference_add_event_member_data(member, event);
+  		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-out-member");
++ 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%d", member->volume_out_level);
+  		switch_event_fire(&event);
+  	}
+  
+  	return SWITCH_STATUS_SUCCESS;
+  }
diff --git a/src/mod/formats/mod_sndfile/mod_sndfile.c.orig b/src/mod/formats/mod_sndfile/mod_sndfile.c.orig
new file mode 100644
index 0000000000..020943ce5a
--- /dev/null
+++ b/src/mod/formats/mod_sndfile/mod_sndfile.c.orig
@@ -0,0 +1,462 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ * Copyright (C) 2005-2010, Anthony Minessale II <anthm@freeswitch.org>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Anthony Minessale II <anthm@freeswitch.org>
+ *
+ *
+ * mod_sndfile.c -- Framework Demo Module
+ *
+ */
+#include <switch.h>
+#include <sndfile.h>
+
+SWITCH_MODULE_LOAD_FUNCTION(mod_sndfile_load);
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_sndfile_shutdown);
+SWITCH_MODULE_DEFINITION(mod_sndfile, mod_sndfile_load, mod_sndfile_shutdown, NULL);
+
+static switch_memory_pool_t *module_pool = NULL;
+
+static struct {
+	switch_hash_t *format_hash;
+} globals;
+
+struct format_map {
+	char *ext;
+	char *uext;
+	uint32_t format;
+};
+
+struct sndfile_context {
+	SF_INFO sfinfo;
+	SNDFILE *handle;
+};
+
+typedef struct sndfile_context sndfile_context;
+
+static switch_status_t sndfile_file_open(switch_file_handle_t *handle, const char *path)
+{
+	sndfile_context *context;
+	int mode = 0;
+	char *ext;
+	struct format_map *map = NULL;
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+	char *alt_path = NULL, *last, *ldup = NULL;
+	size_t alt_len = 0;
+	int rates[4] = { 8000, 16000, 32000, 48000 };
+	int i;
+#ifdef WIN32
+	char ps = '\\';
+#else
+	char ps = '/';
+#endif
+
+	if ((ext = strrchr(path, '.')) == 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Format\n");
+		return SWITCH_STATUS_GENERR;
+	}
+	ext++;
+
+	if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
+		mode += SFM_READ;
+	}
+
+	if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
+		if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND)) {
+			mode += SFM_RDWR;
+		} else {
+			mode += SFM_WRITE;
+		}
+	}
+
+	if (!mode) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Mode!\n");
+		return SWITCH_STATUS_GENERR;
+	}
+
+	if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) {
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	map = switch_core_hash_find(globals.format_hash, ext);
+
+	if (mode & SFM_WRITE) {
+		context->sfinfo.channels = handle->channels;
+		context->sfinfo.samplerate = handle->samplerate;
+		if (handle->samplerate == 8000 || handle->samplerate == 16000 ||
+			handle->samplerate == 24000 || handle->samplerate == 32000 || handle->samplerate == 48000 ||
+			handle->samplerate == 11025 || handle->samplerate == 22050 || handle->samplerate == 44100) {
+			context->sfinfo.format |= SF_FORMAT_PCM_16;
+		}
+	}
+
+	if (map) {
+		context->sfinfo.format |= map->format;
+	}
+
+	if (!strcmp(ext, "r8") || !strcmp(ext, "raw")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_PCM_16;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 8000;
+	} else if (!strcmp(ext, "r16")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_PCM_16;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 16000;
+	} else if (!strcmp(ext, "r24")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_PCM_24;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 24000;
+	} else if (!strcmp(ext, "r32")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_PCM_32;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 32000;
+	} else if (!strcmp(ext, "gsm")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_GSM610;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 8000;
+	} else if (!strcmp(ext, "ul")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_ULAW;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 8000;
+	} else if (!strcmp(ext, "al")) {
+		context->sfinfo.format = SF_FORMAT_RAW | SF_FORMAT_ALAW;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 8000;
+	} else if (!strcmp(ext, "adpcm")) {
+		context->sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM;
+		context->sfinfo.channels = 1;
+		context->sfinfo.samplerate = 8000;
+	}
+
+	if ((mode & SFM_WRITE) && sf_format_check(&context->sfinfo) == 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error : file format is invalid (0x%08X).\n", context->sfinfo.format);
+		return SWITCH_STATUS_GENERR;
+	}
+
+	alt_len = strlen(path) + 10;
+	switch_zmalloc(alt_path, alt_len);
+
+	switch_copy_string(alt_path, path, alt_len);
+
+	/* This block attempts to add the sample rate to the path
+	   if the sample rate is already present in the path it does nothing
+	   and reverts to the original file name.
+	 */
+	if ((last = strrchr(alt_path, ps))) {
+		last++;
+#ifdef WIN32
+		if (strrchr(last, '/')) {
+			last = strrchr(alt_path, '/');	/* do not swallow a forward slash if they are intermixed under windows */
+			last++;
+		}
+#endif
+		ldup = strdup(last);
+		switch_assert(ldup);
+		switch_snprintf(last, alt_len - (last - alt_path), "%d%s%s", handle->samplerate, SWITCH_PATH_SEPARATOR, ldup);
+		if ((context->handle = sf_open(alt_path, mode, &context->sfinfo))) {
+			path = alt_path;
+		} else {
+			/* Try to find the file at the highest rate possible if we can't find one that matches the exact rate.
+			   If we don't find any, we will default back to the original file name.
+			 */
+			for (i = 3; i >= 0; i--) {
+				switch_snprintf(last, alt_len - (last - alt_path), "%d%s%s", rates[i], SWITCH_PATH_SEPARATOR, ldup);
+				if ((context->handle = sf_open(alt_path, mode, &context->sfinfo))) {
+					path = alt_path;
+					break;
+				}
+			}
+		}
+	}
+
+	if (!context->handle) {
+		if ((context->handle = sf_open(path, mode, &context->sfinfo)) == 0) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening File [%s] [%s]\n", path, sf_strerror(context->handle));
+			status = SWITCH_STATUS_GENERR;
+			goto end;
+		}
+	}
+	//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Opening File [%s] rate %dhz\n", path, context->sfinfo.samplerate);
+	handle->samples = (unsigned int) context->sfinfo.frames;
+	handle->samplerate = context->sfinfo.samplerate;
+	handle->channels = (uint8_t) context->sfinfo.channels;
+	handle->format = context->sfinfo.format;
+	handle->sections = context->sfinfo.sections;
+	handle->seekable = context->sfinfo.seekable;
+	handle->speed = 0;
+	handle->private_info = context;
+
+	if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND)) {
+		handle->pos = sf_seek(context->handle, 0, SEEK_END);
+	} else {
+		sf_count_t frames = 0;
+		sf_command(context->handle, SFC_FILE_TRUNCATE, &frames, sizeof(frames));
+	}
+
+
+  end:
+
+	switch_safe_free(alt_path);
+	switch_safe_free(ldup);
+
+	return status;
+}
+
+static switch_status_t sndfile_file_truncate(switch_file_handle_t *handle, int64_t offset)
+{
+	sndfile_context *context = handle->private_info;
+	sf_command(context->handle, SFC_FILE_TRUNCATE, &offset, sizeof(offset));
+	handle->pos = 0;
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t sndfile_file_close(switch_file_handle_t *handle)
+{
+	sndfile_context *context = handle->private_info;
+
+	sf_close(context->handle);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t sndfile_file_seek(switch_file_handle_t *handle, unsigned int *cur_sample, int64_t samples, int whence)
+{
+	sndfile_context *context = handle->private_info;
+
+	if (!handle->seekable) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "File is not seekable\n");
+		return SWITCH_STATUS_NOTIMPL;
+	}
+
+	*cur_sample = (unsigned int) sf_seek(context->handle, samples, whence);
+	handle->pos = *cur_sample;
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t sndfile_file_read(switch_file_handle_t *handle, void *data, size_t *len)
+{
+	size_t inlen = *len;
+	sndfile_context *context = handle->private_info;
+
+	if (switch_test_flag(handle, SWITCH_FILE_DATA_RAW)) {
+		*len = (size_t) sf_read_raw(context->handle, data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_INT)) {
+		*len = (size_t) sf_readf_int(context->handle, (int *) data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_SHORT)) {
+		*len = (size_t) sf_readf_short(context->handle, (short *) data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_FLOAT)) {
+		*len = (size_t) sf_readf_float(context->handle, (float *) data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_DOUBLE)) {
+		*len = (size_t) sf_readf_double(context->handle, (double *) data, inlen);
+	} else {
+		*len = (size_t) sf_readf_int(context->handle, (int *) data, inlen);
+	}
+
+	handle->pos += *len;
+	handle->sample_count += *len;
+
+	return *len ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
+}
+
+static switch_status_t sndfile_file_write(switch_file_handle_t *handle, void *data, size_t *len)
+{
+	size_t inlen = *len;
+	sndfile_context *context = handle->private_info;
+
+	if (switch_test_flag(handle, SWITCH_FILE_DATA_RAW)) {
+		*len = (size_t) sf_write_raw(context->handle, data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_INT)) {
+		*len = (size_t) sf_writef_int(context->handle, (int *) data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_SHORT)) {
+		*len = (size_t) sf_writef_short(context->handle, (short *) data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_FLOAT)) {
+		*len = (size_t) sf_writef_float(context->handle, (float *) data, inlen);
+	} else if (switch_test_flag(handle, SWITCH_FILE_DATA_DOUBLE)) {
+		*len = (size_t) sf_writef_double(context->handle, (double *) data, inlen);
+	} else {
+		*len = (size_t) sf_writef_int(context->handle, (int *) data, inlen);
+	}
+
+	handle->sample_count += *len;
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t sndfile_file_set_string(switch_file_handle_t *handle, switch_audio_col_t col, const char *string)
+{
+	sndfile_context *context = handle->private_info;
+
+	return sf_set_string(context->handle, (int) col, string) ? SWITCH_STATUS_FALSE : SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t sndfile_file_get_string(switch_file_handle_t *handle, switch_audio_col_t col, const char **string)
+{
+	sndfile_context *context = handle->private_info;
+	const char *s;
+
+	if ((s = sf_get_string(context->handle, (int) col))) {
+		*string = s;
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	return SWITCH_STATUS_FALSE;
+}
+
+/* Registration */
+
+static char **supported_formats;
+
+static switch_status_t setup_formats(void)
+{
+	SF_FORMAT_INFO info;
+	SF_INFO sfinfo;
+	char buffer[128];
+	int format, major_count, subtype_count, m, s;
+	int len, x, skip;
+	char *extras[] = { "r8", "r16", "r24", "r32", "gsm", "ul", "al", "adpcm", NULL };
+	int exlen = (sizeof(extras) / sizeof(extras[0]));
+	buffer[0] = 0;
+
+	sf_command(NULL, SFC_GET_LIB_VERSION, buffer, sizeof(buffer));
+	if (strlen(buffer) < 1) {
+		switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR, "Line %d: could not retrieve lib version.\n", __LINE__);
+		return SWITCH_STATUS_FALSE;
+	}
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "\nLibSndFile Version : %s Supported Formats\n", buffer);
+	switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO, "================================================================================\n");
+	sf_command(NULL, SFC_GET_FORMAT_MAJOR_COUNT, &major_count, sizeof(int));
+	sf_command(NULL, SFC_GET_FORMAT_SUBTYPE_COUNT, &subtype_count, sizeof(int));
+
+	sfinfo.channels = 1;
+	len = ((major_count + (exlen + 2)) * sizeof(char *));
+	supported_formats = switch_core_permanent_alloc(len);
+
+	len = 0;
+	for (m = 0; m < major_count; m++) {
+		skip = 0;
+		info.format = m;
+		sf_command(NULL, SFC_GET_FORMAT_MAJOR, &info, sizeof(info));
+		switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO, "%s  (extension \"%s\")\n", info.name, info.extension);
+		for (x = 0; x < len; x++) {
+			if (supported_formats[x] == info.extension) {
+				skip++;
+				break;
+			}
+		}
+		if (!skip) {
+			char *p;
+			struct format_map *map = switch_core_permanent_alloc(sizeof(*map));
+			switch_assert(map);
+
+			map->ext = switch_core_permanent_strdup(info.extension);
+			map->uext = switch_core_permanent_strdup(info.extension);
+			map->format = info.format;
+			if (map->ext) {
+				for (p = map->ext; *p; p++) {
+					*p = (char) switch_tolower(*p);
+				}
+				switch_core_hash_insert(globals.format_hash, map->ext, map);
+			}
+			if (map->uext) {
+				for (p = map->uext; *p; p++) {
+					*p = (char) switch_toupper(*p);
+				}
+				switch_core_hash_insert(globals.format_hash, map->uext, map);
+			}
+			supported_formats[len++] = (char *) info.extension;
+		}
+		format = info.format;
+
+		for (s = 0; s < subtype_count; s++) {
+			info.format = s;
+			sf_command(NULL, SFC_GET_FORMAT_SUBTYPE, &info, sizeof(info));
+			format = (format & SF_FORMAT_TYPEMASK) | info.format;
+			sfinfo.format = format;
+			/*
+			   if (sf_format_check(&sfinfo)) {
+			   switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_DEBUG, "   %s\n", info.name);
+			   }
+			 */
+		}
+	}
+	for (m = 0; m < exlen; m++) {
+		supported_formats[len++] = extras[m];
+	}
+
+	switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_NOTICE, "================================================================================\n");
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_MODULE_LOAD_FUNCTION(mod_sndfile_load)
+{
+	switch_file_interface_t *file_interface;
+
+	if (switch_core_new_memory_pool(&module_pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
+		return SWITCH_STATUS_TERM;
+	}
+
+	switch_core_hash_init(&globals.format_hash, module_pool);
+
+	if (setup_formats() != SWITCH_STATUS_SUCCESS) {
+		return SWITCH_STATUS_FALSE;
+	}
+
+	/* connect my internal structure to the blank pointer passed to me */
+	*module_interface = switch_loadable_module_create_module_interface(pool, modname);
+	file_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_FILE_INTERFACE);
+	file_interface->interface_name = modname;
+	file_interface->extens = supported_formats;
+	file_interface->file_open = sndfile_file_open;
+	file_interface->file_close = sndfile_file_close;
+	file_interface->file_truncate = sndfile_file_truncate;
+	file_interface->file_read = sndfile_file_read;
+	file_interface->file_write = sndfile_file_write;
+	file_interface->file_seek = sndfile_file_seek;
+	file_interface->file_set_string = sndfile_file_set_string;
+	file_interface->file_get_string = sndfile_file_get_string;
+
+	/* indicate that the module should continue to be loaded */
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_sndfile_shutdown)
+{
+	switch_core_hash_destroy(&globals.format_hash);
+	return SWITCH_STATUS_SUCCESS;
+}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
diff --git a/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java b/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java
index 1c2e19ba9d..283518f1d6 100644
--- a/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java
+++ b/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java
@@ -38,11 +38,7 @@ public class API {
   }
 
   public String execute(String command, String data) {
-    return freeswitchJNI.API_execute__SWIG_0(swigCPtr, this, command, data);
-  }
-
-  public String execute(String command) {
-    return freeswitchJNI.API_execute__SWIG_1(swigCPtr, this, command);
+    return freeswitchJNI.API_execute(swigCPtr, this, command, data);
   }
 
   public String executeString(String command) {
diff --git a/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java b/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java
index d36d4b9f3a..2b9353c063 100644
--- a/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java
+++ b/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java
@@ -125,11 +125,7 @@ public class CoreSession {
   }
 
   public void hangup(String cause) {
-    freeswitchJNI.CoreSession_hangup__SWIG_0(swigCPtr, this, cause);
-  }
-
-  public void hangup() {
-    freeswitchJNI.CoreSession_hangup__SWIG_1(swigCPtr, this);
+    freeswitchJNI.CoreSession_hangup(swigCPtr, this, cause);
   }
 
   public void hangupState() {
@@ -158,23 +154,11 @@ public class CoreSession {
   }
 
   public void say(String tosay, String module_name, String say_type, String say_method, String say_gender) {
-    freeswitchJNI.CoreSession_say__SWIG_0(swigCPtr, this, tosay, module_name, say_type, say_method, say_gender);
-  }
-
-  public void say(String tosay, String module_name, String say_type, String say_method) {
-    freeswitchJNI.CoreSession_say__SWIG_1(swigCPtr, this, tosay, module_name, say_type, say_method);
+    freeswitchJNI.CoreSession_say(swigCPtr, this, tosay, module_name, say_type, say_method, say_gender);
   }
 
   public void sayPhrase(String phrase_name, String phrase_data, String phrase_lang) {
-    freeswitchJNI.CoreSession_sayPhrase__SWIG_0(swigCPtr, this, phrase_name, phrase_data, phrase_lang);
-  }
-
-  public void sayPhrase(String phrase_name, String phrase_data) {
-    freeswitchJNI.CoreSession_sayPhrase__SWIG_1(swigCPtr, this, phrase_name, phrase_data);
-  }
-
-  public void sayPhrase(String phrase_name) {
-    freeswitchJNI.CoreSession_sayPhrase__SWIG_2(swigCPtr, this, phrase_name);
+    freeswitchJNI.CoreSession_sayPhrase(swigCPtr, this, phrase_name, phrase_data, phrase_lang);
   }
 
   public String hangupCause() {
@@ -186,31 +170,11 @@ public class CoreSession {
   }
 
   public int recordFile(String file_name, int time_limit, int silence_threshold, int silence_hits) {
-    return freeswitchJNI.CoreSession_recordFile__SWIG_0(swigCPtr, this, file_name, time_limit, silence_threshold, silence_hits);
-  }
-
-  public int recordFile(String file_name, int time_limit, int silence_threshold) {
-    return freeswitchJNI.CoreSession_recordFile__SWIG_1(swigCPtr, this, file_name, time_limit, silence_threshold);
-  }
-
-  public int recordFile(String file_name, int time_limit) {
-    return freeswitchJNI.CoreSession_recordFile__SWIG_2(swigCPtr, this, file_name, time_limit);
-  }
-
-  public int recordFile(String file_name) {
-    return freeswitchJNI.CoreSession_recordFile__SWIG_3(swigCPtr, this, file_name);
+    return freeswitchJNI.CoreSession_recordFile(swigCPtr, this, file_name, time_limit, silence_threshold, silence_hits);
   }
 
   public int originate(CoreSession a_leg_session, String dest, int timeout, SWIGTYPE_p_switch_state_handler_table_t handlers) {
-    return freeswitchJNI.CoreSession_originate__SWIG_0(swigCPtr, this, CoreSession.getCPtr(a_leg_session), a_leg_session, dest, timeout, SWIGTYPE_p_switch_state_handler_table_t.getCPtr(handlers));
-  }
-
-  public int originate(CoreSession a_leg_session, String dest, int timeout) {
-    return freeswitchJNI.CoreSession_originate__SWIG_1(swigCPtr, this, CoreSession.getCPtr(a_leg_session), a_leg_session, dest, timeout);
-  }
-
-  public int originate(CoreSession a_leg_session, String dest) {
-    return freeswitchJNI.CoreSession_originate__SWIG_2(swigCPtr, this, CoreSession.getCPtr(a_leg_session), a_leg_session, dest);
+    return freeswitchJNI.CoreSession_originate(swigCPtr, this, CoreSession.getCPtr(a_leg_session), a_leg_session, dest, timeout, SWIGTYPE_p_switch_state_handler_table_t.getCPtr(handlers));
   }
 
   public void destroy() {
@@ -246,15 +210,7 @@ public class CoreSession {
   }
 
   public int transfer(String extension, String dialplan, String context) {
-    return freeswitchJNI.CoreSession_transfer__SWIG_0(swigCPtr, this, extension, dialplan, context);
-  }
-
-  public int transfer(String extension, String dialplan) {
-    return freeswitchJNI.CoreSession_transfer__SWIG_1(swigCPtr, this, extension, dialplan);
-  }
-
-  public int transfer(String extension) {
-    return freeswitchJNI.CoreSession_transfer__SWIG_2(swigCPtr, this, extension);
+    return freeswitchJNI.CoreSession_transfer(swigCPtr, this, extension, dialplan, context);
   }
 
   public String read(int min_digits, int max_digits, String prompt_audio_file, int timeout, String valid_terminators) {
@@ -262,27 +218,15 @@ public class CoreSession {
   }
 
   public String playAndGetDigits(int min_digits, int max_digits, int max_tries, int timeout, String terminators, String audio_files, String bad_input_audio_files, String digits_regex, String var_name) {
-    return freeswitchJNI.CoreSession_playAndGetDigits__SWIG_0(swigCPtr, this, min_digits, max_digits, max_tries, timeout, terminators, audio_files, bad_input_audio_files, digits_regex, var_name);
-  }
-
-  public String playAndGetDigits(int min_digits, int max_digits, int max_tries, int timeout, String terminators, String audio_files, String bad_input_audio_files, String digits_regex) {
-    return freeswitchJNI.CoreSession_playAndGetDigits__SWIG_1(swigCPtr, this, min_digits, max_digits, max_tries, timeout, terminators, audio_files, bad_input_audio_files, digits_regex);
+    return freeswitchJNI.CoreSession_playAndGetDigits(swigCPtr, this, min_digits, max_digits, max_tries, timeout, terminators, audio_files, bad_input_audio_files, digits_regex, var_name);
   }
 
   public int streamFile(String file, int starting_sample_count) {
-    return freeswitchJNI.CoreSession_streamFile__SWIG_0(swigCPtr, this, file, starting_sample_count);
-  }
-
-  public int streamFile(String file) {
-    return freeswitchJNI.CoreSession_streamFile__SWIG_1(swigCPtr, this, file);
+    return freeswitchJNI.CoreSession_streamFile(swigCPtr, this, file, starting_sample_count);
   }
 
   public int sleep(int ms, int sync) {
-    return freeswitchJNI.CoreSession_sleep__SWIG_0(swigCPtr, this, ms, sync);
-  }
-
-  public int sleep(int ms) {
-    return freeswitchJNI.CoreSession_sleep__SWIG_1(swigCPtr, this, ms);
+    return freeswitchJNI.CoreSession_sleep(swigCPtr, this, ms, sync);
   }
 
   public int flushEvents() {
@@ -322,11 +266,7 @@ public class CoreSession {
   }
 
   public void execute(String app, String data) {
-    freeswitchJNI.CoreSession_execute__SWIG_0(swigCPtr, this, app, data);
-  }
-
-  public void execute(String app) {
-    freeswitchJNI.CoreSession_execute__SWIG_1(swigCPtr, this, app);
+    freeswitchJNI.CoreSession_execute(swigCPtr, this, app, data);
   }
 
   public void sendEvent(Event sendME) {
diff --git a/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java b/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java
index 5ed8de1198..81e949d285 100644
--- a/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java
+++ b/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java
@@ -50,11 +50,7 @@ public class DTMF {
   }
 
   public DTMF(char idigit, SWIGTYPE_p_uint32_t iduration) {
-    this(freeswitchJNI.new_DTMF__SWIG_0(idigit, SWIGTYPE_p_uint32_t.getCPtr(iduration)), true);
-  }
-
-  public DTMF(char idigit) {
-    this(freeswitchJNI.new_DTMF__SWIG_1(idigit), true);
+    this(freeswitchJNI.new_DTMF(idigit, SWIGTYPE_p_uint32_t.getCPtr(iduration)), true);
   }
 
 }
diff --git a/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java b/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java
index 9f93860274..c1c9ba17e7 100644
--- a/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java
+++ b/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java
@@ -62,32 +62,16 @@ public class Event {
     this(freeswitchJNI.new_Event__SWIG_0(type, subclass_name), true);
   }
 
-  public Event(String type) {
-    this(freeswitchJNI.new_Event__SWIG_1(type), true);
-  }
-
   public Event(SWIGTYPE_p_switch_event_t wrap_me, int free_me) {
-    this(freeswitchJNI.new_Event__SWIG_2(SWIGTYPE_p_switch_event_t.getCPtr(wrap_me), free_me), true);
-  }
-
-  public Event(SWIGTYPE_p_switch_event_t wrap_me) {
-    this(freeswitchJNI.new_Event__SWIG_3(SWIGTYPE_p_switch_event_t.getCPtr(wrap_me)), true);
+    this(freeswitchJNI.new_Event__SWIG_1(SWIGTYPE_p_switch_event_t.getCPtr(wrap_me), free_me), true);
   }
 
   public String serialize(String format) {
-    return freeswitchJNI.Event_serialize__SWIG_0(swigCPtr, this, format);
-  }
-
-  public String serialize() {
-    return freeswitchJNI.Event_serialize__SWIG_1(swigCPtr, this);
+    return freeswitchJNI.Event_serialize(swigCPtr, this, format);
   }
 
   public boolean setPriority(SWIGTYPE_p_switch_priority_t priority) {
-    return freeswitchJNI.Event_setPriority__SWIG_0(swigCPtr, this, SWIGTYPE_p_switch_priority_t.getCPtr(priority));
-  }
-
-  public boolean setPriority() {
-    return freeswitchJNI.Event_setPriority__SWIG_1(swigCPtr, this);
+    return freeswitchJNI.Event_setPriority(swigCPtr, this, SWIGTYPE_p_switch_priority_t.getCPtr(priority));
   }
 
   public String getHeader(String header_name) {
diff --git a/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java b/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java
index 91d4b39328..a28a386284 100644
--- a/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java
+++ b/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java
@@ -50,15 +50,6 @@ public class EventConsumer {
     return new SWIGTYPE_p_switch_event_types_t(freeswitchJNI.EventConsumer_e_event_id_get(swigCPtr, this), true);
   }
 
-  public void setNode(SWIGTYPE_p_switch_event_node_t value) {
-    freeswitchJNI.EventConsumer_node_set(swigCPtr, this, SWIGTYPE_p_switch_event_node_t.getCPtr(value));
-  }
-
-  public SWIGTYPE_p_switch_event_node_t getNode() {
-    long cPtr = freeswitchJNI.EventConsumer_node_get(swigCPtr, this);
-    return (cPtr == 0) ? null : new SWIGTYPE_p_switch_event_node_t(cPtr, false);
-  }
-
   public void setE_callback(String value) {
     freeswitchJNI.EventConsumer_e_callback_set(swigCPtr, this, value);
   }
@@ -84,20 +75,15 @@ public class EventConsumer {
   }
 
   public EventConsumer(String event_name, String subclass_name) {
-    this(freeswitchJNI.new_EventConsumer__SWIG_0(event_name, subclass_name), true);
+    this(freeswitchJNI.new_EventConsumer(event_name, subclass_name), true);
   }
 
-  public EventConsumer(String event_name) {
-    this(freeswitchJNI.new_EventConsumer__SWIG_1(event_name), true);
+  public int bind(String event_name, String subclass_name) {
+    return freeswitchJNI.EventConsumer_bind(swigCPtr, this, event_name, subclass_name);
   }
 
   public Event pop(int block) {
-    long cPtr = freeswitchJNI.EventConsumer_pop__SWIG_0(swigCPtr, this, block);
-    return (cPtr == 0) ? null : new Event(cPtr, true);
-  }
-
-  public Event pop() {
-    long cPtr = freeswitchJNI.EventConsumer_pop__SWIG_1(swigCPtr, this);
+    long cPtr = freeswitchJNI.EventConsumer_pop(swigCPtr, this, block);
     return (cPtr == 0) ? null : new Event(cPtr, true);
   }
 
diff --git a/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java b/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java
index 9c2b77a45a..c211873441 100644
--- a/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java
+++ b/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java
@@ -17,8 +17,7 @@ class freeswitchJNI {
   public final static native void IVRMenu_execute(long jarg1, IVRMenu jarg1_, long jarg2, CoreSession jarg2_, String jarg3);
   public final static native long new_API();
   public final static native void delete_API(long jarg1);
-  public final static native String API_execute__SWIG_0(long jarg1, API jarg1_, String jarg2, String jarg3);
-  public final static native String API_execute__SWIG_1(long jarg1, API jarg1_, String jarg2);
+  public final static native String API_execute(long jarg1, API jarg1_, String jarg2, String jarg3);
   public final static native String API_executeString(long jarg1, API jarg1_, String jarg2);
   public final static native String API_getTime(long jarg1, API jarg1_);
   public final static native void input_callback_state_t_function_set(long jarg1, input_callback_state_t jarg1_, long jarg2);
@@ -38,8 +37,7 @@ class freeswitchJNI {
   public final static native char DTMF_digit_get(long jarg1, DTMF jarg1_);
   public final static native void DTMF_duration_set(long jarg1, DTMF jarg1_, long jarg2);
   public final static native long DTMF_duration_get(long jarg1, DTMF jarg1_);
-  public final static native long new_DTMF__SWIG_0(char jarg1, long jarg2);
-  public final static native long new_DTMF__SWIG_1(char jarg1);
+  public final static native long new_DTMF(char jarg1, long jarg2);
   public final static native void delete_DTMF(long jarg1);
   public final static native long new_Stream__SWIG_0();
   public final static native long new_Stream__SWIG_1(long jarg1);
@@ -53,14 +51,10 @@ class freeswitchJNI {
   public final static native void Event_mine_set(long jarg1, Event jarg1_, int jarg2);
   public final static native int Event_mine_get(long jarg1, Event jarg1_);
   public final static native long new_Event__SWIG_0(String jarg1, String jarg2);
-  public final static native long new_Event__SWIG_1(String jarg1);
-  public final static native long new_Event__SWIG_2(long jarg1, int jarg2);
-  public final static native long new_Event__SWIG_3(long jarg1);
+  public final static native long new_Event__SWIG_1(long jarg1, int jarg2);
   public final static native void delete_Event(long jarg1);
-  public final static native String Event_serialize__SWIG_0(long jarg1, Event jarg1_, String jarg2);
-  public final static native String Event_serialize__SWIG_1(long jarg1, Event jarg1_);
-  public final static native boolean Event_setPriority__SWIG_0(long jarg1, Event jarg1_, long jarg2);
-  public final static native boolean Event_setPriority__SWIG_1(long jarg1, Event jarg1_);
+  public final static native String Event_serialize(long jarg1, Event jarg1_, String jarg2);
+  public final static native boolean Event_setPriority(long jarg1, Event jarg1_, long jarg2);
   public final static native String Event_getHeader(long jarg1, Event jarg1_, String jarg2);
   public final static native String Event_getBody(long jarg1, Event jarg1_);
   public final static native String Event_getType(long jarg1, Event jarg1_);
@@ -72,19 +66,16 @@ class freeswitchJNI {
   public final static native long EventConsumer_events_get(long jarg1, EventConsumer jarg1_);
   public final static native void EventConsumer_e_event_id_set(long jarg1, EventConsumer jarg1_, long jarg2);
   public final static native long EventConsumer_e_event_id_get(long jarg1, EventConsumer jarg1_);
-  public final static native void EventConsumer_node_set(long jarg1, EventConsumer jarg1_, long jarg2);
-  public final static native long EventConsumer_node_get(long jarg1, EventConsumer jarg1_);
   public final static native void EventConsumer_e_callback_set(long jarg1, EventConsumer jarg1_, String jarg2);
   public final static native String EventConsumer_e_callback_get(long jarg1, EventConsumer jarg1_);
   public final static native void EventConsumer_e_subclass_name_set(long jarg1, EventConsumer jarg1_, String jarg2);
   public final static native String EventConsumer_e_subclass_name_get(long jarg1, EventConsumer jarg1_);
   public final static native void EventConsumer_e_cb_arg_set(long jarg1, EventConsumer jarg1_, String jarg2);
   public final static native String EventConsumer_e_cb_arg_get(long jarg1, EventConsumer jarg1_);
-  public final static native long new_EventConsumer__SWIG_0(String jarg1, String jarg2);
-  public final static native long new_EventConsumer__SWIG_1(String jarg1);
+  public final static native long new_EventConsumer(String jarg1, String jarg2);
   public final static native void delete_EventConsumer(long jarg1);
-  public final static native long EventConsumer_pop__SWIG_0(long jarg1, EventConsumer jarg1_, int jarg2);
-  public final static native long EventConsumer_pop__SWIG_1(long jarg1, EventConsumer jarg1_);
+  public final static native int EventConsumer_bind(long jarg1, EventConsumer jarg1_, String jarg2, String jarg3);
+  public final static native long EventConsumer_pop(long jarg1, EventConsumer jarg1_, int jarg2);
   public final static native void delete_CoreSession(long jarg1);
   public final static native void CoreSession_session_set(long jarg1, CoreSession jarg1_, long jarg2);
   public final static native long CoreSession_session_get(long jarg1, CoreSession jarg1_);
@@ -108,28 +99,19 @@ class freeswitchJNI {
   public final static native String CoreSession_voice_name_get(long jarg1, CoreSession jarg1_);
   public final static native int CoreSession_answer(long jarg1, CoreSession jarg1_);
   public final static native int CoreSession_preAnswer(long jarg1, CoreSession jarg1_);
-  public final static native void CoreSession_hangup__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2);
-  public final static native void CoreSession_hangup__SWIG_1(long jarg1, CoreSession jarg1_);
+  public final static native void CoreSession_hangup(long jarg1, CoreSession jarg1_, String jarg2);
   public final static native void CoreSession_hangupState(long jarg1, CoreSession jarg1_);
   public final static native void CoreSession_setVariable(long jarg1, CoreSession jarg1_, String jarg2, String jarg3);
   public final static native void CoreSession_setPrivate(long jarg1, CoreSession jarg1_, String jarg2, long jarg3);
   public final static native long CoreSession_getPrivate(long jarg1, CoreSession jarg1_, String jarg2);
   public final static native String CoreSession_getVariable(long jarg1, CoreSession jarg1_, String jarg2);
   public final static native long CoreSession_process_callback_result(long jarg1, CoreSession jarg1_, String jarg2);
-  public final static native void CoreSession_say__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4, String jarg5, String jarg6);
-  public final static native void CoreSession_say__SWIG_1(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4, String jarg5);
-  public final static native void CoreSession_sayPhrase__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4);
-  public final static native void CoreSession_sayPhrase__SWIG_1(long jarg1, CoreSession jarg1_, String jarg2, String jarg3);
-  public final static native void CoreSession_sayPhrase__SWIG_2(long jarg1, CoreSession jarg1_, String jarg2);
+  public final static native void CoreSession_say(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4, String jarg5, String jarg6);
+  public final static native void CoreSession_sayPhrase(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4);
   public final static native String CoreSession_hangupCause(long jarg1, CoreSession jarg1_);
   public final static native String CoreSession_getState(long jarg1, CoreSession jarg1_);
-  public final static native int CoreSession_recordFile__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2, int jarg3, int jarg4, int jarg5);
-  public final static native int CoreSession_recordFile__SWIG_1(long jarg1, CoreSession jarg1_, String jarg2, int jarg3, int jarg4);
-  public final static native int CoreSession_recordFile__SWIG_2(long jarg1, CoreSession jarg1_, String jarg2, int jarg3);
-  public final static native int CoreSession_recordFile__SWIG_3(long jarg1, CoreSession jarg1_, String jarg2);
-  public final static native int CoreSession_originate__SWIG_0(long jarg1, CoreSession jarg1_, long jarg2, CoreSession jarg2_, String jarg3, int jarg4, long jarg5);
-  public final static native int CoreSession_originate__SWIG_1(long jarg1, CoreSession jarg1_, long jarg2, CoreSession jarg2_, String jarg3, int jarg4);
-  public final static native int CoreSession_originate__SWIG_2(long jarg1, CoreSession jarg1_, long jarg2, CoreSession jarg2_, String jarg3);
+  public final static native int CoreSession_recordFile(long jarg1, CoreSession jarg1_, String jarg2, int jarg3, int jarg4, int jarg5);
+  public final static native int CoreSession_originate(long jarg1, CoreSession jarg1_, long jarg2, CoreSession jarg2_, String jarg3, int jarg4, long jarg5);
   public final static native void CoreSession_destroy(long jarg1, CoreSession jarg1_);
   public final static native void CoreSession_setDTMFCallback(long jarg1, CoreSession jarg1_, long jarg2, String jarg3);
   public final static native int CoreSession_speak(long jarg1, CoreSession jarg1_, String jarg2);
@@ -138,16 +120,11 @@ class freeswitchJNI {
   public final static native int CoreSession_collectDigits__SWIG_1(long jarg1, CoreSession jarg1_, int jarg2, int jarg3);
   public final static native String CoreSession_getDigits__SWIG_0(long jarg1, CoreSession jarg1_, int jarg2, String jarg3, int jarg4);
   public final static native String CoreSession_getDigits__SWIG_1(long jarg1, CoreSession jarg1_, int jarg2, String jarg3, int jarg4, int jarg5);
-  public final static native int CoreSession_transfer__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4);
-  public final static native int CoreSession_transfer__SWIG_1(long jarg1, CoreSession jarg1_, String jarg2, String jarg3);
-  public final static native int CoreSession_transfer__SWIG_2(long jarg1, CoreSession jarg1_, String jarg2);
+  public final static native int CoreSession_transfer(long jarg1, CoreSession jarg1_, String jarg2, String jarg3, String jarg4);
   public final static native String CoreSession_read(long jarg1, CoreSession jarg1_, int jarg2, int jarg3, String jarg4, int jarg5, String jarg6);
-  public final static native String CoreSession_playAndGetDigits__SWIG_0(long jarg1, CoreSession jarg1_, int jarg2, int jarg3, int jarg4, int jarg5, String jarg6, String jarg7, String jarg8, String jarg9, String jarg10);
-  public final static native String CoreSession_playAndGetDigits__SWIG_1(long jarg1, CoreSession jarg1_, int jarg2, int jarg3, int jarg4, int jarg5, String jarg6, String jarg7, String jarg8, String jarg9);
-  public final static native int CoreSession_streamFile__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2, int jarg3);
-  public final static native int CoreSession_streamFile__SWIG_1(long jarg1, CoreSession jarg1_, String jarg2);
-  public final static native int CoreSession_sleep__SWIG_0(long jarg1, CoreSession jarg1_, int jarg2, int jarg3);
-  public final static native int CoreSession_sleep__SWIG_1(long jarg1, CoreSession jarg1_, int jarg2);
+  public final static native String CoreSession_playAndGetDigits(long jarg1, CoreSession jarg1_, int jarg2, int jarg3, int jarg4, int jarg5, String jarg6, String jarg7, String jarg8, String jarg9, String jarg10);
+  public final static native int CoreSession_streamFile(long jarg1, CoreSession jarg1_, String jarg2, int jarg3);
+  public final static native int CoreSession_sleep(long jarg1, CoreSession jarg1_, int jarg2, int jarg3);
   public final static native int CoreSession_flushEvents(long jarg1, CoreSession jarg1_);
   public final static native int CoreSession_flushDigits(long jarg1, CoreSession jarg1_);
   public final static native int CoreSession_setAutoHangup(long jarg1, CoreSession jarg1_, boolean jarg2);
@@ -157,8 +134,7 @@ class freeswitchJNI {
   public final static native boolean CoreSession_answered(long jarg1, CoreSession jarg1_);
   public final static native boolean CoreSession_mediaReady(long jarg1, CoreSession jarg1_);
   public final static native void CoreSession_waitForAnswer(long jarg1, CoreSession jarg1_, long jarg2, CoreSession jarg2_);
-  public final static native void CoreSession_execute__SWIG_0(long jarg1, CoreSession jarg1_, String jarg2, String jarg3);
-  public final static native void CoreSession_execute__SWIG_1(long jarg1, CoreSession jarg1_, String jarg2);
+  public final static native void CoreSession_execute(long jarg1, CoreSession jarg1_, String jarg2, String jarg3);
   public final static native void CoreSession_sendEvent(long jarg1, CoreSession jarg1_, long jarg2, Event jarg2_);
   public final static native void CoreSession_setEventData(long jarg1, CoreSession jarg1_, long jarg2, Event jarg2_);
   public final static native String CoreSession_getXMLCDR(long jarg1, CoreSession jarg1_);
diff --git a/src/mod/languages/mod_java/switch_swig_wrap.cpp b/src/mod/languages/mod_java/switch_swig_wrap.cpp
index d2c3850461..163cf8b3e4 100644
--- a/src/mod/languages/mod_java/switch_swig_wrap.cpp
+++ b/src/mod/languages/mod_java/switch_swig_wrap.cpp
@@ -421,11 +421,11 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1API(JNIEn
 }
 
 
-SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_API_1execute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
+SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_API_1execute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
   jstring jresult = 0 ;
   API *arg1 = (API *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
   char *result = 0 ;
   
   (void)jenv;
@@ -450,28 +450,6 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_API_1execute_1
 }
 
 
-SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_API_1execute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
-  jstring jresult = 0 ;
-  API *arg1 = (API *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(API **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  result = (char *)(arg1)->execute((char const *)arg2);
-  if(result) jresult = jenv->NewStringUTF((const char *)result);
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  return jresult;
-}
-
-
 SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_API_1executeString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
   jstring jresult = 0 ;
   API *arg1 = (API *) 0 ;
@@ -760,10 +738,10 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_DTMF_1duration_1
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1DTMF_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jchar jarg1, jlong jarg2) {
+SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1DTMF(JNIEnv *jenv, jclass jcls, jchar jarg1, jlong jarg2) {
   jlong jresult = 0 ;
   char arg1 ;
-  uint32_t arg2 ;
+  uint32_t arg2 = (uint32_t) SWITCH_DEFAULT_DTMF_DURATION ;
   DTMF *result = 0 ;
   uint32_t *argp2 ;
   
@@ -782,20 +760,6 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1DTMF_1_1SWI
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1DTMF_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jchar jarg1) {
-  jlong jresult = 0 ;
-  char arg1 ;
-  DTMF *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  arg1 = (char)jarg1; 
-  result = (DTMF *)new DTMF(arg1);
-  *(DTMF **)&jresult = result; 
-  return jresult;
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1DTMF(JNIEnv *jenv, jclass jcls, jlong jarg1) {
   DTMF *arg1 = (DTMF *) 0 ;
   
@@ -979,7 +943,7 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1mine_1get(
 SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
   jlong jresult = 0 ;
   char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
   Event *result = 0 ;
   
   (void)jenv;
@@ -1002,29 +966,10 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SW
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
-  jlong jresult = 0 ;
-  char *arg1 = (char *) 0 ;
-  Event *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  arg1 = 0;
-  if (jarg1) {
-    arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
-    if (!arg1) return 0;
-  }
-  result = (Event *)new Event((char const *)arg1);
-  *(Event **)&jresult = result; 
-  if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
-  return jresult;
-}
-
-
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
+SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
   jlong jresult = 0 ;
   switch_event_t *arg1 = (switch_event_t *) 0 ;
-  int arg2 ;
+  int arg2 = (int) 0 ;
   Event *result = 0 ;
   
   (void)jenv;
@@ -1037,20 +982,6 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SW
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1) {
-  jlong jresult = 0 ;
-  switch_event_t *arg1 = (switch_event_t *) 0 ;
-  Event *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  arg1 = *(switch_event_t **)&jarg1; 
-  result = (Event *)new Event(arg1);
-  *(Event **)&jresult = result; 
-  return jresult;
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1Event(JNIEnv *jenv, jclass jcls, jlong jarg1) {
   Event *arg1 = (Event *) 0 ;
   
@@ -1062,10 +993,10 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1Event(JNI
 }
 
 
-SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1serialize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
+SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
   jstring jresult = 0 ;
   Event *arg1 = (Event *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
   char *result = 0 ;
   
   (void)jenv;
@@ -1084,25 +1015,10 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1seriali
 }
 
 
-SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1serialize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
-  jstring jresult = 0 ;
-  Event *arg1 = (Event *) 0 ;
-  char *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(Event **)&jarg1; 
-  result = (char *)(arg1)->serialize();
-  if(result) jresult = jenv->NewStringUTF((const char *)result);
-  return jresult;
-}
-
-
-SWIGEXPORT jboolean JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1setPriority_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
+SWIGEXPORT jboolean JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1setPriority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
   jboolean jresult = 0 ;
   Event *arg1 = (Event *) 0 ;
-  switch_priority_t arg2 ;
+  switch_priority_t arg2 = (switch_priority_t) SWITCH_PRIORITY_NORMAL ;
   bool result;
   switch_priority_t *argp2 ;
   
@@ -1122,21 +1038,6 @@ SWIGEXPORT jboolean JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1setPri
 }
 
 
-SWIGEXPORT jboolean JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1setPriority_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
-  jboolean jresult = 0 ;
-  Event *arg1 = (Event *) 0 ;
-  bool result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(Event **)&jarg1; 
-  result = (bool)(arg1)->setPriority();
-  jresult = (jboolean)result; 
-  return jresult;
-}
-
-
 SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_Event_1getHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
   jstring jresult = 0 ;
   Event *arg1 = (Event *) 0 ;
@@ -1341,35 +1242,6 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1e
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1node_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *arg2 = (switch_event_node_t *) 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(EventConsumer **)&jarg1; 
-  arg2 = *(switch_event_node_t **)&jarg2; 
-  if (arg1) (arg1)->node = arg2;
-  
-}
-
-
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1node_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
-  jlong jresult = 0 ;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(EventConsumer **)&jarg1; 
-  result = (switch_event_node_t *) ((arg1)->node);
-  *(switch_event_node_t **)&jresult = result; 
-  return jresult;
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1e_1callback_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *arg2 = (char *) 0 ;
@@ -1493,10 +1365,10 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1EventConsumer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
+SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1EventConsumer(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
   jlong jresult = 0 ;
-  char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg1 = (char *) NULL ;
+  char *arg2 = (char *) "" ;
   EventConsumer *result = 0 ;
   
   (void)jenv;
@@ -1519,25 +1391,6 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1EventConsum
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1EventConsumer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
-  jlong jresult = 0 ;
-  char *arg1 = (char *) 0 ;
-  EventConsumer *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  arg1 = 0;
-  if (jarg1) {
-    arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
-    if (!arg1) return 0;
-  }
-  result = (EventConsumer *)new EventConsumer((char const *)arg1);
-  *(EventConsumer **)&jresult = result; 
-  if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
-  return jresult;
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1EventConsumer(JNIEnv *jenv, jclass jcls, jlong jarg1) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   
@@ -1549,10 +1402,39 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1EventCons
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1pop_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
+SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1bind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
+  jint jresult = 0 ;
+  EventConsumer *arg1 = (EventConsumer *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  (void)jarg1_;
+  arg1 = *(EventConsumer **)&jarg1; 
+  arg2 = 0;
+  if (jarg2) {
+    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
+    if (!arg2) return 0;
+  }
+  arg3 = 0;
+  if (jarg3) {
+    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
+    if (!arg3) return 0;
+  }
+  result = (int)(arg1)->bind((char const *)arg2,(char const *)arg3);
+  jresult = (jint)result; 
+  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
+  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
+  return jresult;
+}
+
+
+SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1pop(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
   jlong jresult = 0 ;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
-  int arg2 ;
+  int arg2 = (int) 0 ;
   Event *result = 0 ;
   
   (void)jenv;
@@ -1566,21 +1448,6 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1p
 }
 
 
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1pop_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
-  jlong jresult = 0 ;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  Event *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(EventConsumer **)&jarg1; 
-  result = (Event *)(arg1)->pop();
-  *(Event **)&jresult = result; 
-  return jresult;
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_delete_1CoreSession(JNIEnv *jenv, jclass jcls, jlong jarg1) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   
@@ -1961,9 +1828,9 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1preA
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1hangup_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
+SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1hangup(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
   CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) "normal_clearing" ;
   
   (void)jenv;
   (void)jcls;
@@ -1979,17 +1846,6 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1hang
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1hangup_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  (arg1)->hangup();
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1hangupState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   
@@ -2112,13 +1968,13 @@ SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1pro
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1say_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jstring jarg5, jstring jarg6) {
+SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1say(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jstring jarg5, jstring jarg6) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   char *arg4 = (char *) 0 ;
   char *arg5 = (char *) 0 ;
-  char *arg6 = (char *) 0 ;
+  char *arg6 = (char *) NULL ;
   
   (void)jenv;
   (void)jcls;
@@ -2158,50 +2014,11 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1say_
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1say_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jstring jarg5) {
+SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sayPhrase(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
-  char *arg5 = (char *) 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return ;
-  }
-  arg3 = 0;
-  if (jarg3) {
-    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
-    if (!arg3) return ;
-  }
-  arg4 = 0;
-  if (jarg4) {
-    arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
-    if (!arg4) return ;
-  }
-  arg5 = 0;
-  if (jarg5) {
-    arg5 = (char *)jenv->GetStringUTFChars(jarg5, 0);
-    if (!arg5) return ;
-  }
-  (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
-  if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
-  if (arg5) jenv->ReleaseStringUTFChars(jarg5, (const char *)arg5);
-}
-
-
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sayPhrase_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  char *arg4 = (char *) NULL ;
   
   (void)jenv;
   (void)jcls;
@@ -2229,49 +2046,6 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sayP
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sayPhrase_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return ;
-  }
-  arg3 = 0;
-  if (jarg3) {
-    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
-    if (!arg3) return ;
-  }
-  (arg1)->sayPhrase((char const *)arg2,(char const *)arg3);
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
-}
-
-
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sayPhrase_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return ;
-  }
-  (arg1)->sayPhrase((char const *)arg2);
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-}
-
-
 SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1hangupCause(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
   jstring jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -2302,13 +2076,13 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1g
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1recordFile_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4, jint jarg5) {
+SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1recordFile(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4, jint jarg5) {
   jint jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
+  int arg3 = (int) 0 ;
+  int arg4 = (int) 0 ;
+  int arg5 = (int) 0 ;
   int result;
   
   (void)jenv;
@@ -2330,85 +2104,13 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1reco
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1recordFile_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int arg4 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  arg3 = (int)jarg3; 
-  arg4 = (int)jarg4; 
-  result = (int)(arg1)->recordFile(arg2,arg3,arg4);
-  jresult = (jint)result; 
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1recordFile_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  arg3 = (int)jarg3; 
-  result = (int)(arg1)->recordFile(arg2,arg3);
-  jresult = (jint)result; 
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1recordFile_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  result = (int)(arg1)->recordFile(arg2);
-  jresult = (jint)result; 
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1originate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jint jarg4, jlong jarg5) {
+SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1originate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jint jarg4, jlong jarg5) {
   jint jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
   CoreSession *arg2 = (CoreSession *) 0 ;
   char *arg3 = (char *) 0 ;
-  int arg4 ;
-  switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) 0 ;
+  int arg4 = (int) 60 ;
+  switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) NULL ;
   int result;
   
   (void)jenv;
@@ -2431,58 +2133,6 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1orig
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1originate_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jint jarg4) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  CoreSession *arg2 = (CoreSession *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int arg4 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  (void)jarg2_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = *(CoreSession **)&jarg2; 
-  arg3 = 0;
-  if (jarg3) {
-    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
-    if (!arg3) return 0;
-  }
-  arg4 = (int)jarg4; 
-  result = (int)(arg1)->originate(arg2,arg3,arg4);
-  jresult = (jint)result; 
-  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1originate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  CoreSession *arg2 = (CoreSession *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  (void)jarg2_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = *(CoreSession **)&jarg2; 
-  arg3 = 0;
-  if (jarg3) {
-    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
-    if (!arg3) return 0;
-  }
-  result = (int)(arg1)->originate(arg2,arg3);
-  jresult = (jint)result; 
-  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
-  return jresult;
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1destroy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   
@@ -2651,12 +2301,12 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1g
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1transfer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
+SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1transfer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
   jint jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
+  char *arg4 = (char *) NULL ;
   int result;
   
   (void)jenv;
@@ -2687,57 +2337,6 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1tran
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1transfer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  arg3 = 0;
-  if (jarg3) {
-    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
-    if (!arg3) return 0;
-  }
-  result = (int)(arg1)->transfer(arg2,arg3);
-  jresult = (jint)result; 
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1transfer_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  result = (int)(arg1)->transfer(arg2);
-  jresult = (jint)result; 
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  return jresult;
-}
-
-
 SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1read(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jstring jarg4, jint jarg5, jstring jarg6) {
   jstring jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -2773,7 +2372,7 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1r
 }
 
 
-SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1playAndGetDigits_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jstring jarg6, jstring jarg7, jstring jarg8, jstring jarg9, jstring jarg10) {
+SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1playAndGetDigits(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jstring jarg6, jstring jarg7, jstring jarg8, jstring jarg9, jstring jarg10) {
   jstring jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
@@ -2784,7 +2383,7 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1p
   char *arg7 = (char *) 0 ;
   char *arg8 = (char *) 0 ;
   char *arg9 = (char *) 0 ;
-  char *arg10 = (char *) 0 ;
+  char *arg10 = (char *) NULL ;
   char *result = 0 ;
   
   (void)jenv;
@@ -2831,62 +2430,11 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1p
 }
 
 
-SWIGEXPORT jstring JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1playAndGetDigits_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jstring jarg6, jstring jarg7, jstring jarg8, jstring jarg9) {
-  jstring jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  int arg2 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
-  char *arg6 = (char *) 0 ;
-  char *arg7 = (char *) 0 ;
-  char *arg8 = (char *) 0 ;
-  char *arg9 = (char *) 0 ;
-  char *result = 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = (int)jarg2; 
-  arg3 = (int)jarg3; 
-  arg4 = (int)jarg4; 
-  arg5 = (int)jarg5; 
-  arg6 = 0;
-  if (jarg6) {
-    arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0);
-    if (!arg6) return 0;
-  }
-  arg7 = 0;
-  if (jarg7) {
-    arg7 = (char *)jenv->GetStringUTFChars(jarg7, 0);
-    if (!arg7) return 0;
-  }
-  arg8 = 0;
-  if (jarg8) {
-    arg8 = (char *)jenv->GetStringUTFChars(jarg8, 0);
-    if (!arg8) return 0;
-  }
-  arg9 = 0;
-  if (jarg9) {
-    arg9 = (char *)jenv->GetStringUTFChars(jarg9, 0);
-    if (!arg9) return 0;
-  }
-  result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
-  if(result) jresult = jenv->NewStringUTF((const char *)result);
-  if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6);
-  if (arg7) jenv->ReleaseStringUTFChars(jarg7, (const char *)arg7);
-  if (arg8) jenv->ReleaseStringUTFChars(jarg8, (const char *)arg8);
-  if (arg9) jenv->ReleaseStringUTFChars(jarg9, (const char *)arg9);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1streamFile_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
+SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1streamFile(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
   jint jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  int arg3 ;
+  int arg3 = (int) 0 ;
   int result;
   
   (void)jenv;
@@ -2906,33 +2454,11 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1stre
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1streamFile_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return 0;
-  }
-  result = (int)(arg1)->streamFile(arg2);
-  jresult = (jint)result; 
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-  return jresult;
-}
-
-
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sleep_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
+SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sleep(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
   jint jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
-  int arg3 ;
+  int arg3 = (int) 0 ;
   int result;
   
   (void)jenv;
@@ -2947,23 +2473,6 @@ SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1slee
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sleep_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
-  jint jresult = 0 ;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  int arg2 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = (int)jarg2; 
-  result = (int)(arg1)->sleep(arg2);
-  jresult = (jint)result; 
-  return jresult;
-}
-
-
 SWIGEXPORT jint JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1flushEvents(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
   jint jresult = 0 ;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -3098,10 +2607,10 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1wait
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1execute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
+SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1execute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
   
   (void)jenv;
   (void)jcls;
@@ -3123,24 +2632,6 @@ SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1exec
 }
 
 
-SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1execute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  
-  (void)jenv;
-  (void)jcls;
-  (void)jarg1_;
-  arg1 = *(CoreSession **)&jarg1; 
-  arg2 = 0;
-  if (jarg2) {
-    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
-    if (!arg2) return ;
-  }
-  (arg1)->execute((char const *)arg2);
-  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
-}
-
-
 SWIGEXPORT void JNICALL Java_org_freeswitch_swig_freeswitchJNI_CoreSession_1sendEvent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   Event *arg2 = (Event *) 0 ;
diff --git a/src/mod/languages/mod_lua/mod_lua_wrap.cpp b/src/mod/languages/mod_lua/mod_lua_wrap.cpp
index c0446fe4cb..247b4076f2 100644
--- a/src/mod/languages/mod_lua/mod_lua_wrap.cpp
+++ b/src/mod/languages/mod_lua/mod_lua_wrap.cpp
@@ -1499,20 +1499,19 @@ SWIG_Lua_dostring(lua_State *L, const char* str) {
 #define SWIGTYPE_p_switch_channel_state_t swig_types[12]
 #define SWIGTYPE_p_switch_channel_t swig_types[13]
 #define SWIGTYPE_p_switch_core_session_t swig_types[14]
-#define SWIGTYPE_p_switch_event_node_t swig_types[15]
-#define SWIGTYPE_p_switch_event_t swig_types[16]
-#define SWIGTYPE_p_switch_event_types_t swig_types[17]
-#define SWIGTYPE_p_switch_input_args_t swig_types[18]
-#define SWIGTYPE_p_switch_input_type_t swig_types[19]
-#define SWIGTYPE_p_switch_priority_t swig_types[20]
-#define SWIGTYPE_p_switch_queue_t swig_types[21]
-#define SWIGTYPE_p_switch_state_handler_table_t swig_types[22]
-#define SWIGTYPE_p_switch_status_t swig_types[23]
-#define SWIGTYPE_p_switch_stream_handle_t swig_types[24]
-#define SWIGTYPE_p_uint32_t swig_types[25]
-#define SWIGTYPE_p_void swig_types[26]
-static swig_type_info *swig_types[28];
-static swig_module_info swig_module = {swig_types, 27, 0, 0, 0, 0};
+#define SWIGTYPE_p_switch_event_t swig_types[15]
+#define SWIGTYPE_p_switch_event_types_t swig_types[16]
+#define SWIGTYPE_p_switch_input_args_t swig_types[17]
+#define SWIGTYPE_p_switch_input_type_t swig_types[18]
+#define SWIGTYPE_p_switch_priority_t swig_types[19]
+#define SWIGTYPE_p_switch_queue_t swig_types[20]
+#define SWIGTYPE_p_switch_state_handler_table_t swig_types[21]
+#define SWIGTYPE_p_switch_status_t swig_types[22]
+#define SWIGTYPE_p_switch_stream_handle_t swig_types[23]
+#define SWIGTYPE_p_uint32_t swig_types[24]
+#define SWIGTYPE_p_void swig_types[25]
+static swig_type_info *swig_types[27];
+static swig_module_info swig_module = {swig_types, 26, 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)
 
@@ -1801,24 +1800,26 @@ fail:
 }
 
 
-static int _wrap_API_execute__SWIG_0(lua_State* L) {
+static int _wrap_API_execute(lua_State* L) {
   int SWIG_arg = -1;
   API *arg1 = (API *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
   char *result = 0 ;
   
-  SWIG_check_num_args("execute",3,3)
+  SWIG_check_num_args("execute",2,3)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"API *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("execute",2,"char const *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_API,0))){
     SWIG_fail_ptr("API_execute",1,SWIGTYPE_p_API);
   }
   
   arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
+  if(lua_gettop(L)>=3){
+    arg3 = (char *)lua_tostring(L, 3);
+  }
   result = (char *)(arg1)->execute((char const *)arg2,(char const *)arg3);
   SWIG_arg=0;
   lua_pushstring(L,(const char*)result); SWIG_arg++;
@@ -1832,90 +1833,6 @@ fail:
 }
 
 
-static int _wrap_API_execute__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  API *arg1 = (API *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *result = 0 ;
-  
-  SWIG_check_num_args("execute",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"API *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("execute",2,"char const *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_API,0))){
-    SWIG_fail_ptr("API_execute",1,SWIGTYPE_p_API);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  result = (char *)(arg1)->execute((char const *)arg2);
-  SWIG_arg=0;
-  lua_pushstring(L,(const char*)result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_API_execute(lua_State* L) {
-  int argc;
-  int argv[4]={
-    1,2,3,4
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_API, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_API_execute__SWIG_1(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_API, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_API_execute__SWIG_0(L);
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'API_execute'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_API_executeString(lua_State* L) {
   int SWIG_arg = -1;
   API *arg1 = (API *) 0 ;
@@ -2381,23 +2298,23 @@ fail:
 }
 
 
-static int _wrap_new_DTMF__SWIG_0(lua_State* L) {
+static int _wrap_new_DTMF(lua_State* L) {
   int SWIG_arg = -1;
   char arg1 ;
-  uint32_t arg2 ;
+  uint32_t arg2 = (uint32_t) SWITCH_DEFAULT_DTMF_DURATION ;
   DTMF *result = 0 ;
   uint32_t *argp2 ;
   
-  SWIG_check_num_args("DTMF",2,2)
+  SWIG_check_num_args("DTMF",1,2)
   if(!lua_isstring(L,1)) SWIG_fail_arg("DTMF",1,"char");
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg("DTMF",2,"uint32_t");
+  if(lua_gettop(L)>=2 && !lua_isuserdata(L,2)) SWIG_fail_arg("DTMF",2,"uint32_t");
   arg1 = (lua_tostring(L, 1))[0];
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){
-    SWIG_fail_ptr("new_DTMF",2,SWIGTYPE_p_uint32_t);
+  if(lua_gettop(L)>=2){
+    if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){
+      SWIG_fail_ptr("new_DTMF",2,SWIGTYPE_p_uint32_t);
+    }
+    arg2 = *argp2;
   }
-  arg2 = *argp2;
-  
   result = (DTMF *)new DTMF(arg1,arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_DTMF,1); SWIG_arg++; 
@@ -2411,68 +2328,6 @@ fail:
 }
 
 
-static int _wrap_new_DTMF__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  char arg1 ;
-  DTMF *result = 0 ;
-  
-  SWIG_check_num_args("DTMF",1,1)
-  if(!lua_isstring(L,1)) SWIG_fail_arg("DTMF",1,"char");
-  arg1 = (lua_tostring(L, 1))[0];
-  result = (DTMF *)new DTMF(arg1);
-  SWIG_arg=0;
-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_DTMF,1); SWIG_arg++; 
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_new_DTMF(lua_State* L) {
-  int argc;
-  int argv[3]={
-    1,2,3
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 1) {
-    int _v;
-    {
-      _v = lua_isstring(L,argv[0]) && (lua_strlen(L,argv[0])==1);
-    }
-    if (_v) {
-      return _wrap_new_DTMF__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = lua_isstring(L,argv[0]) && (lua_strlen(L,argv[0])==1);
-    }
-    if (_v) {
-      {
-        void *ptr;
-        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint32_t, 0)) {
-          _v = 0;
-        } else {
-          _v = 1;
-        }
-      }
-      if (_v) {
-        return _wrap_new_DTMF__SWIG_0(L);
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'new_DTMF'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_delete_DTMF(lua_State* L) {
   int SWIG_arg = -1;
   DTMF *arg1 = (DTMF *) 0 ;
@@ -2853,14 +2708,16 @@ fail:
 static int _wrap_new_Event__SWIG_0(lua_State* L) {
   int SWIG_arg = -1;
   char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
   Event *result = 0 ;
   
-  SWIG_check_num_args("Event",2,2)
+  SWIG_check_num_args("Event",1,2)
   if(!lua_isstring(L,1)) SWIG_fail_arg("Event",1,"char const *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("Event",2,"char const *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("Event",2,"char const *");
   arg1 = (char *)lua_tostring(L, 1);
-  arg2 = (char *)lua_tostring(L, 2);
+  if(lua_gettop(L)>=2){
+    arg2 = (char *)lua_tostring(L, 2);
+  }
   result = (Event *)new Event((char const *)arg1,(char const *)arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
@@ -2875,41 +2732,22 @@ fail:
 
 
 static int _wrap_new_Event__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  char *arg1 = (char *) 0 ;
-  Event *result = 0 ;
-  
-  SWIG_check_num_args("Event",1,1)
-  if(!lua_isstring(L,1)) SWIG_fail_arg("Event",1,"char const *");
-  arg1 = (char *)lua_tostring(L, 1);
-  result = (Event *)new Event((char const *)arg1);
-  SWIG_arg=0;
-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_new_Event__SWIG_2(lua_State* L) {
   int SWIG_arg = -1;
   switch_event_t *arg1 = (switch_event_t *) 0 ;
-  int arg2 ;
+  int arg2 = (int) 0 ;
   Event *result = 0 ;
   
-  SWIG_check_num_args("Event",2,2)
+  SWIG_check_num_args("Event",1,2)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Event",1,"switch_event_t *");
-  if(!lua_isnumber(L,2)) SWIG_fail_arg("Event",2,"int");
+  if(lua_gettop(L)>=2 && !lua_isnumber(L,2)) SWIG_fail_arg("Event",2,"int");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_event_t,0))){
     SWIG_fail_ptr("new_Event",1,SWIGTYPE_p_switch_event_t);
   }
   
-  arg2 = (int)lua_tonumber(L, 2);
+  if(lua_gettop(L)>=2){
+    arg2 = (int)lua_tonumber(L, 2);
+  }
   result = (Event *)new Event(arg1,arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
@@ -2923,31 +2761,6 @@ fail:
 }
 
 
-static int _wrap_new_Event__SWIG_3(lua_State* L) {
-  int SWIG_arg = -1;
-  switch_event_t *arg1 = (switch_event_t *) 0 ;
-  Event *result = 0 ;
-  
-  SWIG_check_num_args("Event",1,1)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Event",1,"switch_event_t *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_event_t,0))){
-    SWIG_fail_ptr("new_Event",1,SWIGTYPE_p_switch_event_t);
-  }
-  
-  result = (Event *)new Event(arg1);
-  SWIG_arg=0;
-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
 static int _wrap_new_Event(lua_State* L) {
   int argc;
   int argv[3]={
@@ -2955,7 +2768,7 @@ static int _wrap_new_Event(lua_State* L) {
   };
   
   argc = lua_gettop(L);
-  if (argc == 1) {
+  if ((argc >= 1) && (argc <= 2)) {
     int _v;
     {
       void *ptr;
@@ -2966,43 +2779,26 @@ static int _wrap_new_Event(lua_State* L) {
       }
     }
     if (_v) {
-      return _wrap_new_Event__SWIG_3(L);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = lua_isstring(L,argv[0]);
-    }
-    if (_v) {
-      return _wrap_new_Event__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_event_t, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
+      if (argc <= 1) {
+        return _wrap_new_Event__SWIG_1(L);
       }
-    }
-    if (_v) {
       {
         _v = lua_isnumber(L,argv[1]);
       }
       if (_v) {
-        return _wrap_new_Event__SWIG_2(L);
+        return _wrap_new_Event__SWIG_1(L);
       }
     }
   }
-  if (argc == 2) {
+  if ((argc >= 1) && (argc <= 2)) {
     int _v;
     {
       _v = lua_isstring(L,argv[0]);
     }
     if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_Event__SWIG_0(L);
+      }
       {
         _v = lua_isstring(L,argv[1]);
       }
@@ -3042,21 +2838,23 @@ fail:
 }
 
 
-static int _wrap_Event_serialize__SWIG_0(lua_State* L) {
+static int _wrap_Event_serialize(lua_State* L) {
   int SWIG_arg = -1;
   Event *arg1 = (Event *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
   char *result = 0 ;
   
-  SWIG_check_num_args("serialize",2,2)
+  SWIG_check_num_args("serialize",1,2)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("serialize",1,"Event *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("serialize",2,"char const *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("serialize",2,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
     SWIG_fail_ptr("Event_serialize",1,SWIGTYPE_p_Event);
   }
   
-  arg2 = (char *)lua_tostring(L, 2);
+  if(lua_gettop(L)>=2){
+    arg2 = (char *)lua_tostring(L, 2);
+  }
   result = (char *)(arg1)->serialize((char const *)arg2);
   SWIG_arg=0;
   lua_pushstring(L,(const char*)result); SWIG_arg++;
@@ -3070,98 +2868,27 @@ fail:
 }
 
 
-static int _wrap_Event_serialize__SWIG_1(lua_State* L) {
+static int _wrap_Event_setPriority(lua_State* L) {
   int SWIG_arg = -1;
   Event *arg1 = (Event *) 0 ;
-  char *result = 0 ;
-  
-  SWIG_check_num_args("serialize",1,1)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("serialize",1,"Event *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
-    SWIG_fail_ptr("Event_serialize",1,SWIGTYPE_p_Event);
-  }
-  
-  result = (char *)(arg1)->serialize();
-  SWIG_arg=0;
-  lua_pushstring(L,(const char*)result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_Event_serialize(lua_State* L) {
-  int argc;
-  int argv[3]={
-    1,2,3
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 1) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Event, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      return _wrap_Event_serialize__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Event, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_Event_serialize__SWIG_0(L);
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'Event_serialize'");
-  lua_error(L);return 0;
-}
-
-
-static int _wrap_Event_setPriority__SWIG_0(lua_State* L) {
-  int SWIG_arg = -1;
-  Event *arg1 = (Event *) 0 ;
-  switch_priority_t arg2 ;
+  switch_priority_t arg2 = (switch_priority_t) SWITCH_PRIORITY_NORMAL ;
   bool result;
   switch_priority_t *argp2 ;
   
-  SWIG_check_num_args("setPriority",2,2)
+  SWIG_check_num_args("setPriority",1,2)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setPriority",1,"Event *");
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg("setPriority",2,"switch_priority_t");
+  if(lua_gettop(L)>=2 && !lua_isuserdata(L,2)) SWIG_fail_arg("setPriority",2,"switch_priority_t");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
     SWIG_fail_ptr("Event_setPriority",1,SWIGTYPE_p_Event);
   }
   
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_switch_priority_t,0))){
-    SWIG_fail_ptr("Event_setPriority",2,SWIGTYPE_p_switch_priority_t);
+  if(lua_gettop(L)>=2){
+    if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_switch_priority_t,0))){
+      SWIG_fail_ptr("Event_setPriority",2,SWIGTYPE_p_switch_priority_t);
+    }
+    arg2 = *argp2;
   }
-  arg2 = *argp2;
-  
   result = (bool)(arg1)->setPriority(arg2);
   SWIG_arg=0;
   lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
@@ -3175,82 +2902,6 @@ fail:
 }
 
 
-static int _wrap_Event_setPriority__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  Event *arg1 = (Event *) 0 ;
-  bool result;
-  
-  SWIG_check_num_args("setPriority",1,1)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setPriority",1,"Event *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
-    SWIG_fail_ptr("Event_setPriority",1,SWIGTYPE_p_Event);
-  }
-  
-  result = (bool)(arg1)->setPriority();
-  SWIG_arg=0;
-  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_Event_setPriority(lua_State* L) {
-  int argc;
-  int argv[3]={
-    1,2,3
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 1) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Event, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      return _wrap_Event_setPriority__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Event, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        void *ptr;
-        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_switch_priority_t, 0)) {
-          _v = 0;
-        } else {
-          _v = 1;
-        }
-      }
-      if (_v) {
-        return _wrap_Event_setPriority__SWIG_0(L);
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'Event_setPriority'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_Event_getHeader(lua_State* L) {
   int SWIG_arg = -1;
   Event *arg1 = (Event *) 0 ;
@@ -3586,63 +3237,6 @@ fail:
 }
 
 
-static int _wrap_EventConsumer_node_set(lua_State* L) {
-  int SWIG_arg = -1;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *arg2 = (switch_event_node_t *) 0 ;
-  
-  SWIG_check_num_args("node",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("node",1,"EventConsumer *");
-  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("node",2,"switch_event_node_t *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
-    SWIG_fail_ptr("EventConsumer_node_set",1,SWIGTYPE_p_EventConsumer);
-  }
-  
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_switch_event_node_t,SWIG_POINTER_DISOWN))){
-    SWIG_fail_ptr("EventConsumer_node_set",2,SWIGTYPE_p_switch_event_node_t);
-  }
-  
-  if (arg1) (arg1)->node = arg2;
-  
-  SWIG_arg=0;
-  
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_EventConsumer_node_get(lua_State* L) {
-  int SWIG_arg = -1;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *result = 0 ;
-  
-  SWIG_check_num_args("node",1,1)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("node",1,"EventConsumer *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
-    SWIG_fail_ptr("EventConsumer_node_get",1,SWIGTYPE_p_EventConsumer);
-  }
-  
-  result = (switch_event_node_t *) ((arg1)->node);
-  SWIG_arg=0;
-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_switch_event_node_t,0); SWIG_arg++; 
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
 static int _wrap_EventConsumer_e_callback_set(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
@@ -3823,17 +3417,21 @@ fail:
 }
 
 
-static int _wrap_new_EventConsumer__SWIG_0(lua_State* L) {
+static int _wrap_new_EventConsumer(lua_State* L) {
   int SWIG_arg = -1;
-  char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg1 = (char *) NULL ;
+  char *arg2 = (char *) "" ;
   EventConsumer *result = 0 ;
   
-  SWIG_check_num_args("EventConsumer",2,2)
-  if(!lua_isstring(L,1)) SWIG_fail_arg("EventConsumer",1,"char const *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("EventConsumer",2,"char const *");
-  arg1 = (char *)lua_tostring(L, 1);
-  arg2 = (char *)lua_tostring(L, 2);
+  SWIG_check_num_args("EventConsumer",0,2)
+  if(lua_gettop(L)>=1 && !lua_isstring(L,1)) SWIG_fail_arg("EventConsumer",1,"char const *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("EventConsumer",2,"char const *");
+  if(lua_gettop(L)>=1){
+    arg1 = (char *)lua_tostring(L, 1);
+  }
+  if(lua_gettop(L)>=2){
+    arg2 = (char *)lua_tostring(L, 2);
+  }
   result = (EventConsumer *)new EventConsumer((char const *)arg1,(char const *)arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_EventConsumer,1); SWIG_arg++; 
@@ -3847,63 +3445,6 @@ fail:
 }
 
 
-static int _wrap_new_EventConsumer__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  char *arg1 = (char *) 0 ;
-  EventConsumer *result = 0 ;
-  
-  SWIG_check_num_args("EventConsumer",1,1)
-  if(!lua_isstring(L,1)) SWIG_fail_arg("EventConsumer",1,"char const *");
-  arg1 = (char *)lua_tostring(L, 1);
-  result = (EventConsumer *)new EventConsumer((char const *)arg1);
-  SWIG_arg=0;
-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_EventConsumer,1); SWIG_arg++; 
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_new_EventConsumer(lua_State* L) {
-  int argc;
-  int argv[3]={
-    1,2,3
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 1) {
-    int _v;
-    {
-      _v = lua_isstring(L,argv[0]);
-    }
-    if (_v) {
-      return _wrap_new_EventConsumer__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = lua_isstring(L,argv[0]);
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_new_EventConsumer__SWIG_0(L);
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'new_EventConsumer'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_delete_EventConsumer(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
@@ -3929,21 +3470,56 @@ fail:
 }
 
 
-static int _wrap_EventConsumer_pop__SWIG_0(lua_State* L) {
+static int _wrap_EventConsumer_bind(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
-  int arg2 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  int result;
+  
+  SWIG_check_num_args("bind",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("bind",1,"EventConsumer *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("bind",2,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("bind",3,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_bind",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  if(lua_gettop(L)>=3){
+    arg3 = (char *)lua_tostring(L, 3);
+  }
+  result = (int)(arg1)->bind((char const *)arg2,(char const *)arg3);
+  SWIG_arg=0;
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_EventConsumer_pop(lua_State* L) {
+  int SWIG_arg = -1;
+  EventConsumer *arg1 = (EventConsumer *) 0 ;
+  int arg2 = (int) 0 ;
   Event *result = 0 ;
   
-  SWIG_check_num_args("pop",2,2)
+  SWIG_check_num_args("pop",1,2)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pop",1,"EventConsumer *");
-  if(!lua_isnumber(L,2)) SWIG_fail_arg("pop",2,"int");
+  if(lua_gettop(L)>=2 && !lua_isnumber(L,2)) SWIG_fail_arg("pop",2,"int");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
     SWIG_fail_ptr("EventConsumer_pop",1,SWIGTYPE_p_EventConsumer);
   }
   
-  arg2 = (int)lua_tonumber(L, 2);
+  if(lua_gettop(L)>=2){
+    arg2 = (int)lua_tonumber(L, 2);
+  }
   result = (Event *)(arg1)->pop(arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
@@ -3957,89 +3533,18 @@ fail:
 }
 
 
-static int _wrap_EventConsumer_pop__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  Event *result = 0 ;
-  
-  SWIG_check_num_args("pop",1,1)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pop",1,"EventConsumer *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
-    SWIG_fail_ptr("EventConsumer_pop",1,SWIGTYPE_p_EventConsumer);
-  }
-  
-  result = (Event *)(arg1)->pop();
-  SWIG_arg=0;
-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_EventConsumer_pop(lua_State* L) {
-  int argc;
-  int argv[3]={
-    1,2,3
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 1) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_EventConsumer, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      return _wrap_EventConsumer_pop__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_EventConsumer, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isnumber(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_EventConsumer_pop__SWIG_0(L);
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'EventConsumer_pop'");
-  lua_error(L);return 0;
-}
-
-
 static void swig_delete_EventConsumer(void *obj) {
 EventConsumer *arg1 = (EventConsumer *) obj;
 delete arg1;
 }
 static swig_lua_method swig_EventConsumer_methods[] = {
+    {"bind", _wrap_EventConsumer_bind}, 
     {"pop", _wrap_EventConsumer_pop}, 
     {0,0}
 };
 static swig_lua_attribute swig_EventConsumer_attributes[] = {
     { "events", _wrap_EventConsumer_events_get, _wrap_EventConsumer_events_set},
     { "e_event_id", _wrap_EventConsumer_e_event_id_get, _wrap_EventConsumer_e_event_id_set},
-    { "node", _wrap_EventConsumer_node_get, _wrap_EventConsumer_node_set},
     { "e_callback", _wrap_EventConsumer_e_callback_get, _wrap_EventConsumer_e_callback_set},
     { "e_subclass_name", _wrap_EventConsumer_e_subclass_name_get, _wrap_EventConsumer_e_subclass_name_set},
     { "e_cb_arg", _wrap_EventConsumer_e_cb_arg_get, _wrap_EventConsumer_e_cb_arg_set},
@@ -4705,20 +4210,22 @@ fail:
 }
 
 
-static int _wrap_CoreSession_hangup__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_hangup(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) "normal_clearing" ;
   
-  SWIG_check_num_args("hangup",2,2)
+  SWIG_check_num_args("hangup",1,2)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("hangup",2,"char const *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("hangup",2,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_hangup",1,SWIGTYPE_p_CoreSession);
   }
   
-  arg2 = (char *)lua_tostring(L, 2);
+  if(lua_gettop(L)>=2){
+    arg2 = (char *)lua_tostring(L, 2);
+  }
   (arg1)->hangup((char const *)arg2);
   SWIG_arg=0;
   
@@ -4732,76 +4239,6 @@ fail:
 }
 
 
-static int _wrap_CoreSession_hangup__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  
-  SWIG_check_num_args("hangup",1,1)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup",1,"CoreSession *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_hangup",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  (arg1)->hangup();
-  SWIG_arg=0;
-  
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_hangup(lua_State* L) {
-  int argc;
-  int argv[3]={
-    1,2,3
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 1) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      return _wrap_CoreSession_hangup__SWIG_1(L);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_hangup__SWIG_0(L);
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_hangup'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_CoreSession_hangupState(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -4973,22 +4410,22 @@ fail:
 }
 
 
-static int _wrap_CoreSession_say__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_say(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   char *arg4 = (char *) 0 ;
   char *arg5 = (char *) 0 ;
-  char *arg6 = (char *) 0 ;
+  char *arg6 = (char *) NULL ;
   
-  SWIG_check_num_args("say",6,6)
+  SWIG_check_num_args("say",5,6)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("say",1,"CoreSession *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("say",2,"char const *");
   if(!lua_isstring(L,3)) SWIG_fail_arg("say",3,"char const *");
   if(!lua_isstring(L,4)) SWIG_fail_arg("say",4,"char const *");
   if(!lua_isstring(L,5)) SWIG_fail_arg("say",5,"char const *");
-  if(!lua_isstring(L,6)) SWIG_fail_arg("say",6,"char const *");
+  if(lua_gettop(L)>=6 && !lua_isstring(L,6)) SWIG_fail_arg("say",6,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_say",1,SWIGTYPE_p_CoreSession);
@@ -4998,7 +4435,9 @@ static int _wrap_CoreSession_say__SWIG_0(lua_State* L) {
   arg3 = (char *)lua_tostring(L, 3);
   arg4 = (char *)lua_tostring(L, 4);
   arg5 = (char *)lua_tostring(L, 5);
-  arg6 = (char *)lua_tostring(L, 6);
+  if(lua_gettop(L)>=6){
+    arg6 = (char *)lua_tostring(L, 6);
+  }
   (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6);
   SWIG_arg=0;
   
@@ -5012,148 +4451,30 @@ fail:
 }
 
 
-static int _wrap_CoreSession_say__SWIG_1(lua_State* L) {
+static int _wrap_CoreSession_sayPhrase(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
-  char *arg5 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  char *arg4 = (char *) NULL ;
   
-  SWIG_check_num_args("say",5,5)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("say",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("say",2,"char const *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("say",3,"char const *");
-  if(!lua_isstring(L,4)) SWIG_fail_arg("say",4,"char const *");
-  if(!lua_isstring(L,5)) SWIG_fail_arg("say",5,"char const *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_say",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
-  arg4 = (char *)lua_tostring(L, 4);
-  arg5 = (char *)lua_tostring(L, 5);
-  (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
-  SWIG_arg=0;
-  
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_say(lua_State* L) {
-  int argc;
-  int argv[7]={
-    1,2,3,4,5,6,7
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 5) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isstring(L,argv[3]);
-          }
-          if (_v) {
-            {
-              _v = lua_isstring(L,argv[4]);
-            }
-            if (_v) {
-              return _wrap_CoreSession_say__SWIG_1(L);
-            }
-          }
-        }
-      }
-    }
-  }
-  if (argc == 6) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isstring(L,argv[3]);
-          }
-          if (_v) {
-            {
-              _v = lua_isstring(L,argv[4]);
-            }
-            if (_v) {
-              {
-                _v = lua_isstring(L,argv[5]);
-              }
-              if (_v) {
-                return _wrap_CoreSession_say__SWIG_0(L);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_say'");
-  lua_error(L);return 0;
-}
-
-
-static int _wrap_CoreSession_sayPhrase__SWIG_0(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
-  
-  SWIG_check_num_args("sayPhrase",4,4)
+  SWIG_check_num_args("sayPhrase",2,4)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sayPhrase",1,"CoreSession *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("sayPhrase",2,"char const *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("sayPhrase",3,"char const *");
-  if(!lua_isstring(L,4)) SWIG_fail_arg("sayPhrase",4,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("sayPhrase",3,"char const *");
+  if(lua_gettop(L)>=4 && !lua_isstring(L,4)) SWIG_fail_arg("sayPhrase",4,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_sayPhrase",1,SWIGTYPE_p_CoreSession);
   }
   
   arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
-  arg4 = (char *)lua_tostring(L, 4);
+  if(lua_gettop(L)>=3){
+    arg3 = (char *)lua_tostring(L, 3);
+  }
+  if(lua_gettop(L)>=4){
+    arg4 = (char *)lua_tostring(L, 4);
+  }
   (arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
   SWIG_arg=0;
   
@@ -5167,148 +4488,6 @@ fail:
 }
 
 
-static int _wrap_CoreSession_sayPhrase__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  
-  SWIG_check_num_args("sayPhrase",3,3)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sayPhrase",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("sayPhrase",2,"char const *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("sayPhrase",3,"char const *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_sayPhrase",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
-  (arg1)->sayPhrase((char const *)arg2,(char const *)arg3);
-  SWIG_arg=0;
-  
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_sayPhrase__SWIG_2(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  
-  SWIG_check_num_args("sayPhrase",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sayPhrase",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("sayPhrase",2,"char const *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_sayPhrase",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  (arg1)->sayPhrase((char const *)arg2);
-  SWIG_arg=0;
-  
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_sayPhrase(lua_State* L) {
-  int argc;
-  int argv[5]={
-    1,2,3,4,5
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_sayPhrase__SWIG_2(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_sayPhrase__SWIG_1(L);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isstring(L,argv[3]);
-          }
-          if (_v) {
-            return _wrap_CoreSession_sayPhrase__SWIG_0(L);
-          }
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_sayPhrase'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_CoreSession_hangupCause(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -5359,30 +4538,36 @@ fail:
 }
 
 
-static int _wrap_CoreSession_recordFile__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_recordFile(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
+  int arg3 = (int) 0 ;
+  int arg4 = (int) 0 ;
+  int arg5 = (int) 0 ;
   int result;
   
-  SWIG_check_num_args("recordFile",5,5)
+  SWIG_check_num_args("recordFile",2,5)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("recordFile",1,"CoreSession *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("recordFile",2,"char *");
-  if(!lua_isnumber(L,3)) SWIG_fail_arg("recordFile",3,"int");
-  if(!lua_isnumber(L,4)) SWIG_fail_arg("recordFile",4,"int");
-  if(!lua_isnumber(L,5)) SWIG_fail_arg("recordFile",5,"int");
+  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("recordFile",3,"int");
+  if(lua_gettop(L)>=4 && !lua_isnumber(L,4)) SWIG_fail_arg("recordFile",4,"int");
+  if(lua_gettop(L)>=5 && !lua_isnumber(L,5)) SWIG_fail_arg("recordFile",5,"int");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_recordFile",1,SWIGTYPE_p_CoreSession);
   }
   
   arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (int)lua_tonumber(L, 3);
-  arg4 = (int)lua_tonumber(L, 4);
-  arg5 = (int)lua_tonumber(L, 5);
+  if(lua_gettop(L)>=3){
+    arg3 = (int)lua_tonumber(L, 3);
+  }
+  if(lua_gettop(L)>=4){
+    arg4 = (int)lua_tonumber(L, 4);
+  }
+  if(lua_gettop(L)>=5){
+    arg5 = (int)lua_tonumber(L, 5);
+  }
   result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
@@ -5396,233 +4581,21 @@ fail:
 }
 
 
-static int _wrap_CoreSession_recordFile__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int arg4 ;
-  int result;
-  
-  SWIG_check_num_args("recordFile",4,4)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("recordFile",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("recordFile",2,"char *");
-  if(!lua_isnumber(L,3)) SWIG_fail_arg("recordFile",3,"int");
-  if(!lua_isnumber(L,4)) SWIG_fail_arg("recordFile",4,"int");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_recordFile",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (int)lua_tonumber(L, 3);
-  arg4 = (int)lua_tonumber(L, 4);
-  result = (int)(arg1)->recordFile(arg2,arg3,arg4);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_recordFile__SWIG_2(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int result;
-  
-  SWIG_check_num_args("recordFile",3,3)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("recordFile",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("recordFile",2,"char *");
-  if(!lua_isnumber(L,3)) SWIG_fail_arg("recordFile",3,"int");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_recordFile",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (int)lua_tonumber(L, 3);
-  result = (int)(arg1)->recordFile(arg2,arg3);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_recordFile__SWIG_3(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  
-  SWIG_check_num_args("recordFile",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("recordFile",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("recordFile",2,"char *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_recordFile",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  result = (int)(arg1)->recordFile(arg2);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_recordFile(lua_State* L) {
-  int argc;
-  int argv[6]={
-    1,2,3,4,5,6
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_recordFile__SWIG_3(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_recordFile__SWIG_2(L);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isnumber(L,argv[3]);
-          }
-          if (_v) {
-            return _wrap_CoreSession_recordFile__SWIG_1(L);
-          }
-        }
-      }
-    }
-  }
-  if (argc == 5) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isnumber(L,argv[3]);
-          }
-          if (_v) {
-            {
-              _v = lua_isnumber(L,argv[4]);
-            }
-            if (_v) {
-              return _wrap_CoreSession_recordFile__SWIG_0(L);
-            }
-          }
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_recordFile'");
-  lua_error(L);return 0;
-}
-
-
-static int _wrap_CoreSession_originate__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_originate(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   CoreSession *arg2 = (CoreSession *) 0 ;
   char *arg3 = (char *) 0 ;
-  int arg4 ;
-  switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) 0 ;
+  int arg4 = (int) 60 ;
+  switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) NULL ;
   int result;
   
-  SWIG_check_num_args("originate",5,5)
+  SWIG_check_num_args("originate",3,5)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("originate",1,"CoreSession *");
   if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("originate",2,"CoreSession *");
   if(!lua_isstring(L,3)) SWIG_fail_arg("originate",3,"char *");
-  if(!lua_isnumber(L,4)) SWIG_fail_arg("originate",4,"int");
-  if(!SWIG_isptrtype(L,5)) SWIG_fail_arg("originate",5,"switch_state_handler_table_t *");
+  if(lua_gettop(L)>=4 && !lua_isnumber(L,4)) SWIG_fail_arg("originate",4,"int");
+  if(lua_gettop(L)>=5 && !SWIG_isptrtype(L,5)) SWIG_fail_arg("originate",5,"switch_state_handler_table_t *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_originate",1,SWIGTYPE_p_CoreSession);
@@ -5634,12 +4607,14 @@ static int _wrap_CoreSession_originate__SWIG_0(lua_State* L) {
   }
   
   arg3 = (char *)lua_tostring(L, 3);
-  arg4 = (int)lua_tonumber(L, 4);
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_switch_state_handler_table_t,0))){
-    SWIG_fail_ptr("CoreSession_originate",5,SWIGTYPE_p_switch_state_handler_table_t);
+  if(lua_gettop(L)>=4){
+    arg4 = (int)lua_tonumber(L, 4);
+  }
+  if(lua_gettop(L)>=5){
+    if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_switch_state_handler_table_t,0))){
+      SWIG_fail_ptr("CoreSession_originate",5,SWIGTYPE_p_switch_state_handler_table_t);
+    }
   }
-  
   result = (int)(arg1)->originate(arg2,arg3,arg4,arg5);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
@@ -5653,199 +4628,6 @@ fail:
 }
 
 
-static int _wrap_CoreSession_originate__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  CoreSession *arg2 = (CoreSession *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int arg4 ;
-  int result;
-  
-  SWIG_check_num_args("originate",4,4)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("originate",1,"CoreSession *");
-  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("originate",2,"CoreSession *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("originate",3,"char *");
-  if(!lua_isnumber(L,4)) SWIG_fail_arg("originate",4,"int");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_originate",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_originate",2,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg3 = (char *)lua_tostring(L, 3);
-  arg4 = (int)lua_tonumber(L, 4);
-  result = (int)(arg1)->originate(arg2,arg3,arg4);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_originate__SWIG_2(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  CoreSession *arg2 = (CoreSession *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int result;
-  
-  SWIG_check_num_args("originate",3,3)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("originate",1,"CoreSession *");
-  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("originate",2,"CoreSession *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("originate",3,"char *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_originate",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_originate",2,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg3 = (char *)lua_tostring(L, 3);
-  result = (int)(arg1)->originate(arg2,arg3);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_originate(lua_State* L) {
-  int argc;
-  int argv[6]={
-    1,2,3,4,5,6
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        void *ptr;
-        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-          _v = 0;
-        } else {
-          _v = 1;
-        }
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_originate__SWIG_2(L);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        void *ptr;
-        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-          _v = 0;
-        } else {
-          _v = 1;
-        }
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isnumber(L,argv[3]);
-          }
-          if (_v) {
-            return _wrap_CoreSession_originate__SWIG_1(L);
-          }
-        }
-      }
-    }
-  }
-  if (argc == 5) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        void *ptr;
-        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-          _v = 0;
-        } else {
-          _v = 1;
-        }
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isnumber(L,argv[3]);
-          }
-          if (_v) {
-            {
-              void *ptr;
-              if (SWIG_isptrtype(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_switch_state_handler_table_t, 0)) {
-                _v = 0;
-              } else {
-                _v = 1;
-              }
-            }
-            if (_v) {
-              return _wrap_CoreSession_originate__SWIG_0(L);
-            }
-          }
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_originate'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_CoreSession_destroy(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -6220,27 +5002,31 @@ static int _wrap_CoreSession_getDigits(lua_State* L) {
 }
 
 
-static int _wrap_CoreSession_transfer__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_transfer(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
+  char *arg4 = (char *) NULL ;
   int result;
   
-  SWIG_check_num_args("transfer",4,4)
+  SWIG_check_num_args("transfer",2,4)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("transfer",1,"CoreSession *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("transfer",2,"char *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("transfer",3,"char *");
-  if(!lua_isstring(L,4)) SWIG_fail_arg("transfer",4,"char *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("transfer",3,"char *");
+  if(lua_gettop(L)>=4 && !lua_isstring(L,4)) SWIG_fail_arg("transfer",4,"char *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_transfer",1,SWIGTYPE_p_CoreSession);
   }
   
   arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
-  arg4 = (char *)lua_tostring(L, 4);
+  if(lua_gettop(L)>=3){
+    arg3 = (char *)lua_tostring(L, 3);
+  }
+  if(lua_gettop(L)>=4){
+    arg4 = (char *)lua_tostring(L, 4);
+  }
   result = (int)(arg1)->transfer(arg2,arg3,arg4);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
@@ -6254,150 +5040,6 @@ fail:
 }
 
 
-static int _wrap_CoreSession_transfer__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int result;
-  
-  SWIG_check_num_args("transfer",3,3)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("transfer",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("transfer",2,"char *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("transfer",3,"char *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_transfer",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
-  result = (int)(arg1)->transfer(arg2,arg3);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_transfer__SWIG_2(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  
-  SWIG_check_num_args("transfer",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("transfer",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("transfer",2,"char *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_transfer",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  result = (int)(arg1)->transfer(arg2);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_transfer(lua_State* L) {
-  int argc;
-  int argv[5]={
-    1,2,3,4,5
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_transfer__SWIG_2(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_transfer__SWIG_1(L);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isstring(L,argv[3]);
-          }
-          if (_v) {
-            return _wrap_CoreSession_transfer__SWIG_0(L);
-          }
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_transfer'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_CoreSession_read(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -6438,7 +5080,7 @@ fail:
 }
 
 
-static int _wrap_CoreSession_playAndGetDigits__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_playAndGetDigits(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
@@ -6449,10 +5091,10 @@ static int _wrap_CoreSession_playAndGetDigits__SWIG_0(lua_State* L) {
   char *arg7 = (char *) 0 ;
   char *arg8 = (char *) 0 ;
   char *arg9 = (char *) 0 ;
-  char *arg10 = (char *) 0 ;
+  char *arg10 = (char *) NULL ;
   char *result = 0 ;
   
-  SWIG_check_num_args("playAndGetDigits",10,10)
+  SWIG_check_num_args("playAndGetDigits",9,10)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("playAndGetDigits",1,"CoreSession *");
   if(!lua_isnumber(L,2)) SWIG_fail_arg("playAndGetDigits",2,"int");
   if(!lua_isnumber(L,3)) SWIG_fail_arg("playAndGetDigits",3,"int");
@@ -6462,7 +5104,7 @@ static int _wrap_CoreSession_playAndGetDigits__SWIG_0(lua_State* L) {
   if(!lua_isstring(L,7)) SWIG_fail_arg("playAndGetDigits",7,"char *");
   if(!lua_isstring(L,8)) SWIG_fail_arg("playAndGetDigits",8,"char *");
   if(!lua_isstring(L,9)) SWIG_fail_arg("playAndGetDigits",9,"char *");
-  if(!lua_isstring(L,10)) SWIG_fail_arg("playAndGetDigits",10,"char const *");
+  if(lua_gettop(L)>=10 && !lua_isstring(L,10)) SWIG_fail_arg("playAndGetDigits",10,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_playAndGetDigits",1,SWIGTYPE_p_CoreSession);
@@ -6476,7 +5118,9 @@ static int _wrap_CoreSession_playAndGetDigits__SWIG_0(lua_State* L) {
   arg7 = (char *)lua_tostring(L, 7);
   arg8 = (char *)lua_tostring(L, 8);
   arg9 = (char *)lua_tostring(L, 9);
-  arg10 = (char *)lua_tostring(L, 10);
+  if(lua_gettop(L)>=10){
+    arg10 = (char *)lua_tostring(L, 10);
+  }
   result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
   SWIG_arg=0;
   lua_pushstring(L,(const char*)result); SWIG_arg++;
@@ -6490,199 +5134,26 @@ fail:
 }
 
 
-static int _wrap_CoreSession_playAndGetDigits__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  int arg2 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
-  char *arg6 = (char *) 0 ;
-  char *arg7 = (char *) 0 ;
-  char *arg8 = (char *) 0 ;
-  char *arg9 = (char *) 0 ;
-  char *result = 0 ;
-  
-  SWIG_check_num_args("playAndGetDigits",9,9)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("playAndGetDigits",1,"CoreSession *");
-  if(!lua_isnumber(L,2)) SWIG_fail_arg("playAndGetDigits",2,"int");
-  if(!lua_isnumber(L,3)) SWIG_fail_arg("playAndGetDigits",3,"int");
-  if(!lua_isnumber(L,4)) SWIG_fail_arg("playAndGetDigits",4,"int");
-  if(!lua_isnumber(L,5)) SWIG_fail_arg("playAndGetDigits",5,"int");
-  if(!lua_isstring(L,6)) SWIG_fail_arg("playAndGetDigits",6,"char *");
-  if(!lua_isstring(L,7)) SWIG_fail_arg("playAndGetDigits",7,"char *");
-  if(!lua_isstring(L,8)) SWIG_fail_arg("playAndGetDigits",8,"char *");
-  if(!lua_isstring(L,9)) SWIG_fail_arg("playAndGetDigits",9,"char *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_playAndGetDigits",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (int)lua_tonumber(L, 2);
-  arg3 = (int)lua_tonumber(L, 3);
-  arg4 = (int)lua_tonumber(L, 4);
-  arg5 = (int)lua_tonumber(L, 5);
-  arg6 = (char *)lua_tostring(L, 6);
-  arg7 = (char *)lua_tostring(L, 7);
-  arg8 = (char *)lua_tostring(L, 8);
-  arg9 = (char *)lua_tostring(L, 9);
-  result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
-  SWIG_arg=0;
-  lua_pushstring(L,(const char*)result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_playAndGetDigits(lua_State* L) {
-  int argc;
-  int argv[11]={
-    1,2,3,4,5,6,7,8,9,10,11
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 9) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isnumber(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isnumber(L,argv[3]);
-          }
-          if (_v) {
-            {
-              _v = lua_isnumber(L,argv[4]);
-            }
-            if (_v) {
-              {
-                _v = lua_isstring(L,argv[5]);
-              }
-              if (_v) {
-                {
-                  _v = lua_isstring(L,argv[6]);
-                }
-                if (_v) {
-                  {
-                    _v = lua_isstring(L,argv[7]);
-                  }
-                  if (_v) {
-                    {
-                      _v = lua_isstring(L,argv[8]);
-                    }
-                    if (_v) {
-                      return _wrap_CoreSession_playAndGetDigits__SWIG_1(L);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  if (argc == 10) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isnumber(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          {
-            _v = lua_isnumber(L,argv[3]);
-          }
-          if (_v) {
-            {
-              _v = lua_isnumber(L,argv[4]);
-            }
-            if (_v) {
-              {
-                _v = lua_isstring(L,argv[5]);
-              }
-              if (_v) {
-                {
-                  _v = lua_isstring(L,argv[6]);
-                }
-                if (_v) {
-                  {
-                    _v = lua_isstring(L,argv[7]);
-                  }
-                  if (_v) {
-                    {
-                      _v = lua_isstring(L,argv[8]);
-                    }
-                    if (_v) {
-                      {
-                        _v = lua_isstring(L,argv[9]);
-                      }
-                      if (_v) {
-                        return _wrap_CoreSession_playAndGetDigits__SWIG_0(L);
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_playAndGetDigits'");
-  lua_error(L);return 0;
-}
-
-
-static int _wrap_CoreSession_streamFile__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_streamFile(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  int arg3 ;
+  int arg3 = (int) 0 ;
   int result;
   
-  SWIG_check_num_args("streamFile",3,3)
+  SWIG_check_num_args("streamFile",2,3)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("streamFile",1,"CoreSession *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("streamFile",2,"char *");
-  if(!lua_isnumber(L,3)) SWIG_fail_arg("streamFile",3,"int");
+  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("streamFile",3,"int");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_streamFile",1,SWIGTYPE_p_CoreSession);
   }
   
   arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (int)lua_tonumber(L, 3);
+  if(lua_gettop(L)>=3){
+    arg3 = (int)lua_tonumber(L, 3);
+  }
   result = (int)(arg1)->streamFile(arg2,arg3);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
@@ -6696,108 +5167,26 @@ fail:
 }
 
 
-static int _wrap_CoreSession_streamFile__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  
-  SWIG_check_num_args("streamFile",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("streamFile",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("streamFile",2,"char *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_streamFile",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  result = (int)(arg1)->streamFile(arg2);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_streamFile(lua_State* L) {
-  int argc;
-  int argv[4]={
-    1,2,3,4
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_streamFile__SWIG_1(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_streamFile__SWIG_0(L);
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_streamFile'");
-  lua_error(L);return 0;
-}
-
-
-static int _wrap_CoreSession_sleep__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_sleep(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
-  int arg3 ;
+  int arg3 = (int) 0 ;
   int result;
   
-  SWIG_check_num_args("sleep",3,3)
+  SWIG_check_num_args("sleep",2,3)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sleep",1,"CoreSession *");
   if(!lua_isnumber(L,2)) SWIG_fail_arg("sleep",2,"int");
-  if(!lua_isnumber(L,3)) SWIG_fail_arg("sleep",3,"int");
+  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("sleep",3,"int");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_sleep",1,SWIGTYPE_p_CoreSession);
   }
   
   arg2 = (int)lua_tonumber(L, 2);
-  arg3 = (int)lua_tonumber(L, 3);
+  if(lua_gettop(L)>=3){
+    arg3 = (int)lua_tonumber(L, 3);
+  }
   result = (int)(arg1)->sleep(arg2,arg3);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
@@ -6811,90 +5200,6 @@ fail:
 }
 
 
-static int _wrap_CoreSession_sleep__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  int arg2 ;
-  int result;
-  
-  SWIG_check_num_args("sleep",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sleep",1,"CoreSession *");
-  if(!lua_isnumber(L,2)) SWIG_fail_arg("sleep",2,"int");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_sleep",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (int)lua_tonumber(L, 2);
-  result = (int)(arg1)->sleep(arg2);
-  SWIG_arg=0;
-  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_sleep(lua_State* L) {
-  int argc;
-  int argv[4]={
-    1,2,3,4
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isnumber(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_sleep__SWIG_1(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isnumber(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isnumber(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_sleep__SWIG_0(L);
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_sleep'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_CoreSession_flushEvents(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -7131,23 +5436,25 @@ fail:
 }
 
 
-static int _wrap_CoreSession_execute__SWIG_0(lua_State* L) {
+static int _wrap_CoreSession_execute(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
   
-  SWIG_check_num_args("execute",3,3)
+  SWIG_check_num_args("execute",2,3)
   if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"CoreSession *");
   if(!lua_isstring(L,2)) SWIG_fail_arg("execute",2,"char const *");
-  if(!lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
   
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
     SWIG_fail_ptr("CoreSession_execute",1,SWIGTYPE_p_CoreSession);
   }
   
   arg2 = (char *)lua_tostring(L, 2);
-  arg3 = (char *)lua_tostring(L, 3);
+  if(lua_gettop(L)>=3){
+    arg3 = (char *)lua_tostring(L, 3);
+  }
   (arg1)->execute((char const *)arg2,(char const *)arg3);
   SWIG_arg=0;
   
@@ -7161,89 +5468,6 @@ fail:
 }
 
 
-static int _wrap_CoreSession_execute__SWIG_1(lua_State* L) {
-  int SWIG_arg = -1;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  
-  SWIG_check_num_args("execute",2,2)
-  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"CoreSession *");
-  if(!lua_isstring(L,2)) SWIG_fail_arg("execute",2,"char const *");
-  
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
-    SWIG_fail_ptr("CoreSession_execute",1,SWIGTYPE_p_CoreSession);
-  }
-  
-  arg2 = (char *)lua_tostring(L, 2);
-  (arg1)->execute((char const *)arg2);
-  SWIG_arg=0;
-  
-  return SWIG_arg;
-  
-  if(0) SWIG_fail;
-  
-fail:
-  lua_error(L);
-  return SWIG_arg;
-}
-
-
-static int _wrap_CoreSession_execute(lua_State* L) {
-  int argc;
-  int argv[4]={
-    1,2,3,4
-  };
-  
-  argc = lua_gettop(L);
-  if (argc == 2) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        return _wrap_CoreSession_execute__SWIG_1(L);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      void *ptr;
-      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
-        _v = 0;
-      } else {
-        _v = 1;
-      }
-    }
-    if (_v) {
-      {
-        _v = lua_isstring(L,argv[1]);
-      }
-      if (_v) {
-        {
-          _v = lua_isstring(L,argv[2]);
-        }
-        if (_v) {
-          return _wrap_CoreSession_execute__SWIG_0(L);
-        }
-      }
-    }
-  }
-  
-  lua_pushstring(L,"No matching function for overloaded 'CoreSession_execute'");
-  lua_error(L);return 0;
-}
-
-
 static int _wrap_CoreSession_sendEvent(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -8703,7 +6927,6 @@ static swig_type_info _swigt__p_switch_call_cause_t = {"_p_switch_call_cause_t",
 static swig_type_info _swigt__p_switch_channel_state_t = {"_p_switch_channel_state_t", "switch_channel_state_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_event_node_t = {"_p_switch_event_node_t", "switch_event_node_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_event_t = {"_p_switch_event_t", "switch_event_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_event_types_t = {"_p_switch_event_types_t", "switch_event_types_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_input_args_t = {"_p_switch_input_args_t", "switch_input_args_t *", 0, 0, (void*)0, 0};
@@ -8732,7 +6955,6 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_switch_channel_state_t,
   &_swigt__p_switch_channel_t,
   &_swigt__p_switch_core_session_t,
-  &_swigt__p_switch_event_node_t,
   &_swigt__p_switch_event_t,
   &_swigt__p_switch_event_types_t,
   &_swigt__p_switch_input_args_t,
@@ -8761,7 +6983,6 @@ static swig_cast_info _swigc__p_switch_call_cause_t[] = {  {&_swigt__p_switch_ca
 static swig_cast_info _swigc__p_switch_channel_state_t[] = {  {&_swigt__p_switch_channel_state_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_event_node_t[] = {  {&_swigt__p_switch_event_node_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_event_t[] = {  {&_swigt__p_switch_event_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_event_types_t[] = {  {&_swigt__p_switch_event_types_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_input_args_t[] = {  {&_swigt__p_switch_input_args_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -8790,7 +7011,6 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_switch_channel_state_t,
   _swigc__p_switch_channel_t,
   _swigc__p_switch_core_session_t,
-  _swigc__p_switch_event_node_t,
   _swigc__p_switch_event_t,
   _swigc__p_switch_event_types_t,
   _swigc__p_switch_input_args_t,
diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.cxx
index e82a39b9b4..1f3ba13ed2 100644
--- a/src/mod/languages/mod_managed/freeswitch_wrap.cxx
+++ b/src/mod/languages/mod_managed/freeswitch_wrap.cxx
@@ -7975,6 +7975,18 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_copy(void * jarg1, void * ja
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_reset(void * jarg1) {
+  int jresult ;
+  switch_codec_t *arg1 = (switch_codec_t *) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_codec_t *)jarg1; 
+  result = (switch_status_t)switch_core_codec_reset(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_codec_encode(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
   int jresult ;
   switch_codec_t *arg1 = (switch_codec_t *) 0 ;
@@ -31030,29 +31042,6 @@ SWIGEXPORT int SWIGSTDCALL CSharp_EventConsumer_e_event_id_get(void * jarg1) {
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_EventConsumer_node_set(void * jarg1, void * jarg2) {
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *arg2 = (switch_event_node_t *) 0 ;
-  
-  arg1 = (EventConsumer *)jarg1; 
-  arg2 = (switch_event_node_t *)jarg2; 
-  if (arg1) (arg1)->node = arg2;
-  
-}
-
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_EventConsumer_node_get(void * jarg1) {
-  void * jresult ;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *result = 0 ;
-  
-  arg1 = (EventConsumer *)jarg1; 
-  result = (switch_event_node_t *) ((arg1)->node);
-  jresult = (void *)result; 
-  return jresult;
-}
-
-
 SWIGEXPORT void SWIGSTDCALL CSharp_EventConsumer_e_callback_set(void * jarg1, char * jarg2) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *arg2 = (char *) 0 ;
@@ -31145,7 +31134,7 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_EventConsumer_e_cb_arg_get(void * jarg1) {
 
 SWIGEXPORT void * SWIGSTDCALL CSharp_new_EventConsumer(char * jarg1, char * jarg2) {
   void * jresult ;
-  char *arg1 = (char *) 0 ;
+  char *arg1 = (char *) NULL ;
   char *arg2 = (char *) "" ;
   EventConsumer *result = 0 ;
   
@@ -31166,6 +31155,22 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_EventConsumer(void * jarg1) {
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_EventConsumer_bind(void * jarg1, char * jarg2, char * jarg3) {
+  int jresult ;
+  EventConsumer *arg1 = (EventConsumer *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  int result;
+  
+  arg1 = (EventConsumer *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  result = (int)(arg1)->bind((char const *)arg2,(char const *)arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void * SWIGSTDCALL CSharp_EventConsumer_pop(void * jarg1, int jarg2) {
   void * jresult ;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
diff --git a/src/mod/languages/mod_managed/managed/swig.cs b/src/mod/languages/mod_managed/managed/swig.cs
index bc596f543c..abc2f8c810 100644
--- a/src/mod/languages/mod_managed/managed/swig.cs
+++ b/src/mod/languages/mod_managed/managed/swig.cs
@@ -554,17 +554,6 @@ public class EventConsumer : IDisposable {
     } 
   }
 
-  public SWIGTYPE_p_switch_event_node node {
-    set {
-      freeswitchPINVOKE.EventConsumer_node_set(swigCPtr, SWIGTYPE_p_switch_event_node.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = freeswitchPINVOKE.EventConsumer_node_get(swigCPtr);
-      SWIGTYPE_p_switch_event_node ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_event_node(cPtr, false);
-      return ret;
-    } 
-  }
-
   public string e_callback {
     set {
       freeswitchPINVOKE.EventConsumer_e_callback_set(swigCPtr, value);
@@ -598,6 +587,11 @@ public class EventConsumer : IDisposable {
   public EventConsumer(string event_name, string subclass_name) : this(freeswitchPINVOKE.new_EventConsumer(event_name, subclass_name), true) {
   }
 
+  public int bind(string event_name, string subclass_name) {
+    int ret = freeswitchPINVOKE.EventConsumer_bind(swigCPtr, event_name, subclass_name);
+    return ret;
+  }
+
   public Event pop(int block) {
     IntPtr cPtr = freeswitchPINVOKE.EventConsumer_pop(swigCPtr, block);
     Event ret = (cPtr == IntPtr.Zero) ? null : new Event(cPtr, true);
@@ -1644,6 +1638,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_core_codec_reset(switch_codec codec) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_reset(switch_codec.getCPtr(codec));
+    return ret;
+  }
+
   public static switch_status_t switch_core_codec_encode(switch_codec codec, switch_codec other_codec, SWIGTYPE_p_void decoded_data, uint decoded_data_len, uint decoded_rate, SWIGTYPE_p_void encoded_data, SWIGTYPE_p_unsigned_long encoded_data_len, SWIGTYPE_p_unsigned_long encoded_rate, SWIGTYPE_p_unsigned_int flag) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_encode(switch_codec.getCPtr(codec), switch_codec.getCPtr(other_codec), SWIGTYPE_p_void.getCPtr(decoded_data), decoded_data_len, decoded_rate, SWIGTYPE_p_void.getCPtr(encoded_data), SWIGTYPE_p_unsigned_long.getCPtr(encoded_data_len), SWIGTYPE_p_unsigned_long.getCPtr(encoded_rate), SWIGTYPE_p_unsigned_int.getCPtr(flag));
     return ret;
@@ -7007,6 +7006,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_codec_copy")]
   public static extern int switch_core_codec_copy(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_codec_reset")]
+  public static extern int switch_core_codec_reset(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_codec_encode")]
   public static extern int switch_core_codec_encode(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, uint jarg4, uint jarg5, HandleRef jarg6, HandleRef jarg7, HandleRef jarg8, HandleRef jarg9);
 
@@ -12404,12 +12406,6 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_EventConsumer_e_event_id_get")]
   public static extern int EventConsumer_e_event_id_get(HandleRef jarg1);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_EventConsumer_node_set")]
-  public static extern void EventConsumer_node_set(HandleRef jarg1, HandleRef jarg2);
-
-  [DllImport("mod_managed", EntryPoint="CSharp_EventConsumer_node_get")]
-  public static extern IntPtr EventConsumer_node_get(HandleRef jarg1);
-
   [DllImport("mod_managed", EntryPoint="CSharp_EventConsumer_e_callback_set")]
   public static extern void EventConsumer_e_callback_set(HandleRef jarg1, string jarg2);
 
@@ -12434,6 +12430,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_delete_EventConsumer")]
   public static extern void delete_EventConsumer(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_EventConsumer_bind")]
+  public static extern int EventConsumer_bind(HandleRef jarg1, string jarg2, string jarg3);
+
   [DllImport("mod_managed", EntryPoint="CSharp_EventConsumer_pop")]
   public static extern IntPtr EventConsumer_pop(HandleRef jarg1, int jarg2);
 
@@ -16430,36 +16429,6 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
-public class SWIGTYPE_p_switch_event_node {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_switch_event_node(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_switch_event_node() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_switch_event_node obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}
-
-}
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-namespace FreeSWITCH.Native {
-
-using System;
-using System.Runtime.InteropServices;
-
 public class SWIGTYPE_p_switch_event_types_t {
   private HandleRef swigCPtr;
 
diff --git a/src/mod/languages/mod_perl/freeswitch.pm b/src/mod/languages/mod_perl/freeswitch.pm
index cfb1f5fed3..7cdeb603e3 100644
--- a/src/mod/languages/mod_perl/freeswitch.pm
+++ b/src/mod/languages/mod_perl/freeswitch.pm
@@ -324,8 +324,6 @@ use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
 *swig_events_set = *freeswitchc::EventConsumer_events_set;
 *swig_e_event_id_get = *freeswitchc::EventConsumer_e_event_id_get;
 *swig_e_event_id_set = *freeswitchc::EventConsumer_e_event_id_set;
-*swig_node_get = *freeswitchc::EventConsumer_node_get;
-*swig_node_set = *freeswitchc::EventConsumer_node_set;
 *swig_e_callback_get = *freeswitchc::EventConsumer_e_callback_get;
 *swig_e_callback_set = *freeswitchc::EventConsumer_e_callback_set;
 *swig_e_subclass_name_get = *freeswitchc::EventConsumer_e_subclass_name_get;
@@ -349,6 +347,7 @@ sub DESTROY {
     }
 }
 
+*bind = *freeswitchc::EventConsumer_bind;
 *pop = *freeswitchc::EventConsumer_pop;
 sub DISOWN {
     my $self = shift;
diff --git a/src/mod/languages/mod_perl/mod_perl_wrap.cpp b/src/mod/languages/mod_perl/mod_perl_wrap.cpp
index 7e289febf6..1eb2b57320 100644
--- a/src/mod/languages/mod_perl/mod_perl_wrap.cpp
+++ b/src/mod/languages/mod_perl/mod_perl_wrap.cpp
@@ -1462,20 +1462,19 @@ SWIG_Perl_SetModule(swig_module_info *module) {
 #define SWIGTYPE_p_switch_channel_state_t swig_types[13]
 #define SWIGTYPE_p_switch_channel_t swig_types[14]
 #define SWIGTYPE_p_switch_core_session_t swig_types[15]
-#define SWIGTYPE_p_switch_event_node_t swig_types[16]
-#define SWIGTYPE_p_switch_event_t swig_types[17]
-#define SWIGTYPE_p_switch_event_types_t swig_types[18]
-#define SWIGTYPE_p_switch_input_args_t swig_types[19]
-#define SWIGTYPE_p_switch_input_type_t swig_types[20]
-#define SWIGTYPE_p_switch_priority_t swig_types[21]
-#define SWIGTYPE_p_switch_queue_t swig_types[22]
-#define SWIGTYPE_p_switch_state_handler_table_t swig_types[23]
-#define SWIGTYPE_p_switch_status_t swig_types[24]
-#define SWIGTYPE_p_switch_stream_handle_t swig_types[25]
-#define SWIGTYPE_p_uint32_t swig_types[26]
-#define SWIGTYPE_p_void swig_types[27]
-static swig_type_info *swig_types[29];
-static swig_module_info swig_module = {swig_types, 28, 0, 0, 0, 0};
+#define SWIGTYPE_p_switch_event_t swig_types[16]
+#define SWIGTYPE_p_switch_event_types_t swig_types[17]
+#define SWIGTYPE_p_switch_input_args_t swig_types[18]
+#define SWIGTYPE_p_switch_input_type_t swig_types[19]
+#define SWIGTYPE_p_switch_priority_t swig_types[20]
+#define SWIGTYPE_p_switch_queue_t swig_types[21]
+#define SWIGTYPE_p_switch_state_handler_table_t swig_types[22]
+#define SWIGTYPE_p_switch_status_t swig_types[23]
+#define SWIGTYPE_p_switch_stream_handle_t swig_types[24]
+#define SWIGTYPE_p_uint32_t swig_types[25]
+#define SWIGTYPE_p_void swig_types[26]
+static swig_type_info *swig_types[28];
+static swig_module_info swig_module = {swig_types, 27, 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)
 
@@ -2351,11 +2350,11 @@ XS(_wrap_delete_API) {
 }
 
 
-XS(_wrap_API_execute__SWIG_0) {
+XS(_wrap_API_execute) {
   {
     API *arg1 = (API *) 0 ;
     char *arg2 = (char *) 0 ;
-    char *arg3 = (char *) 0 ;
+    char *arg3 = (char *) NULL ;
     char *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -2368,7 +2367,7 @@ XS(_wrap_API_execute__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 3) || (items > 3)) {
+    if ((items < 2) || (items > 3)) {
       SWIG_croak("Usage: API_execute(self,command,data);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_API, 0 |  0 );
@@ -2381,11 +2380,13 @@ XS(_wrap_API_execute__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "API_execute" "', argument " "2"" of type '" "char const *""'");
     }
     arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "API_execute" "', argument " "3"" of type '" "char const *""'");
+    if (items > 2) {
+      res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+      if (!SWIG_IsOK(res3)) {
+        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "API_execute" "', argument " "3"" of type '" "char const *""'");
+      }
+      arg3 = reinterpret_cast< char * >(buf3);
     }
-    arg3 = reinterpret_cast< char * >(buf3);
     result = (char *)(arg1)->execute((char const *)arg2,(char const *)arg3);
     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
@@ -2401,131 +2402,6 @@ XS(_wrap_API_execute__SWIG_0) {
 }
 
 
-XS(_wrap_API_execute__SWIG_1) {
-  {
-    API *arg1 = (API *) 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: API_execute(self,command);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_API, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "API_execute" "', argument " "1"" of type '" "API *""'"); 
-    }
-    arg1 = reinterpret_cast< API * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "API_execute" "', argument " "2"" of type '" "char const *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    result = (char *)(arg1)->execute((char const *)arg2);
-    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_API_execute) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_API, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_API, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_API_execute__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_API_execute__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'API_execute'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_API_executeString) {
   {
     API *arg1 = (API *) 0 ;
@@ -3039,10 +2915,10 @@ XS(_wrap_DTMF_duration_get) {
 }
 
 
-XS(_wrap_new_DTMF__SWIG_0) {
+XS(_wrap_new_DTMF) {
   {
     char arg1 ;
-    uint32_t arg2 ;
+    uint32_t arg2 = (uint32_t) SWITCH_DEFAULT_DTMF_DURATION ;
     DTMF *result = 0 ;
     char val1 ;
     int ecode1 = 0 ;
@@ -3051,7 +2927,7 @@ XS(_wrap_new_DTMF__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: new_DTMF(idigit,iduration);");
     }
     ecode1 = SWIG_AsVal_char SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
@@ -3059,15 +2935,17 @@ XS(_wrap_new_DTMF__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DTMF" "', argument " "1"" of type '" "char""'");
     } 
     arg1 = static_cast< char >(val1);
-    {
-      res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_uint32_t,  0 );
-      if (!SWIG_IsOK(res2)) {
-        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'"); 
-      }  
-      if (!argp2) {
-        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'");
-      } else {
-        arg2 = *(reinterpret_cast< uint32_t * >(argp2));
+    if (items > 1) {
+      {
+        res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_uint32_t,  0 );
+        if (!SWIG_IsOK(res2)) {
+          SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'"); 
+        }  
+        if (!argp2) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'");
+        } else {
+          arg2 = *(reinterpret_cast< uint32_t * >(argp2));
+        }
       }
     }
     result = (DTMF *)new DTMF(arg1,arg2);
@@ -3081,107 +2959,6 @@ XS(_wrap_new_DTMF__SWIG_0) {
 }
 
 
-XS(_wrap_new_DTMF__SWIG_1) {
-  {
-    char arg1 ;
-    DTMF *result = 0 ;
-    char val1 ;
-    int ecode1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: new_DTMF(idigit);");
-    }
-    ecode1 = SWIG_AsVal_char SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
-    if (!SWIG_IsOK(ecode1)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DTMF" "', argument " "1"" of type '" "char""'");
-    } 
-    arg1 = static_cast< char >(val1);
-    result = (DTMF *)new DTMF(arg1);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DTMF, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_new_DTMF) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        {
-          int res = SWIG_AsVal_char SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        {
-          int res = SWIG_AsVal_char SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_uint32_t, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DTMF__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DTMF__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'new_DTMF'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_delete_DTMF) {
   {
     DTMF *arg1 = (DTMF *) 0 ;
@@ -3606,7 +3383,7 @@ XS(_wrap_Event_mine_get) {
 XS(_wrap_new_Event__SWIG_0) {
   {
     char *arg1 = (char *) 0 ;
-    char *arg2 = (char *) 0 ;
+    char *arg2 = (char *) NULL ;
     Event *result = 0 ;
     int res1 ;
     char *buf1 = 0 ;
@@ -3617,7 +3394,7 @@ XS(_wrap_new_Event__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: new_Event(type,subclass_name);");
     }
     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
@@ -3625,11 +3402,13 @@ XS(_wrap_new_Event__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "char const *""'");
     }
     arg1 = reinterpret_cast< char * >(buf1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Event" "', argument " "2"" of type '" "char const *""'");
+    if (items > 1) {
+      res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Event" "', argument " "2"" of type '" "char const *""'");
+      }
+      arg2 = reinterpret_cast< char * >(buf2);
     }
-    arg2 = reinterpret_cast< char * >(buf2);
     result = (Event *)new Event((char const *)arg1,(char const *)arg2);
     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
     if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
@@ -3644,38 +3423,9 @@ XS(_wrap_new_Event__SWIG_0) {
 
 
 XS(_wrap_new_Event__SWIG_1) {
-  {
-    char *arg1 = (char *) 0 ;
-    Event *result = 0 ;
-    int res1 ;
-    char *buf1 = 0 ;
-    int alloc1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: new_Event(type);");
-    }
-    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "char const *""'");
-    }
-    arg1 = reinterpret_cast< char * >(buf1);
-    result = (Event *)new Event((char const *)arg1);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-    XSRETURN(argvi);
-  fail:
-    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_new_Event__SWIG_2) {
   {
     switch_event_t *arg1 = (switch_event_t *) 0 ;
-    int arg2 ;
+    int arg2 = (int) 0 ;
     Event *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -3684,7 +3434,7 @@ XS(_wrap_new_Event__SWIG_2) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: new_Event(wrap_me,free_me);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_event_t, 0 |  0 );
@@ -3692,11 +3442,13 @@ XS(_wrap_new_Event__SWIG_2) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "switch_event_t *""'"); 
     }
     arg1 = reinterpret_cast< switch_event_t * >(argp1);
-    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
-    if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Event" "', argument " "2"" of type '" "int""'");
-    } 
-    arg2 = static_cast< int >(val2);
+    if (items > 1) {
+      ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+      if (!SWIG_IsOK(ecode2)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Event" "', argument " "2"" of type '" "int""'");
+      } 
+      arg2 = static_cast< int >(val2);
+    }
     result = (Event *)new Event(arg1,arg2);
     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
     
@@ -3710,41 +3462,13 @@ XS(_wrap_new_Event__SWIG_2) {
 }
 
 
-XS(_wrap_new_Event__SWIG_3) {
-  {
-    switch_event_t *arg1 = (switch_event_t *) 0 ;
-    Event *result = 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: new_Event(wrap_me);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_switch_event_t, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "switch_event_t *""'"); 
-    }
-    arg1 = reinterpret_cast< switch_event_t * >(argp1);
-    result = (Event *)new Event(arg1);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
 XS(_wrap_new_Event) {
   dXSARGS;
   
   {
     unsigned long _index = 0;
     SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
+    if ((items >= 1) && (items <= 2)) {
       SWIG_TypeRank _ranki = 0;
       SWIG_TypeRank _rankm = 0;
       SWIG_TypeRank _pi = 1;
@@ -3758,6 +3482,18 @@ XS(_wrap_new_Event) {
       _ranki += _v*_pi;
       _rankm += _pi;
       _pi *= SWIG_MAXCASTRANK;
+      if (items > 1) {
+        {
+          {
+            int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+            _v = SWIG_CheckState(res);
+          }
+        }
+        if (!_v) goto check_1;
+        _ranki += _v*_pi;
+        _rankm += _pi;
+        _pi *= SWIG_MAXCASTRANK;
+      }
       if (!_index || (_ranki < _rank)) {
         _rank = _ranki; _index = 1;
         if (_rank == _rankm) goto dispatch;
@@ -3765,7 +3501,7 @@ XS(_wrap_new_Event) {
     }
   check_1:
     
-    if (items == 1) {
+    if ((items >= 1) && (items <= 2)) {
       SWIG_TypeRank _ranki = 0;
       SWIG_TypeRank _rankm = 0;
       SWIG_TypeRank _pi = 1;
@@ -3778,6 +3514,16 @@ XS(_wrap_new_Event) {
       _ranki += _v*_pi;
       _rankm += _pi;
       _pi *= SWIG_MAXCASTRANK;
+      if (items > 1) {
+        {
+          int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+        }
+        if (!_v) goto check_2;
+        _ranki += _v*_pi;
+        _rankm += _pi;
+        _pi *= SWIG_MAXCASTRANK;
+      }
       if (!_index || (_ranki < _rank)) {
         _rank = _ranki; _index = 2;
         if (_rank == _rankm) goto dispatch;
@@ -3785,74 +3531,11 @@ XS(_wrap_new_Event) {
     }
   check_2:
     
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_switch_event_t, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 3;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_3:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 4;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_4:
-    
   dispatch:
     switch(_index) {
     case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Event__SWIG_3); return;
-    case 2:
       ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Event__SWIG_1); return;
-    case 3:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Event__SWIG_2); return;
-    case 4:
+    case 2:
       ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Event__SWIG_0); return;
     }
   }
@@ -3890,10 +3573,10 @@ XS(_wrap_delete_Event) {
 }
 
 
-XS(_wrap_Event_serialize__SWIG_0) {
+XS(_wrap_Event_serialize) {
   {
     Event *arg1 = (Event *) 0 ;
-    char *arg2 = (char *) 0 ;
+    char *arg2 = (char *) NULL ;
     char *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -3903,7 +3586,7 @@ XS(_wrap_Event_serialize__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: Event_serialize(self,format);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Event, 0 |  0 );
@@ -3911,11 +3594,13 @@ XS(_wrap_Event_serialize__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_serialize" "', argument " "1"" of type '" "Event *""'"); 
     }
     arg1 = reinterpret_cast< Event * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_serialize" "', argument " "2"" of type '" "char const *""'");
+    if (items > 1) {
+      res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_serialize" "', argument " "2"" of type '" "char const *""'");
+      }
+      arg2 = reinterpret_cast< char * >(buf2);
     }
-    arg2 = reinterpret_cast< char * >(buf2);
     result = (char *)(arg1)->serialize((char const *)arg2);
     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
@@ -3929,108 +3614,10 @@ XS(_wrap_Event_serialize__SWIG_0) {
 }
 
 
-XS(_wrap_Event_serialize__SWIG_1) {
+XS(_wrap_Event_setPriority) {
   {
     Event *arg1 = (Event *) 0 ;
-    char *result = 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Event_serialize(self);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Event, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_serialize" "', argument " "1"" of type '" "Event *""'"); 
-    }
-    arg1 = reinterpret_cast< Event * >(argp1);
-    result = (char *)(arg1)->serialize();
-    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_Event_serialize) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Event, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Event, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Event_serialize__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Event_serialize__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'Event_serialize'");
-  XSRETURN(0);
-}
-
-
-XS(_wrap_Event_setPriority__SWIG_0) {
-  {
-    Event *arg1 = (Event *) 0 ;
-    switch_priority_t arg2 ;
+    switch_priority_t arg2 = (switch_priority_t) SWITCH_PRIORITY_NORMAL ;
     bool result;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -4039,7 +3626,7 @@ XS(_wrap_Event_setPriority__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: Event_setPriority(self,priority);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Event, 0 |  0 );
@@ -4047,15 +3634,17 @@ XS(_wrap_Event_setPriority__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setPriority" "', argument " "1"" of type '" "Event *""'"); 
     }
     arg1 = reinterpret_cast< Event * >(argp1);
-    {
-      res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_switch_priority_t,  0 );
-      if (!SWIG_IsOK(res2)) {
-        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'"); 
-      }  
-      if (!argp2) {
-        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'");
-      } else {
-        arg2 = *(reinterpret_cast< switch_priority_t * >(argp2));
+    if (items > 1) {
+      {
+        res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_switch_priority_t,  0 );
+        if (!SWIG_IsOK(res2)) {
+          SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'"); 
+        }  
+        if (!argp2) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'");
+        } else {
+          arg2 = *(reinterpret_cast< switch_priority_t * >(argp2));
+        }
       }
     }
     result = (bool)(arg1)->setPriority(arg2);
@@ -4069,105 +3658,6 @@ XS(_wrap_Event_setPriority__SWIG_0) {
 }
 
 
-XS(_wrap_Event_setPriority__SWIG_1) {
-  {
-    Event *arg1 = (Event *) 0 ;
-    bool result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Event_setPriority(self);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Event, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setPriority" "', argument " "1"" of type '" "Event *""'"); 
-    }
-    arg1 = reinterpret_cast< Event * >(argp1);
-    result = (bool)(arg1)->setPriority();
-    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_Event_setPriority) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Event, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_Event, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_switch_priority_t, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Event_setPriority__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Event_setPriority__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'Event_setPriority'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_Event_getHeader) {
   {
     Event *arg1 = (Event *) 0 ;
@@ -4555,72 +4045,6 @@ XS(_wrap_EventConsumer_e_event_id_get) {
 }
 
 
-XS(_wrap_EventConsumer_node_set) {
-  {
-    EventConsumer *arg1 = (EventConsumer *) 0 ;
-    switch_event_node_t *arg2 = (switch_event_node_t *) 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    void *argp2 = 0 ;
-    int res2 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: EventConsumer_node_set(self,node);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_node_set" "', argument " "1"" of type '" "EventConsumer *""'"); 
-    }
-    arg1 = reinterpret_cast< EventConsumer * >(argp1);
-    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_switch_event_node_t, SWIG_POINTER_DISOWN |  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventConsumer_node_set" "', argument " "2"" of type '" "switch_event_node_t *""'"); 
-    }
-    arg2 = reinterpret_cast< switch_event_node_t * >(argp2);
-    if (arg1) (arg1)->node = arg2;
-    
-    
-    
-    
-    XSRETURN(argvi);
-  fail:
-    
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_EventConsumer_node_get) {
-  {
-    EventConsumer *arg1 = (EventConsumer *) 0 ;
-    switch_event_node_t *result = 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: EventConsumer_node_get(self);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_node_get" "', argument " "1"" of type '" "EventConsumer *""'"); 
-    }
-    arg1 = reinterpret_cast< EventConsumer * >(argp1);
-    result = (switch_event_node_t *) ((arg1)->node);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_switch_event_node_t, 0 | 0); argvi++ ;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
 XS(_wrap_EventConsumer_e_callback_set) {
   {
     EventConsumer *arg1 = (EventConsumer *) 0 ;
@@ -4837,10 +4261,10 @@ XS(_wrap_EventConsumer_e_cb_arg_get) {
 }
 
 
-XS(_wrap_new_EventConsumer__SWIG_0) {
+XS(_wrap_new_EventConsumer) {
   {
-    char *arg1 = (char *) 0 ;
-    char *arg2 = (char *) 0 ;
+    char *arg1 = (char *) NULL ;
+    char *arg2 = (char *) "" ;
     EventConsumer *result = 0 ;
     int res1 ;
     char *buf1 = 0 ;
@@ -4851,19 +4275,23 @@ XS(_wrap_new_EventConsumer__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 0) || (items > 2)) {
       SWIG_croak("Usage: new_EventConsumer(event_name,subclass_name);");
     }
-    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventConsumer" "', argument " "1"" of type '" "char const *""'");
+    if (items > 0) {
+      res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+      if (!SWIG_IsOK(res1)) {
+        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventConsumer" "', argument " "1"" of type '" "char const *""'");
+      }
+      arg1 = reinterpret_cast< char * >(buf1);
     }
-    arg1 = reinterpret_cast< char * >(buf1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EventConsumer" "', argument " "2"" of type '" "char const *""'");
+    if (items > 1) {
+      res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EventConsumer" "', argument " "2"" of type '" "char const *""'");
+      }
+      arg2 = reinterpret_cast< char * >(buf2);
     }
-    arg2 = reinterpret_cast< char * >(buf2);
     result = (EventConsumer *)new EventConsumer((char const *)arg1,(char const *)arg2);
     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventConsumer, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
     if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
@@ -4877,103 +4305,6 @@ XS(_wrap_new_EventConsumer__SWIG_0) {
 }
 
 
-XS(_wrap_new_EventConsumer__SWIG_1) {
-  {
-    char *arg1 = (char *) 0 ;
-    EventConsumer *result = 0 ;
-    int res1 ;
-    char *buf1 = 0 ;
-    int alloc1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: new_EventConsumer(event_name);");
-    }
-    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventConsumer" "', argument " "1"" of type '" "char const *""'");
-    }
-    arg1 = reinterpret_cast< char * >(buf1);
-    result = (EventConsumer *)new EventConsumer((char const *)arg1);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventConsumer, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-    XSRETURN(argvi);
-  fail:
-    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_new_EventConsumer) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_EventConsumer__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_EventConsumer__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'new_EventConsumer'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_delete_EventConsumer) {
   {
     EventConsumer *arg1 = (EventConsumer *) 0 ;
@@ -5002,10 +4333,62 @@ XS(_wrap_delete_EventConsumer) {
 }
 
 
-XS(_wrap_EventConsumer_pop__SWIG_0) {
+XS(_wrap_EventConsumer_bind) {
   {
     EventConsumer *arg1 = (EventConsumer *) 0 ;
-    int arg2 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) "" ;
+    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 < 2) || (items > 3)) {
+      SWIG_croak("Usage: EventConsumer_bind(self,event_name,subclass_name);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_bind" "', argument " "1"" of type '" "EventConsumer *""'"); 
+    }
+    arg1 = reinterpret_cast< EventConsumer * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventConsumer_bind" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    if (items > 2) {
+      res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+      if (!SWIG_IsOK(res3)) {
+        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventConsumer_bind" "', argument " "3"" of type '" "char const *""'");
+      }
+      arg3 = reinterpret_cast< char * >(buf3);
+    }
+    result = (int)(arg1)->bind((char const *)arg2,(char const *)arg3);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_EventConsumer_pop) {
+  {
+    EventConsumer *arg1 = (EventConsumer *) 0 ;
+    int arg2 = (int) 0 ;
     Event *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -5014,7 +4397,7 @@ XS(_wrap_EventConsumer_pop__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: EventConsumer_pop(self,block);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
@@ -5022,11 +4405,13 @@ XS(_wrap_EventConsumer_pop__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_pop" "', argument " "1"" of type '" "EventConsumer *""'"); 
     }
     arg1 = reinterpret_cast< EventConsumer * >(argp1);
-    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
-    if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventConsumer_pop" "', argument " "2"" of type '" "int""'");
-    } 
-    arg2 = static_cast< int >(val2);
+    if (items > 1) {
+      ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+      if (!SWIG_IsOK(ecode2)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventConsumer_pop" "', argument " "2"" of type '" "int""'");
+      } 
+      arg2 = static_cast< int >(val2);
+    }
     result = (Event *)(arg1)->pop(arg2);
     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
     
@@ -5040,106 +4425,6 @@ XS(_wrap_EventConsumer_pop__SWIG_0) {
 }
 
 
-XS(_wrap_EventConsumer_pop__SWIG_1) {
-  {
-    EventConsumer *arg1 = (EventConsumer *) 0 ;
-    Event *result = 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: EventConsumer_pop(self);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_pop" "', argument " "1"" of type '" "EventConsumer *""'"); 
-    }
-    arg1 = reinterpret_cast< EventConsumer * >(argp1);
-    result = (Event *)(arg1)->pop();
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_EventConsumer_pop) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_EventConsumer, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_EventConsumer, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_EventConsumer_pop__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_EventConsumer_pop__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'EventConsumer_pop'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_delete_CoreSession) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -5910,10 +5195,10 @@ XS(_wrap_CoreSession_preAnswer) {
 }
 
 
-XS(_wrap_CoreSession_hangup__SWIG_0) {
+XS(_wrap_CoreSession_hangup) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
-    char *arg2 = (char *) 0 ;
+    char *arg2 = (char *) "normal_clearing" ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int res2 ;
@@ -5922,7 +5207,7 @@ XS(_wrap_CoreSession_hangup__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
+    if ((items < 1) || (items > 2)) {
       SWIG_croak("Usage: CoreSession_hangup(self,cause);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -5930,11 +5215,13 @@ XS(_wrap_CoreSession_hangup__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_hangup" "', argument " "1"" of type '" "CoreSession *""'"); 
     }
     arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_hangup" "', argument " "2"" of type '" "char const *""'");
+    if (items > 1) {
+      res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_hangup" "', argument " "2"" of type '" "char const *""'");
+      }
+      arg2 = reinterpret_cast< char * >(buf2);
     }
-    arg2 = reinterpret_cast< char * >(buf2);
     (arg1)->hangup((char const *)arg2);
     
     
@@ -5948,103 +5235,6 @@ XS(_wrap_CoreSession_hangup__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_hangup__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: CoreSession_hangup(self);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_hangup" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    (arg1)->hangup();
-    
-    
-    XSRETURN(argvi);
-  fail:
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_hangup) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 1) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_hangup__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_hangup__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_hangup'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_CoreSession_hangupState) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -6284,14 +5474,14 @@ XS(_wrap_CoreSession_process_callback_result) {
 }
 
 
-XS(_wrap_CoreSession_say__SWIG_0) {
+XS(_wrap_CoreSession_say) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     char *arg2 = (char *) 0 ;
     char *arg3 = (char *) 0 ;
     char *arg4 = (char *) 0 ;
     char *arg5 = (char *) 0 ;
-    char *arg6 = (char *) 0 ;
+    char *arg6 = (char *) NULL ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int res2 ;
@@ -6312,7 +5502,7 @@ XS(_wrap_CoreSession_say__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 6) || (items > 6)) {
+    if ((items < 5) || (items > 6)) {
       SWIG_croak("Usage: CoreSession_say(self,tosay,module_name,say_type,say_method,say_gender);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -6340,11 +5530,13 @@ XS(_wrap_CoreSession_say__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_say" "', argument " "5"" of type '" "char const *""'");
     }
     arg5 = reinterpret_cast< char * >(buf5);
-    res6 = SWIG_AsCharPtrAndSize(ST(5), &buf6, NULL, &alloc6);
-    if (!SWIG_IsOK(res6)) {
-      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoreSession_say" "', argument " "6"" of type '" "char const *""'");
+    if (items > 5) {
+      res6 = SWIG_AsCharPtrAndSize(ST(5), &buf6, NULL, &alloc6);
+      if (!SWIG_IsOK(res6)) {
+        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoreSession_say" "', argument " "6"" of type '" "char const *""'");
+      }
+      arg6 = reinterpret_cast< char * >(buf6);
     }
-    arg6 = reinterpret_cast< char * >(buf6);
     (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6);
     
     
@@ -6366,217 +5558,12 @@ XS(_wrap_CoreSession_say__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_say__SWIG_1) {
+XS(_wrap_CoreSession_sayPhrase) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     char *arg2 = (char *) 0 ;
-    char *arg3 = (char *) 0 ;
-    char *arg4 = (char *) 0 ;
-    char *arg5 = (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 res4 ;
-    char *buf4 = 0 ;
-    int alloc4 = 0 ;
-    int res5 ;
-    char *buf5 = 0 ;
-    int alloc5 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 5) || (items > 5)) {
-      SWIG_croak("Usage: CoreSession_say(self,tosay,module_name,say_type,say_method);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_say" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_say" "', argument " "2"" of type '" "char const *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_say" "', argument " "3"" of type '" "char const *""'");
-    }
-    arg3 = reinterpret_cast< char * >(buf3);
-    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_say" "', argument " "4"" of type '" "char const *""'");
-    }
-    arg4 = reinterpret_cast< char * >(buf4);
-    res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
-    if (!SWIG_IsOK(res5)) {
-      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_say" "', argument " "5"" of type '" "char const *""'");
-    }
-    arg5 = reinterpret_cast< char * >(buf5);
-    (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
-    
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-    if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-    if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_say) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 5) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(3), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(4), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 6) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(3), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(4), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(5), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_say__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_say__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_say'");
-  XSRETURN(0);
-}
-
-
-XS(_wrap_CoreSession_sayPhrase__SWIG_0) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    char *arg2 = (char *) 0 ;
-    char *arg3 = (char *) 0 ;
-    char *arg4 = (char *) 0 ;
+    char *arg3 = (char *) "" ;
+    char *arg4 = (char *) NULL ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int res2 ;
@@ -6591,7 +5578,7 @@ XS(_wrap_CoreSession_sayPhrase__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 4) || (items > 4)) {
+    if ((items < 2) || (items > 4)) {
       SWIG_croak("Usage: CoreSession_sayPhrase(self,phrase_name,phrase_data,phrase_lang);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -6604,16 +5591,20 @@ XS(_wrap_CoreSession_sayPhrase__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_sayPhrase" "', argument " "2"" of type '" "char const *""'");
     }
     arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_sayPhrase" "', argument " "3"" of type '" "char const *""'");
+    if (items > 2) {
+      res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+      if (!SWIG_IsOK(res3)) {
+        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_sayPhrase" "', argument " "3"" of type '" "char const *""'");
+      }
+      arg3 = reinterpret_cast< char * >(buf3);
     }
-    arg3 = reinterpret_cast< char * >(buf3);
-    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_sayPhrase" "', argument " "4"" of type '" "char const *""'");
+    if (items > 3) {
+      res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+      if (!SWIG_IsOK(res4)) {
+        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_sayPhrase" "', argument " "4"" of type '" "char const *""'");
+      }
+      arg4 = reinterpret_cast< char * >(buf4);
     }
-    arg4 = reinterpret_cast< char * >(buf4);
     (arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
     
     
@@ -6631,226 +5622,6 @@ XS(_wrap_CoreSession_sayPhrase__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_sayPhrase__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_sayPhrase(self,phrase_name,phrase_data);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sayPhrase" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_sayPhrase" "', argument " "2"" of type '" "char const *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_sayPhrase" "', argument " "3"" of type '" "char const *""'");
-    }
-    arg3 = reinterpret_cast< char * >(buf3);
-    (arg1)->sayPhrase((char const *)arg2,(char const *)arg3);
-    
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_sayPhrase__SWIG_2) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_sayPhrase(self,phrase_name);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sayPhrase" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_sayPhrase" "', argument " "2"" of type '" "char const *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    (arg1)->sayPhrase((char const *)arg2);
-    
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_sayPhrase) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-    if (items == 4) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(3), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 3;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_3:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_sayPhrase__SWIG_2); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_sayPhrase__SWIG_1); return;
-    case 3:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_sayPhrase__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_sayPhrase'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_CoreSession_hangupCause) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -6907,13 +5678,13 @@ XS(_wrap_CoreSession_getState) {
 }
 
 
-XS(_wrap_CoreSession_recordFile__SWIG_0) {
+XS(_wrap_CoreSession_recordFile) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     char *arg2 = (char *) 0 ;
-    int arg3 ;
-    int arg4 ;
-    int arg5 ;
+    int arg3 = (int) 0 ;
+    int arg4 = (int) 0 ;
+    int arg5 = (int) 0 ;
     int result;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -6929,7 +5700,7 @@ XS(_wrap_CoreSession_recordFile__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 5) || (items > 5)) {
+    if ((items < 2) || (items > 5)) {
       SWIG_croak("Usage: CoreSession_recordFile(self,file_name,time_limit,silence_threshold,silence_hits);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -6942,21 +5713,27 @@ XS(_wrap_CoreSession_recordFile__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
     }
     arg2 = reinterpret_cast< char * >(buf2);
-    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
-    } 
-    arg3 = static_cast< int >(val3);
-    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_recordFile" "', argument " "4"" of type '" "int""'");
-    } 
-    arg4 = static_cast< int >(val4);
-    ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
-    if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoreSession_recordFile" "', argument " "5"" of type '" "int""'");
-    } 
-    arg5 = static_cast< int >(val5);
+    if (items > 2) {
+      ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+      if (!SWIG_IsOK(ecode3)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
+      } 
+      arg3 = static_cast< int >(val3);
+    }
+    if (items > 3) {
+      ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+      if (!SWIG_IsOK(ecode4)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_recordFile" "', argument " "4"" of type '" "int""'");
+      } 
+      arg4 = static_cast< int >(val4);
+    }
+    if (items > 4) {
+      ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+      if (!SWIG_IsOK(ecode5)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoreSession_recordFile" "', argument " "5"" of type '" "int""'");
+      } 
+      arg5 = static_cast< int >(val5);
+    }
     result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
     
@@ -6976,360 +5753,13 @@ XS(_wrap_CoreSession_recordFile__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_recordFile__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    char *arg2 = (char *) 0 ;
-    int arg3 ;
-    int arg4 ;
-    int result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int res2 ;
-    char *buf2 = 0 ;
-    int alloc2 = 0 ;
-    int val3 ;
-    int ecode3 = 0 ;
-    int val4 ;
-    int ecode4 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 4) || (items > 4)) {
-      SWIG_croak("Usage: CoreSession_recordFile(self,file_name,time_limit,silence_threshold);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
-    } 
-    arg3 = static_cast< int >(val3);
-    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_recordFile" "', argument " "4"" of type '" "int""'");
-    } 
-    arg4 = static_cast< int >(val4);
-    result = (int)(arg1)->recordFile(arg2,arg3,arg4);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    
-    
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_recordFile__SWIG_2) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    char *arg2 = (char *) 0 ;
-    int arg3 ;
-    int result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int res2 ;
-    char *buf2 = 0 ;
-    int alloc2 = 0 ;
-    int val3 ;
-    int ecode3 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 3) || (items > 3)) {
-      SWIG_croak("Usage: CoreSession_recordFile(self,file_name,time_limit);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
-    } 
-    arg3 = static_cast< int >(val3);
-    result = (int)(arg1)->recordFile(arg2,arg3);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_recordFile__SWIG_3) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_recordFile(self,file_name);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    result = (int)(arg1)->recordFile(arg2);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_recordFile) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-    if (items == 4) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 3;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_3:
-    
-    if (items == 5) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_4;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 4;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_4:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_recordFile__SWIG_3); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_recordFile__SWIG_2); return;
-    case 3:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_recordFile__SWIG_1); return;
-    case 4:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_recordFile__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_recordFile'");
-  XSRETURN(0);
-}
-
-
-XS(_wrap_CoreSession_originate__SWIG_0) {
+XS(_wrap_CoreSession_originate) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     CoreSession *arg2 = (CoreSession *) 0 ;
     char *arg3 = (char *) 0 ;
-    int arg4 ;
-    switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) 0 ;
+    int arg4 = (int) 60 ;
+    switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) NULL ;
     int result;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -7345,7 +5775,7 @@ XS(_wrap_CoreSession_originate__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 5) || (items > 5)) {
+    if ((items < 3) || (items > 5)) {
       SWIG_croak("Usage: CoreSession_originate(self,a_leg_session,dest,timeout,handlers);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -7363,16 +5793,20 @@ XS(_wrap_CoreSession_originate__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_originate" "', argument " "3"" of type '" "char *""'");
     }
     arg3 = reinterpret_cast< char * >(buf3);
-    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_originate" "', argument " "4"" of type '" "int""'");
-    } 
-    arg4 = static_cast< int >(val4);
-    res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_switch_state_handler_table_t, 0 |  0 );
-    if (!SWIG_IsOK(res5)) {
-      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_originate" "', argument " "5"" of type '" "switch_state_handler_table_t *""'"); 
+    if (items > 3) {
+      ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+      if (!SWIG_IsOK(ecode4)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_originate" "', argument " "4"" of type '" "int""'");
+      } 
+      arg4 = static_cast< int >(val4);
+    }
+    if (items > 4) {
+      res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_switch_state_handler_table_t, 0 |  0 );
+      if (!SWIG_IsOK(res5)) {
+        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_originate" "', argument " "5"" of type '" "switch_state_handler_table_t *""'"); 
+      }
+      arg5 = reinterpret_cast< switch_state_handler_table_t * >(argp5);
     }
-    arg5 = reinterpret_cast< switch_state_handler_table_t * >(argp5);
     result = (int)(arg1)->originate(arg2,arg3,arg4,arg5);
     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
     
@@ -7392,279 +5826,6 @@ XS(_wrap_CoreSession_originate__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_originate__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    CoreSession *arg2 = (CoreSession *) 0 ;
-    char *arg3 = (char *) 0 ;
-    int arg4 ;
-    int result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    void *argp2 = 0 ;
-    int res2 = 0 ;
-    int res3 ;
-    char *buf3 = 0 ;
-    int alloc3 = 0 ;
-    int val4 ;
-    int ecode4 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 4) || (items > 4)) {
-      SWIG_croak("Usage: CoreSession_originate(self,a_leg_session,dest,timeout);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_originate" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_originate" "', argument " "2"" of type '" "CoreSession *""'"); 
-    }
-    arg2 = reinterpret_cast< CoreSession * >(argp2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_originate" "', argument " "3"" of type '" "char *""'");
-    }
-    arg3 = reinterpret_cast< char * >(buf3);
-    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_originate" "', argument " "4"" of type '" "int""'");
-    } 
-    arg4 = static_cast< int >(val4);
-    result = (int)(arg1)->originate(arg2,arg3,arg4);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    
-    XSRETURN(argvi);
-  fail:
-    
-    
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_originate__SWIG_2) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    CoreSession *arg2 = (CoreSession *) 0 ;
-    char *arg3 = (char *) 0 ;
-    int result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    void *argp2 = 0 ;
-    int res2 = 0 ;
-    int res3 ;
-    char *buf3 = 0 ;
-    int alloc3 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 3) || (items > 3)) {
-      SWIG_croak("Usage: CoreSession_originate(self,a_leg_session,dest);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_originate" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_originate" "', argument " "2"" of type '" "CoreSession *""'"); 
-    }
-    arg2 = reinterpret_cast< CoreSession * >(argp2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_originate" "', argument " "3"" of type '" "char *""'");
-    }
-    arg3 = reinterpret_cast< char * >(buf3);
-    result = (int)(arg1)->originate(arg2,arg3);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    XSRETURN(argvi);
-  fail:
-    
-    
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_originate) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 4) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-    if (items == 5) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(4), &vptr, SWIGTYPE_p_switch_state_handler_table_t, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 3;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_3:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_originate__SWIG_2); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_originate__SWIG_1); return;
-    case 3:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_originate__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_originate'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_CoreSession_destroy) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -8260,12 +6421,12 @@ XS(_wrap_CoreSession_getDigits) {
 }
 
 
-XS(_wrap_CoreSession_transfer__SWIG_0) {
+XS(_wrap_CoreSession_transfer) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     char *arg2 = (char *) 0 ;
-    char *arg3 = (char *) 0 ;
-    char *arg4 = (char *) 0 ;
+    char *arg3 = (char *) NULL ;
+    char *arg4 = (char *) NULL ;
     int result;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -8281,7 +6442,7 @@ XS(_wrap_CoreSession_transfer__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 4) || (items > 4)) {
+    if ((items < 2) || (items > 4)) {
       SWIG_croak("Usage: CoreSession_transfer(self,extension,dialplan,context);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -8294,16 +6455,20 @@ XS(_wrap_CoreSession_transfer__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_transfer" "', argument " "2"" of type '" "char *""'");
     }
     arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_transfer" "', argument " "3"" of type '" "char *""'");
+    if (items > 2) {
+      res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+      if (!SWIG_IsOK(res3)) {
+        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_transfer" "', argument " "3"" of type '" "char *""'");
+      }
+      arg3 = reinterpret_cast< char * >(buf3);
     }
-    arg3 = reinterpret_cast< char * >(buf3);
-    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_transfer" "', argument " "4"" of type '" "char *""'");
+    if (items > 3) {
+      res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+      if (!SWIG_IsOK(res4)) {
+        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_transfer" "', argument " "4"" of type '" "char *""'");
+      }
+      arg4 = reinterpret_cast< char * >(buf4);
     }
-    arg4 = reinterpret_cast< char * >(buf4);
     result = (int)(arg1)->transfer(arg2,arg3,arg4);
     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
     
@@ -8321,228 +6486,6 @@ XS(_wrap_CoreSession_transfer__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_transfer__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_transfer(self,extension,dialplan);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_transfer" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_transfer" "', argument " "2"" of type '" "char *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_transfer" "', argument " "3"" of type '" "char *""'");
-    }
-    arg3 = reinterpret_cast< char * >(buf3);
-    result = (int)(arg1)->transfer(arg2,arg3);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_transfer__SWIG_2) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_transfer(self,extension);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_transfer" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_transfer" "', argument " "2"" of type '" "char *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    result = (int)(arg1)->transfer(arg2);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_transfer) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-    if (items == 4) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(3), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_3;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 3;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_3:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_transfer__SWIG_2); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_transfer__SWIG_1); return;
-    case 3:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_transfer__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_transfer'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_CoreSession_read) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -8623,7 +6566,7 @@ XS(_wrap_CoreSession_read) {
 }
 
 
-XS(_wrap_CoreSession_playAndGetDigits__SWIG_0) {
+XS(_wrap_CoreSession_playAndGetDigits) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     int arg2 ;
@@ -8634,7 +6577,7 @@ XS(_wrap_CoreSession_playAndGetDigits__SWIG_0) {
     char *arg7 = (char *) 0 ;
     char *arg8 = (char *) 0 ;
     char *arg9 = (char *) 0 ;
-    char *arg10 = (char *) 0 ;
+    char *arg10 = (char *) NULL ;
     char *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -8664,7 +6607,7 @@ XS(_wrap_CoreSession_playAndGetDigits__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 10) || (items > 10)) {
+    if ((items < 9) || (items > 10)) {
       SWIG_croak("Usage: CoreSession_playAndGetDigits(self,min_digits,max_digits,max_tries,timeout,terminators,audio_files,bad_input_audio_files,digits_regex,var_name);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -8712,11 +6655,13 @@ XS(_wrap_CoreSession_playAndGetDigits__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CoreSession_playAndGetDigits" "', argument " "9"" of type '" "char *""'");
     }
     arg9 = reinterpret_cast< char * >(buf9);
-    res10 = SWIG_AsCharPtrAndSize(ST(9), &buf10, NULL, &alloc10);
-    if (!SWIG_IsOK(res10)) {
-      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CoreSession_playAndGetDigits" "', argument " "10"" of type '" "char const *""'");
+    if (items > 9) {
+      res10 = SWIG_AsCharPtrAndSize(ST(9), &buf10, NULL, &alloc10);
+      if (!SWIG_IsOK(res10)) {
+        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CoreSession_playAndGetDigits" "', argument " "10"" of type '" "char const *""'");
+      }
+      arg10 = reinterpret_cast< char * >(buf10);
     }
-    arg10 = reinterpret_cast< char * >(buf10);
     result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
@@ -8746,337 +6691,11 @@ XS(_wrap_CoreSession_playAndGetDigits__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_playAndGetDigits__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    int arg2 ;
-    int arg3 ;
-    int arg4 ;
-    int arg5 ;
-    char *arg6 = (char *) 0 ;
-    char *arg7 = (char *) 0 ;
-    char *arg8 = (char *) 0 ;
-    char *arg9 = (char *) 0 ;
-    char *result = 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int val2 ;
-    int ecode2 = 0 ;
-    int val3 ;
-    int ecode3 = 0 ;
-    int val4 ;
-    int ecode4 = 0 ;
-    int val5 ;
-    int ecode5 = 0 ;
-    int res6 ;
-    char *buf6 = 0 ;
-    int alloc6 = 0 ;
-    int res7 ;
-    char *buf7 = 0 ;
-    int alloc7 = 0 ;
-    int res8 ;
-    char *buf8 = 0 ;
-    int alloc8 = 0 ;
-    int res9 ;
-    char *buf9 = 0 ;
-    int alloc9 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 9) || (items > 9)) {
-      SWIG_croak("Usage: CoreSession_playAndGetDigits(self,min_digits,max_digits,max_tries,timeout,terminators,audio_files,bad_input_audio_files,digits_regex);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_playAndGetDigits" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
-    if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_playAndGetDigits" "', argument " "2"" of type '" "int""'");
-    } 
-    arg2 = static_cast< int >(val2);
-    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_playAndGetDigits" "', argument " "3"" of type '" "int""'");
-    } 
-    arg3 = static_cast< int >(val3);
-    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_playAndGetDigits" "', argument " "4"" of type '" "int""'");
-    } 
-    arg4 = static_cast< int >(val4);
-    ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
-    if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoreSession_playAndGetDigits" "', argument " "5"" of type '" "int""'");
-    } 
-    arg5 = static_cast< int >(val5);
-    res6 = SWIG_AsCharPtrAndSize(ST(5), &buf6, NULL, &alloc6);
-    if (!SWIG_IsOK(res6)) {
-      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoreSession_playAndGetDigits" "', argument " "6"" of type '" "char *""'");
-    }
-    arg6 = reinterpret_cast< char * >(buf6);
-    res7 = SWIG_AsCharPtrAndSize(ST(6), &buf7, NULL, &alloc7);
-    if (!SWIG_IsOK(res7)) {
-      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CoreSession_playAndGetDigits" "', argument " "7"" of type '" "char *""'");
-    }
-    arg7 = reinterpret_cast< char * >(buf7);
-    res8 = SWIG_AsCharPtrAndSize(ST(7), &buf8, NULL, &alloc8);
-    if (!SWIG_IsOK(res8)) {
-      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CoreSession_playAndGetDigits" "', argument " "8"" of type '" "char *""'");
-    }
-    arg8 = reinterpret_cast< char * >(buf8);
-    res9 = SWIG_AsCharPtrAndSize(ST(8), &buf9, NULL, &alloc9);
-    if (!SWIG_IsOK(res9)) {
-      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CoreSession_playAndGetDigits" "', argument " "9"" of type '" "char *""'");
-    }
-    arg9 = reinterpret_cast< char * >(buf9);
-    result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
-    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
-    
-    
-    
-    
-    
-    if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-    if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
-    if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
-    if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
-    XSRETURN(argvi);
-  fail:
-    
-    
-    
-    
-    
-    if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-    if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
-    if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
-    if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_playAndGetDigits) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 9) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(5), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(6), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(7), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(8), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 10) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(5), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(6), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(7), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(8), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(9), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_playAndGetDigits__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_playAndGetDigits__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_playAndGetDigits'");
-  XSRETURN(0);
-}
-
-
-XS(_wrap_CoreSession_streamFile__SWIG_0) {
+XS(_wrap_CoreSession_streamFile) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     char *arg2 = (char *) 0 ;
-    int arg3 ;
+    int arg3 = (int) 0 ;
     int result;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -9088,7 +6707,7 @@ XS(_wrap_CoreSession_streamFile__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 3) || (items > 3)) {
+    if ((items < 2) || (items > 3)) {
       SWIG_croak("Usage: CoreSession_streamFile(self,file,starting_sample_count);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -9101,11 +6720,13 @@ XS(_wrap_CoreSession_streamFile__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_streamFile" "', argument " "2"" of type '" "char *""'");
     }
     arg2 = reinterpret_cast< char * >(buf2);
-    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_streamFile" "', argument " "3"" of type '" "int""'");
-    } 
-    arg3 = static_cast< int >(val3);
+    if (items > 2) {
+      ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+      if (!SWIG_IsOK(ecode3)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_streamFile" "', argument " "3"" of type '" "int""'");
+      } 
+      arg3 = static_cast< int >(val3);
+    }
     result = (int)(arg1)->streamFile(arg2,arg3);
     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
     
@@ -9121,138 +6742,11 @@ XS(_wrap_CoreSession_streamFile__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_streamFile__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_streamFile(self,file);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_streamFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_streamFile" "', argument " "2"" of type '" "char *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    result = (int)(arg1)->streamFile(arg2);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_streamFile) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_streamFile__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_streamFile__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_streamFile'");
-  XSRETURN(0);
-}
-
-
-XS(_wrap_CoreSession_sleep__SWIG_0) {
+XS(_wrap_CoreSession_sleep) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     int arg2 ;
-    int arg3 ;
+    int arg3 = (int) 0 ;
     int result;
     void *argp1 = 0 ;
     int res1 = 0 ;
@@ -9263,7 +6757,7 @@ XS(_wrap_CoreSession_sleep__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 3) || (items > 3)) {
+    if ((items < 2) || (items > 3)) {
       SWIG_croak("Usage: CoreSession_sleep(self,ms,sync);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -9276,11 +6770,13 @@ XS(_wrap_CoreSession_sleep__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_sleep" "', argument " "2"" of type '" "int""'");
     } 
     arg2 = static_cast< int >(val2);
-    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_sleep" "', argument " "3"" of type '" "int""'");
-    } 
-    arg3 = static_cast< int >(val3);
+    if (items > 2) {
+      ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+      if (!SWIG_IsOK(ecode3)) {
+        SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_sleep" "', argument " "3"" of type '" "int""'");
+      } 
+      arg3 = static_cast< int >(val3);
+    }
     result = (int)(arg1)->sleep(arg2,arg3);
     ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
     
@@ -9296,136 +6792,6 @@ XS(_wrap_CoreSession_sleep__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_sleep__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 0 ;
-    int arg2 ;
-    int result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int val2 ;
-    int ecode2 = 0 ;
-    int argvi = 0;
-    dXSARGS;
-    
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: CoreSession_sleep(self,ms);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sleep" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
-    if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_sleep" "', argument " "2"" of type '" "int""'");
-    } 
-    arg2 = static_cast< int >(val2);
-    result = (int)(arg1)->sleep(arg2);
-    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-    
-    
-    XSRETURN(argvi);
-  fail:
-    
-    
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_sleep) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        {
-          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
-          _v = SWIG_CheckState(res);
-        }
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_sleep__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_sleep__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_sleep'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_CoreSession_flushEvents) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -9704,11 +7070,11 @@ XS(_wrap_CoreSession_waitForAnswer) {
 }
 
 
-XS(_wrap_CoreSession_execute__SWIG_0) {
+XS(_wrap_CoreSession_execute) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
     char *arg2 = (char *) 0 ;
-    char *arg3 = (char *) 0 ;
+    char *arg3 = (char *) NULL ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int res2 ;
@@ -9720,7 +7086,7 @@ XS(_wrap_CoreSession_execute__SWIG_0) {
     int argvi = 0;
     dXSARGS;
     
-    if ((items < 3) || (items > 3)) {
+    if ((items < 2) || (items > 3)) {
       SWIG_croak("Usage: CoreSession_execute(self,app,data);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
@@ -9733,11 +7099,13 @@ XS(_wrap_CoreSession_execute__SWIG_0) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_execute" "', argument " "2"" of type '" "char const *""'");
     }
     arg2 = reinterpret_cast< char * >(buf2);
-    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_execute" "', argument " "3"" of type '" "char const *""'");
+    if (items > 2) {
+      res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+      if (!SWIG_IsOK(res3)) {
+        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_execute" "', argument " "3"" of type '" "char const *""'");
+      }
+      arg3 = reinterpret_cast< char * >(buf3);
     }
-    arg3 = reinterpret_cast< char * >(buf3);
     (arg1)->execute((char const *)arg2,(char const *)arg3);
     
     
@@ -9753,130 +7121,6 @@ XS(_wrap_CoreSession_execute__SWIG_0) {
 }
 
 
-XS(_wrap_CoreSession_execute__SWIG_1) {
-  {
-    CoreSession *arg1 = (CoreSession *) 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: CoreSession_execute(self,app);");
-    }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_execute" "', argument " "1"" of type '" "CoreSession *""'"); 
-    }
-    arg1 = reinterpret_cast< CoreSession * >(argp1);
-    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_execute" "', argument " "2"" of type '" "char const *""'");
-    }
-    arg2 = reinterpret_cast< char * >(buf2);
-    (arg1)->execute((char const *)arg2);
-    
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    XSRETURN(argvi);
-  fail:
-    
-    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-    SWIG_croak_null();
-  }
-}
-
-
-XS(_wrap_CoreSession_execute) {
-  dXSARGS;
-  
-  {
-    unsigned long _index = 0;
-    SWIG_TypeRank _rank = 0; 
-    if (items == 2) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_1;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 1;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_1:
-    
-    if (items == 3) {
-      SWIG_TypeRank _ranki = 0;
-      SWIG_TypeRank _rankm = 0;
-      SWIG_TypeRank _pi = 1;
-      int _v = 0;
-      {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_CoreSession, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      {
-        int res = SWIG_AsCharPtrAndSize(ST(2), 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-      }
-      if (!_v) goto check_2;
-      _ranki += _v*_pi;
-      _rankm += _pi;
-      _pi *= SWIG_MAXCASTRANK;
-      if (!_index || (_ranki < _rank)) {
-        _rank = _ranki; _index = 2;
-        if (_rank == _rankm) goto dispatch;
-      }
-    }
-  check_2:
-    
-  dispatch:
-    switch(_index) {
-    case 1:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_execute__SWIG_1); return;
-    case 2:
-      ++PL_markstack_ptr; SWIG_CALLXS(_wrap_CoreSession_execute__SWIG_0); return;
-    }
-  }
-  
-  croak("No matching function for overloaded 'CoreSession_execute'");
-  XSRETURN(0);
-}
-
-
 XS(_wrap_CoreSession_sendEvent) {
   {
     CoreSession *arg1 = (CoreSession *) 0 ;
@@ -11746,7 +8990,6 @@ static swig_type_info _swigt__p_switch_call_cause_t = {"_p_switch_call_cause_t",
 static swig_type_info _swigt__p_switch_channel_state_t = {"_p_switch_channel_state_t", "switch_channel_state_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_event_node_t = {"_p_switch_event_node_t", "switch_event_node_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_event_t = {"_p_switch_event_t", "switch_event_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_event_types_t = {"_p_switch_event_types_t", "switch_event_types_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_input_args_t = {"_p_switch_input_args_t", "switch_input_args_t *", 0, 0, (void*)0, 0};
@@ -11776,7 +9019,6 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_switch_channel_state_t,
   &_swigt__p_switch_channel_t,
   &_swigt__p_switch_core_session_t,
-  &_swigt__p_switch_event_node_t,
   &_swigt__p_switch_event_t,
   &_swigt__p_switch_event_types_t,
   &_swigt__p_switch_input_args_t,
@@ -11806,7 +9048,6 @@ static swig_cast_info _swigc__p_switch_call_cause_t[] = {  {&_swigt__p_switch_ca
 static swig_cast_info _swigc__p_switch_channel_state_t[] = {  {&_swigt__p_switch_channel_state_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_event_node_t[] = {  {&_swigt__p_switch_event_node_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_event_t[] = {  {&_swigt__p_switch_event_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_event_types_t[] = {  {&_swigt__p_switch_event_types_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_input_args_t[] = {  {&_swigt__p_switch_input_args_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -11836,7 +9077,6 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_switch_channel_state_t,
   _swigc__p_switch_channel_t,
   _swigc__p_switch_core_session_t,
-  _swigc__p_switch_event_node_t,
   _swigc__p_switch_event_t,
   _swigc__p_switch_event_types_t,
   _swigc__p_switch_input_args_t,
@@ -11915,8 +9155,6 @@ static swig_command_info swig_commands[] = {
 {"freeswitchc::EventConsumer_events_get", _wrap_EventConsumer_events_get},
 {"freeswitchc::EventConsumer_e_event_id_set", _wrap_EventConsumer_e_event_id_set},
 {"freeswitchc::EventConsumer_e_event_id_get", _wrap_EventConsumer_e_event_id_get},
-{"freeswitchc::EventConsumer_node_set", _wrap_EventConsumer_node_set},
-{"freeswitchc::EventConsumer_node_get", _wrap_EventConsumer_node_get},
 {"freeswitchc::EventConsumer_e_callback_set", _wrap_EventConsumer_e_callback_set},
 {"freeswitchc::EventConsumer_e_callback_get", _wrap_EventConsumer_e_callback_get},
 {"freeswitchc::EventConsumer_e_subclass_name_set", _wrap_EventConsumer_e_subclass_name_set},
@@ -11925,6 +9163,7 @@ static swig_command_info swig_commands[] = {
 {"freeswitchc::EventConsumer_e_cb_arg_get", _wrap_EventConsumer_e_cb_arg_get},
 {"freeswitchc::new_EventConsumer", _wrap_new_EventConsumer},
 {"freeswitchc::delete_EventConsumer", _wrap_delete_EventConsumer},
+{"freeswitchc::EventConsumer_bind", _wrap_EventConsumer_bind},
 {"freeswitchc::EventConsumer_pop", _wrap_EventConsumer_pop},
 {"freeswitchc::delete_CoreSession", _wrap_delete_CoreSession},
 {"freeswitchc::CoreSession_session_set", _wrap_CoreSession_session_set},
@@ -12318,17 +9557,17 @@ XS(SWIG_init) {
   SWIG_TypeClientData(SWIGTYPE_p_IVRMenu, (void*) "freeswitch::IVRMenu");
   SWIG_TypeClientData(SWIGTYPE_p_API, (void*) "freeswitch::API");
   SWIG_TypeClientData(SWIGTYPE_p_input_callback_state, (void*) "freeswitch::input_callback_state_t");
-  /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
+  /*@SWIG:/usr/local/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
     SV *sv = get_sv((char*) SWIG_prefix "S_HUP", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(S_HUP)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
+  /*@SWIG:/usr/local/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
     SV *sv = get_sv((char*) SWIG_prefix "S_FREE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(S_FREE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
+  /*@SWIG:/usr/local/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
     SV *sv = get_sv((char*) SWIG_prefix "S_RDLOCK", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(S_RDLOCK)));
     SvREADONLY_on(sv);
diff --git a/src/mod/languages/mod_python/freeswitch.py b/src/mod/languages/mod_python/freeswitch.py
index 134f28920e..c1c4ddc797 100644
--- a/src/mod/languages/mod_python/freeswitch.py
+++ b/src/mod/languages/mod_python/freeswitch.py
@@ -198,9 +198,6 @@ class EventConsumer(_object):
     __swig_setmethods__["e_event_id"] = _freeswitch.EventConsumer_e_event_id_set
     __swig_getmethods__["e_event_id"] = _freeswitch.EventConsumer_e_event_id_get
     if _newclass:e_event_id = _swig_property(_freeswitch.EventConsumer_e_event_id_get, _freeswitch.EventConsumer_e_event_id_set)
-    __swig_setmethods__["node"] = _freeswitch.EventConsumer_node_set
-    __swig_getmethods__["node"] = _freeswitch.EventConsumer_node_get
-    if _newclass:node = _swig_property(_freeswitch.EventConsumer_node_get, _freeswitch.EventConsumer_node_set)
     __swig_setmethods__["e_callback"] = _freeswitch.EventConsumer_e_callback_set
     __swig_getmethods__["e_callback"] = _freeswitch.EventConsumer_e_callback_get
     if _newclass:e_callback = _swig_property(_freeswitch.EventConsumer_e_callback_get, _freeswitch.EventConsumer_e_callback_set)
@@ -216,6 +213,7 @@ class EventConsumer(_object):
         except: self.this = this
     __swig_destroy__ = _freeswitch.delete_EventConsumer
     __del__ = lambda self : None;
+    def bind(*args): return _freeswitch.EventConsumer_bind(*args)
     def pop(*args): return _freeswitch.EventConsumer_pop(*args)
 EventConsumer_swigregister = _freeswitch.EventConsumer_swigregister
 EventConsumer_swigregister(EventConsumer)
diff --git a/src/mod/languages/mod_python/mod_python_wrap.cpp b/src/mod/languages/mod_python/mod_python_wrap.cpp
index d85799b7bc..e599b68cf3 100644
--- a/src/mod/languages/mod_python/mod_python_wrap.cpp
+++ b/src/mod/languages/mod_python/mod_python_wrap.cpp
@@ -2510,20 +2510,19 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags)
 #define SWIGTYPE_p_switch_channel_state_t swig_types[12]
 #define SWIGTYPE_p_switch_channel_t swig_types[13]
 #define SWIGTYPE_p_switch_core_session_t swig_types[14]
-#define SWIGTYPE_p_switch_event_node_t swig_types[15]
-#define SWIGTYPE_p_switch_event_t swig_types[16]
-#define SWIGTYPE_p_switch_event_types_t swig_types[17]
-#define SWIGTYPE_p_switch_input_args_t swig_types[18]
-#define SWIGTYPE_p_switch_input_type_t swig_types[19]
-#define SWIGTYPE_p_switch_priority_t swig_types[20]
-#define SWIGTYPE_p_switch_queue_t swig_types[21]
-#define SWIGTYPE_p_switch_state_handler_table_t swig_types[22]
-#define SWIGTYPE_p_switch_status_t swig_types[23]
-#define SWIGTYPE_p_switch_stream_handle_t swig_types[24]
-#define SWIGTYPE_p_uint32_t swig_types[25]
-#define SWIGTYPE_p_void swig_types[26]
-static swig_type_info *swig_types[28];
-static swig_module_info swig_module = {swig_types, 27, 0, 0, 0, 0};
+#define SWIGTYPE_p_switch_event_t swig_types[15]
+#define SWIGTYPE_p_switch_event_types_t swig_types[16]
+#define SWIGTYPE_p_switch_input_args_t swig_types[17]
+#define SWIGTYPE_p_switch_input_type_t swig_types[18]
+#define SWIGTYPE_p_switch_priority_t swig_types[19]
+#define SWIGTYPE_p_switch_queue_t swig_types[20]
+#define SWIGTYPE_p_switch_state_handler_table_t swig_types[21]
+#define SWIGTYPE_p_switch_status_t swig_types[22]
+#define SWIGTYPE_p_switch_stream_handle_t swig_types[23]
+#define SWIGTYPE_p_uint32_t swig_types[24]
+#define SWIGTYPE_p_void swig_types[25]
+static swig_type_info *swig_types[27];
+static swig_module_info swig_module = {swig_types, 26, 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)
 
@@ -3418,11 +3417,11 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_API_execute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_API_execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   API *arg1 = (API *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
   char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -3436,7 +3435,7 @@ SWIGINTERN PyObject *_wrap_API_execute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:API_execute",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|O:API_execute",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_API, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "API_execute" "', argument " "1"" of type '" "API *""'"); 
@@ -3447,11 +3446,13 @@ SWIGINTERN PyObject *_wrap_API_execute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "API_execute" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "API_execute" "', argument " "3"" of type '" "char const *""'");
+  if (obj2) {
+    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "API_execute" "', argument " "3"" of type '" "char const *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
   }
-  arg3 = reinterpret_cast< char * >(buf3);
   result = (char *)(arg1)->execute((char const *)arg2,(char const *)arg3);
   resultobj = SWIG_FromCharPtr((const char *)result);
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -3464,90 +3465,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_API_execute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  API *arg1 = (API *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:API_execute",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_API, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "API_execute" "', argument " "1"" of type '" "API *""'"); 
-  }
-  arg1 = reinterpret_cast< API * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "API_execute" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  result = (char *)(arg1)->execute((char const *)arg2);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_API_execute(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[4];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_API, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_API_execute__SWIG_1(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_API, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_API_execute__SWIG_0(self, args);
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'API_execute'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    execute(API *,char const *,char const *)\n"
-    "    execute(API *,char const *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_API_executeString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   API *arg1 = (API *) 0 ;
@@ -3981,10 +3898,10 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_new_DTMF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_DTMF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char arg1 ;
-  uint32_t arg2 ;
+  uint32_t arg2 = (uint32_t) SWITCH_DEFAULT_DTMF_DURATION ;
   DTMF *result = 0 ;
   char val1 ;
   int ecode1 = 0 ;
@@ -3993,23 +3910,25 @@ SWIGINTERN PyObject *_wrap_new_DTMF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyOb
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:new_DTMF",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:new_DTMF",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_char(obj0, &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DTMF" "', argument " "1"" of type '" "char""'");
   } 
   arg1 = static_cast< char >(val1);
-  {
-    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint32_t,  0  | 0);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'"); 
-    }  
-    if (!argp2) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'");
-    } else {
-      uint32_t * temp = reinterpret_cast< uint32_t * >(argp2);
-      arg2 = *temp;
-      if (SWIG_IsNewObj(res2)) delete temp;
+  if (obj1) {
+    {
+      res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint32_t,  0  | 0);
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'"); 
+      }  
+      if (!argp2) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DTMF" "', argument " "2"" of type '" "uint32_t""'");
+      } else {
+        uint32_t * temp = reinterpret_cast< uint32_t * >(argp2);
+        arg2 = *temp;
+        if (SWIG_IsNewObj(res2)) delete temp;
+      }
     }
   }
   result = (DTMF *)new DTMF(arg1,arg2);
@@ -4020,72 +3939,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_new_DTMF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  char arg1 ;
-  DTMF *result = 0 ;
-  char val1 ;
-  int ecode1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:new_DTMF",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_char(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DTMF" "', argument " "1"" of type '" "char""'");
-  } 
-  arg1 = static_cast< char >(val1);
-  result = (DTMF *)new DTMF(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DTMF, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_DTMF(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[3];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      int res = SWIG_AsVal_char(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_new_DTMF__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      int res = SWIG_AsVal_char(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_uint32_t, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_new_DTMF__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DTMF'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    DTMF(char,uint32_t)\n"
-    "    DTMF(char)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_delete_DTMF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   DTMF *arg1 = (DTMF *) 0 ;
@@ -4436,7 +4289,7 @@ fail:
 SWIGINTERN PyObject *_wrap_new_Event__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
   Event *result = 0 ;
   int res1 ;
   char *buf1 = 0 ;
@@ -4447,17 +4300,19 @@ SWIGINTERN PyObject *_wrap_new_Event__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyO
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:new_Event",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:new_Event",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = reinterpret_cast< char * >(buf1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Event" "', argument " "2"" of type '" "char const *""'");
+  if (obj1) {
+    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Event" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
   }
-  arg2 = reinterpret_cast< char * >(buf2);
   result = (Event *)new Event((char const *)arg1,(char const *)arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
@@ -4471,34 +4326,9 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Event__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  Event *result = 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:new_Event",&obj0)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "char const *""'");
-  }
-  arg1 = reinterpret_cast< char * >(buf1);
-  result = (Event *)new Event((char const *)arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
-  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_Event__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   switch_event_t *arg1 = (switch_event_t *) 0 ;
-  int arg2 ;
+  int arg2 = (int) 0 ;
   Event *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -4507,17 +4337,19 @@ SWIGINTERN PyObject *_wrap_new_Event__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyO
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:new_Event",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:new_Event",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_switch_event_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "switch_event_t *""'"); 
   }
   arg1 = reinterpret_cast< switch_event_t * >(argp1);
-  ecode2 = SWIG_AsVal_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Event" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = static_cast< int >(val2);
+  if (obj1) {
+    ecode2 = SWIG_AsVal_int(obj1, &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Event" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+  }
   result = (Event *)new Event(arg1,arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
   return resultobj;
@@ -4526,28 +4358,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_new_Event__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  switch_event_t *arg1 = (switch_event_t *) 0 ;
-  Event *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:new_Event",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_switch_event_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "switch_event_t *""'"); 
-  }
-  arg1 = reinterpret_cast< switch_event_t * >(argp1);
-  result = (Event *)new Event(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_Event(PyObject *self, PyObject *args) {
   int argc;
   PyObject *argv[3];
@@ -4558,43 +4368,32 @@ SWIGINTERN PyObject *_wrap_new_Event(PyObject *self, PyObject *args) {
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_switch_event_t, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_Event__SWIG_3(self, args);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_Event__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
+  if ((argc >= 1) && (argc <= 2)) {
     int _v;
     void *vptr = 0;
     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_switch_event_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_Event__SWIG_1(self, args);
+      }
       {
         int res = SWIG_AsVal_int(argv[1], NULL);
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        return _wrap_new_Event__SWIG_2(self, args);
+        return _wrap_new_Event__SWIG_1(self, args);
       }
     }
   }
-  if (argc == 2) {
+  if ((argc >= 1) && (argc <= 2)) {
     int _v;
     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_Event__SWIG_0(self, args);
+      }
       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
@@ -4607,9 +4406,7 @@ fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Event'.\n"
     "  Possible C/C++ prototypes are:\n"
     "    Event(char const *,char const *)\n"
-    "    Event(char const *)\n"
-    "    Event(switch_event_t *,int)\n"
-    "    Event(switch_event_t *)\n");
+    "    Event(switch_event_t *,int)\n");
   return NULL;
 }
 
@@ -4636,10 +4433,10 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_Event_serialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_Event_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Event *arg1 = (Event *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
   char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -4649,17 +4446,19 @@ SWIGINTERN PyObject *_wrap_Event_serialize__SWIG_0(PyObject *SWIGUNUSEDPARM(self
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:Event_serialize",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:Event_serialize",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Event, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_serialize" "', argument " "1"" of type '" "Event *""'"); 
   }
   arg1 = reinterpret_cast< Event * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_serialize" "', argument " "2"" of type '" "char const *""'");
+  if (obj1) {
+    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_serialize" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
   }
-  arg2 = reinterpret_cast< char * >(buf2);
   result = (char *)(arg1)->serialize((char const *)arg2);
   resultobj = SWIG_FromCharPtr((const char *)result);
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -4670,74 +4469,10 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_Event_serialize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_Event_setPriority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Event *arg1 = (Event *) 0 ;
-  char *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:Event_serialize",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Event, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_serialize" "', argument " "1"" of type '" "Event *""'"); 
-  }
-  arg1 = reinterpret_cast< Event * >(argp1);
-  result = (char *)(arg1)->serialize();
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Event_serialize(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[3];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_Event_serialize__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_Event_serialize__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Event_serialize'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    serialize(Event *,char const *)\n"
-    "    serialize(Event *)\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Event_setPriority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Event *arg1 = (Event *) 0 ;
-  switch_priority_t arg2 ;
+  switch_priority_t arg2 = (switch_priority_t) SWITCH_PRIORITY_NORMAL ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -4746,23 +4481,25 @@ SWIGINTERN PyObject *_wrap_Event_setPriority__SWIG_0(PyObject *SWIGUNUSEDPARM(se
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:Event_setPriority",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:Event_setPriority",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Event, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setPriority" "', argument " "1"" of type '" "Event *""'"); 
   }
   arg1 = reinterpret_cast< Event * >(argp1);
-  {
-    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_switch_priority_t,  0  | 0);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'"); 
-    }  
-    if (!argp2) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'");
-    } else {
-      switch_priority_t * temp = reinterpret_cast< switch_priority_t * >(argp2);
-      arg2 = *temp;
-      if (SWIG_IsNewObj(res2)) delete temp;
+  if (obj1) {
+    {
+      res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_switch_priority_t,  0  | 0);
+      if (!SWIG_IsOK(res2)) {
+        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'"); 
+      }  
+      if (!argp2) {
+        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setPriority" "', argument " "2"" of type '" "switch_priority_t""'");
+      } else {
+        switch_priority_t * temp = reinterpret_cast< switch_priority_t * >(argp2);
+        arg2 = *temp;
+        if (SWIG_IsNewObj(res2)) delete temp;
+      }
     }
   }
   result = (bool)(arg1)->setPriority(arg2);
@@ -4773,70 +4510,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_Event_setPriority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Event *arg1 = (Event *) 0 ;
-  bool result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:Event_setPriority",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Event, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setPriority" "', argument " "1"" of type '" "Event *""'"); 
-  }
-  arg1 = reinterpret_cast< Event * >(argp1);
-  result = (bool)(arg1)->setPriority();
-  resultobj = SWIG_From_bool(static_cast< bool >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Event_setPriority(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[3];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_Event_setPriority__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_switch_priority_t, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_Event_setPriority__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Event_setPriority'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    setPriority(Event *,switch_priority_t)\n"
-    "    setPriority(Event *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_Event_getHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Event *arg1 = (Event *) 0 ;
@@ -5172,59 +4845,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_EventConsumer_node_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *arg2 = (switch_event_node_t *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:EventConsumer_node_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_node_set" "', argument " "1"" of type '" "EventConsumer *""'"); 
-  }
-  arg1 = reinterpret_cast< EventConsumer * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_switch_event_node_t, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventConsumer_node_set" "', argument " "2"" of type '" "switch_event_node_t *""'"); 
-  }
-  arg2 = reinterpret_cast< switch_event_node_t * >(argp2);
-  if (arg1) (arg1)->node = arg2;
-  
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_EventConsumer_node_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  switch_event_node_t *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:EventConsumer_node_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_node_get" "', argument " "1"" of type '" "EventConsumer *""'"); 
-  }
-  arg1 = reinterpret_cast< EventConsumer * >(argp1);
-  result = (switch_event_node_t *) ((arg1)->node);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_switch_event_node_t, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_EventConsumer_e_callback_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
@@ -5408,10 +5028,10 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_new_EventConsumer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_EventConsumer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg1 = (char *) NULL ;
+  char *arg2 = (char *) "" ;
   EventConsumer *result = 0 ;
   int res1 ;
   char *buf1 = 0 ;
@@ -5422,17 +5042,21 @@ SWIGINTERN PyObject *_wrap_new_EventConsumer__SWIG_0(PyObject *SWIGUNUSEDPARM(se
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:new_EventConsumer",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventConsumer" "', argument " "1"" of type '" "char const *""'");
+  if (!PyArg_ParseTuple(args,(char *)"|OO:new_EventConsumer",&obj0,&obj1)) SWIG_fail;
+  if (obj0) {
+    res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventConsumer" "', argument " "1"" of type '" "char const *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
   }
-  arg1 = reinterpret_cast< char * >(buf1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EventConsumer" "', argument " "2"" of type '" "char const *""'");
+  if (obj1) {
+    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EventConsumer" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
   }
-  arg2 = reinterpret_cast< char * >(buf2);
   result = (EventConsumer *)new EventConsumer((char const *)arg1,(char const *)arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventConsumer, SWIG_POINTER_NEW |  0 );
   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
@@ -5445,71 +5069,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_new_EventConsumer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  char *arg1 = (char *) 0 ;
-  EventConsumer *result = 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:new_EventConsumer",&obj0)) SWIG_fail;
-  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventConsumer" "', argument " "1"" of type '" "char const *""'");
-  }
-  arg1 = reinterpret_cast< char * >(buf1);
-  result = (EventConsumer *)new EventConsumer((char const *)arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventConsumer, SWIG_POINTER_NEW |  0 );
-  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-  return resultobj;
-fail:
-  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_EventConsumer(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[3];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_new_EventConsumer__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_new_EventConsumer__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EventConsumer'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    EventConsumer(char const *,char const *)\n"
-    "    EventConsumer(char const *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_delete_EventConsumer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
@@ -5532,10 +5091,58 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_EventConsumer_pop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_EventConsumer_bind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
-  int arg2 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO|O:EventConsumer_bind",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_bind" "', argument " "1"" of type '" "EventConsumer *""'"); 
+  }
+  arg1 = reinterpret_cast< EventConsumer * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventConsumer_bind" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  if (obj2) {
+    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventConsumer_bind" "', argument " "3"" of type '" "char const *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+  }
+  result = (int)(arg1)->bind((char const *)arg2,(char const *)arg3);
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_EventConsumer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  EventConsumer *arg1 = (EventConsumer *) 0 ;
+  int arg2 = (int) 0 ;
   Event *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -5544,20 +5151,20 @@ SWIGINTERN PyObject *_wrap_EventConsumer_pop__SWIG_0(PyObject *SWIGUNUSEDPARM(se
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:EventConsumer_pop",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:EventConsumer_pop",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_pop" "', argument " "1"" of type '" "EventConsumer *""'"); 
   }
   arg1 = reinterpret_cast< EventConsumer * >(argp1);
-  ecode2 = SWIG_AsVal_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventConsumer_pop" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = static_cast< int >(val2);
-  Py_BEGIN_ALLOW_THREADS;
+  if (obj1) {
+    ecode2 = SWIG_AsVal_int(obj1, &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventConsumer_pop" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+  }
   result = (Event *)(arg1)->pop(arg2);
-  Py_END_ALLOW_THREADS;
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
@@ -5565,74 +5172,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_EventConsumer_pop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  EventConsumer *arg1 = (EventConsumer *) 0 ;
-  Event *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:EventConsumer_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EventConsumer, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_pop" "', argument " "1"" of type '" "EventConsumer *""'"); 
-  }
-  arg1 = reinterpret_cast< EventConsumer * >(argp1);
-  Py_BEGIN_ALLOW_THREADS;
-  result = (Event *)(arg1)->pop();
-  Py_END_ALLOW_THREADS;
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_EventConsumer_pop(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[3];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EventConsumer, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_EventConsumer_pop__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EventConsumer, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_int(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_EventConsumer_pop__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EventConsumer_pop'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    pop(EventConsumer *,int)\n"
-    "    pop(EventConsumer *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *EventConsumer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
@@ -6276,10 +5815,10 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_hangup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_hangup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
+  char *arg2 = (char *) "normal_clearing" ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 ;
@@ -6288,17 +5827,19 @@ SWIGINTERN PyObject *_wrap_CoreSession_hangup__SWIG_0(PyObject *SWIGUNUSEDPARM(s
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_hangup",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O|O:CoreSession_hangup",&obj0,&obj1)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_hangup" "', argument " "1"" of type '" "CoreSession *""'"); 
   }
   arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_hangup" "', argument " "2"" of type '" "char const *""'");
+  if (obj1) {
+    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_hangup" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
   }
-  arg2 = reinterpret_cast< char * >(buf2);
   (arg1)->hangup((char const *)arg2);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -6309,69 +5850,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_hangup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:CoreSession_hangup",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_hangup" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  (arg1)->hangup();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_hangup(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[3];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_CoreSession_hangup__SWIG_1(self, args);
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_CoreSession_hangup__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_hangup'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    hangup(CoreSession *,char const *)\n"
-    "    hangup(CoreSession *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_CoreSession_hangupState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -6580,14 +6058,14 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_say__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_say(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   char *arg4 = (char *) 0 ;
   char *arg5 = (char *) 0 ;
-  char *arg6 = (char *) 0 ;
+  char *arg6 = (char *) NULL ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 ;
@@ -6612,7 +6090,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_say__SWIG_0(PyObject *SWIGUNUSEDPARM(self
   PyObject * obj4 = 0 ;
   PyObject * obj5 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CoreSession_say",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:CoreSession_say",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_say" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -6638,11 +6116,13 @@ SWIGINTERN PyObject *_wrap_CoreSession_say__SWIG_0(PyObject *SWIGUNUSEDPARM(self
     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_say" "', argument " "5"" of type '" "char const *""'");
   }
   arg5 = reinterpret_cast< char * >(buf5);
-  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoreSession_say" "', argument " "6"" of type '" "char const *""'");
+  if (obj5) {
+    res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoreSession_say" "', argument " "6"" of type '" "char const *""'");
+    }
+    arg6 = reinterpret_cast< char * >(buf6);
   }
-  arg6 = reinterpret_cast< char * >(buf6);
   (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -6661,155 +6141,12 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_say__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
-  char *arg5 = (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 res4 ;
-  char *buf4 = 0 ;
-  int alloc4 = 0 ;
-  int res5 ;
-  char *buf5 = 0 ;
-  int alloc5 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:CoreSession_say",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_say" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_say" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_say" "', argument " "3"" of type '" "char const *""'");
-  }
-  arg3 = reinterpret_cast< char * >(buf3);
-  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_say" "', argument " "4"" of type '" "char const *""'");
-  }
-  arg4 = reinterpret_cast< char * >(buf4);
-  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_say" "', argument " "5"" of type '" "char const *""'");
-  }
-  arg5 = reinterpret_cast< char * >(buf5);
-  (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_say(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[7];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 6); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 5) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
-          _v = SWIG_CheckState(res);
-          if (_v) {
-            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
-            _v = SWIG_CheckState(res);
-            if (_v) {
-              return _wrap_CoreSession_say__SWIG_1(self, args);
-            }
-          }
-        }
-      }
-    }
-  }
-  if (argc == 6) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
-          _v = SWIG_CheckState(res);
-          if (_v) {
-            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
-            _v = SWIG_CheckState(res);
-            if (_v) {
-              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
-              _v = SWIG_CheckState(res);
-              if (_v) {
-                return _wrap_CoreSession_say__SWIG_0(self, args);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_say'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    say(CoreSession *,char const *,char const *,char const *,char const *,char const *)\n"
-    "    say(CoreSession *,char const *,char const *,char const *,char const *)\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
+  char *arg3 = (char *) "" ;
+  char *arg4 = (char *) NULL ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 ;
@@ -6826,7 +6163,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase__SWIG_0(PyObject *SWIGUNUSEDPAR
   PyObject * obj2 = 0 ;
   PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:CoreSession_sayPhrase",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|OO:CoreSession_sayPhrase",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sayPhrase" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -6837,16 +6174,20 @@ SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase__SWIG_0(PyObject *SWIGUNUSEDPAR
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_sayPhrase" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_sayPhrase" "', argument " "3"" of type '" "char const *""'");
+  if (obj2) {
+    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_sayPhrase" "', argument " "3"" of type '" "char const *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
   }
-  arg3 = reinterpret_cast< char * >(buf3);
-  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_sayPhrase" "', argument " "4"" of type '" "char const *""'");
+  if (obj3) {
+    res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_sayPhrase" "', argument " "4"" of type '" "char const *""'");
+    }
+    arg4 = reinterpret_cast< char * >(buf4);
   }
-  arg4 = reinterpret_cast< char * >(buf4);
   (arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -6861,156 +6202,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 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 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_sayPhrase",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sayPhrase" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_sayPhrase" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_sayPhrase" "', argument " "3"" of type '" "char const *""'");
-  }
-  arg3 = reinterpret_cast< char * >(buf3);
-  (arg1)->sayPhrase((char const *)arg2,(char const *)arg3);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_sayPhrase",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sayPhrase" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_sayPhrase" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  (arg1)->sayPhrase((char const *)arg2);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_sayPhrase(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[5];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_CoreSession_sayPhrase__SWIG_2(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_CoreSession_sayPhrase__SWIG_1(self, args);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
-          _v = SWIG_CheckState(res);
-          if (_v) {
-            return _wrap_CoreSession_sayPhrase__SWIG_0(self, args);
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_sayPhrase'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    sayPhrase(CoreSession *,char const *,char const *,char const *)\n"
-    "    sayPhrase(CoreSession *,char const *,char const *)\n"
-    "    sayPhrase(CoreSession *,char const *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_CoreSession_hangupCause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -7055,13 +6246,13 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_recordFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
+  int arg3 = (int) 0 ;
+  int arg4 = (int) 0 ;
+  int arg5 = (int) 0 ;
   int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -7080,7 +6271,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_0(PyObject *SWIGUNUSEDPA
   PyObject * obj3 = 0 ;
   PyObject * obj4 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:CoreSession_recordFile",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|OOO:CoreSession_recordFile",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -7091,21 +6282,27 @@ SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_0(PyObject *SWIGUNUSEDPA
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
   }
   arg2 = reinterpret_cast< char * >(buf2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = static_cast< int >(val3);
-  ecode4 = SWIG_AsVal_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_recordFile" "', argument " "4"" of type '" "int""'");
-  } 
-  arg4 = static_cast< int >(val4);
-  ecode5 = SWIG_AsVal_int(obj4, &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoreSession_recordFile" "', argument " "5"" of type '" "int""'");
-  } 
-  arg5 = static_cast< int >(val5);
+  if (obj2) {
+    ecode3 = SWIG_AsVal_int(obj2, &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
+    } 
+    arg3 = static_cast< int >(val3);
+  }
+  if (obj3) {
+    ecode4 = SWIG_AsVal_int(obj3, &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_recordFile" "', argument " "4"" of type '" "int""'");
+    } 
+    arg4 = static_cast< int >(val4);
+  }
+  if (obj4) {
+    ecode5 = SWIG_AsVal_int(obj4, &val5);
+    if (!SWIG_IsOK(ecode5)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoreSession_recordFile" "', argument " "5"" of type '" "int""'");
+    } 
+    arg5 = static_cast< int >(val5);
+  }
   result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
   resultobj = SWIG_From_int(static_cast< int >(result));
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -7116,252 +6313,13 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int arg4 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:CoreSession_recordFile",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = static_cast< int >(val3);
-  ecode4 = SWIG_AsVal_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_recordFile" "', argument " "4"" of type '" "int""'");
-  } 
-  arg4 = static_cast< int >(val4);
-  result = (int)(arg1)->recordFile(arg2,arg3,arg4);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int arg3 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_recordFile",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_recordFile" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = static_cast< int >(val3);
-  result = (int)(arg1)->recordFile(arg2,arg3);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_recordFile",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_recordFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_recordFile" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  result = (int)(arg1)->recordFile(arg2);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_recordFile(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[6];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_CoreSession_recordFile__SWIG_3(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_CoreSession_recordFile__SWIG_2(self, args);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
-          if (_v) {
-            return _wrap_CoreSession_recordFile__SWIG_1(self, args);
-          }
-        }
-      }
-    }
-  }
-  if (argc == 5) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
-          if (_v) {
-            {
-              int res = SWIG_AsVal_int(argv[4], NULL);
-              _v = SWIG_CheckState(res);
-            }
-            if (_v) {
-              return _wrap_CoreSession_recordFile__SWIG_0(self, args);
-            }
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_recordFile'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    recordFile(CoreSession *,char *,int,int,int)\n"
-    "    recordFile(CoreSession *,char *,int,int)\n"
-    "    recordFile(CoreSession *,char *,int)\n"
-    "    recordFile(CoreSession *,char *)\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_originate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_originate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   CoreSession *arg2 = (CoreSession *) 0 ;
   char *arg3 = (char *) 0 ;
-  int arg4 ;
-  switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) 0 ;
+  int arg4 = (int) 60 ;
+  switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) NULL ;
   int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -7380,7 +6338,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_originate__SWIG_0(PyObject *SWIGUNUSEDPAR
   PyObject * obj3 = 0 ;
   PyObject * obj4 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:CoreSession_originate",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:CoreSession_originate",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_originate" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -7396,16 +6354,20 @@ SWIGINTERN PyObject *_wrap_CoreSession_originate__SWIG_0(PyObject *SWIGUNUSEDPAR
     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_originate" "', argument " "3"" of type '" "char *""'");
   }
   arg3 = reinterpret_cast< char * >(buf3);
-  ecode4 = SWIG_AsVal_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_originate" "', argument " "4"" of type '" "int""'");
-  } 
-  arg4 = static_cast< int >(val4);
-  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_switch_state_handler_table_t, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_originate" "', argument " "5"" of type '" "switch_state_handler_table_t *""'"); 
+  if (obj3) {
+    ecode4 = SWIG_AsVal_int(obj3, &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_originate" "', argument " "4"" of type '" "int""'");
+    } 
+    arg4 = static_cast< int >(val4);
+  }
+  if (obj4) {
+    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_switch_state_handler_table_t, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoreSession_originate" "', argument " "5"" of type '" "switch_state_handler_table_t *""'"); 
+    }
+    arg5 = reinterpret_cast< switch_state_handler_table_t * >(argp5);
   }
-  arg5 = reinterpret_cast< switch_state_handler_table_t * >(argp5);
   result = (int)(arg1)->originate(arg2,arg3,arg4,arg5);
   resultobj = SWIG_From_int(static_cast< int >(result));
   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
@@ -7416,193 +6378,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_originate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  CoreSession *arg2 = (CoreSession *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int arg4 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  int res3 ;
-  char *buf3 = 0 ;
-  int alloc3 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:CoreSession_originate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_originate" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_originate" "', argument " "2"" of type '" "CoreSession *""'"); 
-  }
-  arg2 = reinterpret_cast< CoreSession * >(argp2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_originate" "', argument " "3"" of type '" "char *""'");
-  }
-  arg3 = reinterpret_cast< char * >(buf3);
-  ecode4 = SWIG_AsVal_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_originate" "', argument " "4"" of type '" "int""'");
-  } 
-  arg4 = static_cast< int >(val4);
-  result = (int)(arg1)->originate(arg2,arg3,arg4);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return resultobj;
-fail:
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_originate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  CoreSession *arg2 = (CoreSession *) 0 ;
-  char *arg3 = (char *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  int res3 ;
-  char *buf3 = 0 ;
-  int alloc3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_originate",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_originate" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_originate" "', argument " "2"" of type '" "CoreSession *""'"); 
-  }
-  arg2 = reinterpret_cast< CoreSession * >(argp2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_originate" "', argument " "3"" of type '" "char *""'");
-  }
-  arg3 = reinterpret_cast< char * >(buf3);
-  result = (int)(arg1)->originate(arg2,arg3);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return resultobj;
-fail:
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_originate(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[6];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CoreSession, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_CoreSession_originate__SWIG_2(self, args);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CoreSession, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
-          if (_v) {
-            return _wrap_CoreSession_originate__SWIG_1(self, args);
-          }
-        }
-      }
-    }
-  }
-  if (argc == 5) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CoreSession, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
-          if (_v) {
-            void *vptr = 0;
-            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_switch_state_handler_table_t, 0);
-            _v = SWIG_CheckState(res);
-            if (_v) {
-              return _wrap_CoreSession_originate__SWIG_0(self, args);
-            }
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_originate'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    originate(CoreSession *,CoreSession *,char *,int,switch_state_handler_table_t *)\n"
-    "    originate(CoreSession *,CoreSession *,char *,int)\n"
-    "    originate(CoreSession *,CoreSession *,char *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_CoreSession_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -8059,12 +6834,12 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_transfer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_transfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
+  char *arg4 = (char *) NULL ;
   int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -8082,7 +6857,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_transfer__SWIG_0(PyObject *SWIGUNUSEDPARM
   PyObject * obj2 = 0 ;
   PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:CoreSession_transfer",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|OO:CoreSession_transfer",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_transfer" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -8093,16 +6868,20 @@ SWIGINTERN PyObject *_wrap_CoreSession_transfer__SWIG_0(PyObject *SWIGUNUSEDPARM
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_transfer" "', argument " "2"" of type '" "char *""'");
   }
   arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_transfer" "', argument " "3"" of type '" "char *""'");
+  if (obj2) {
+    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_transfer" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
   }
-  arg3 = reinterpret_cast< char * >(buf3);
-  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_transfer" "', argument " "4"" of type '" "char *""'");
+  if (obj3) {
+    res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoreSession_transfer" "', argument " "4"" of type '" "char *""'");
+    }
+    arg4 = reinterpret_cast< char * >(buf4);
   }
-  arg4 = reinterpret_cast< char * >(buf4);
   result = (int)(arg1)->transfer(arg2,arg3,arg4);
   resultobj = SWIG_From_int(static_cast< int >(result));
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -8117,158 +6896,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_transfer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 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 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_transfer",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_transfer" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_transfer" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_transfer" "', argument " "3"" of type '" "char *""'");
-  }
-  arg3 = reinterpret_cast< char * >(buf3);
-  result = (int)(arg1)->transfer(arg2,arg3);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_transfer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_transfer",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_transfer" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_transfer" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  result = (int)(arg1)->transfer(arg2);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_transfer(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[5];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_CoreSession_transfer__SWIG_2(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_CoreSession_transfer__SWIG_1(self, args);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
-          _v = SWIG_CheckState(res);
-          if (_v) {
-            return _wrap_CoreSession_transfer__SWIG_0(self, args);
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_transfer'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    transfer(CoreSession *,char *,char *,char *)\n"
-    "    transfer(CoreSession *,char *,char *)\n"
-    "    transfer(CoreSession *,char *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_CoreSession_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -8342,7 +6969,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
@@ -8353,7 +6980,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits__SWIG_0(PyObject *SWIGUN
   char *arg7 = (char *) 0 ;
   char *arg8 = (char *) 0 ;
   char *arg9 = (char *) 0 ;
-  char *arg10 = (char *) 0 ;
+  char *arg10 = (char *) NULL ;
   char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -8391,7 +7018,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits__SWIG_0(PyObject *SWIGUN
   PyObject * obj8 = 0 ;
   PyObject * obj9 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:CoreSession_playAndGetDigits",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|O:CoreSession_playAndGetDigits",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_playAndGetDigits" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -8437,11 +7064,13 @@ SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits__SWIG_0(PyObject *SWIGUN
     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CoreSession_playAndGetDigits" "', argument " "9"" of type '" "char *""'");
   }
   arg9 = reinterpret_cast< char * >(buf9);
-  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CoreSession_playAndGetDigits" "', argument " "10"" of type '" "char const *""'");
+  if (obj9) {
+    res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
+    if (!SWIG_IsOK(res10)) {
+      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CoreSession_playAndGetDigits" "', argument " "10"" of type '" "char const *""'");
+    }
+    arg10 = reinterpret_cast< char * >(buf10);
   }
-  arg10 = reinterpret_cast< char * >(buf10);
   result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
   resultobj = SWIG_FromCharPtr((const char *)result);
   if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
@@ -8460,239 +7089,11 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  int arg2 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
-  char *arg6 = (char *) 0 ;
-  char *arg7 = (char *) 0 ;
-  char *arg8 = (char *) 0 ;
-  char *arg9 = (char *) 0 ;
-  char *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
-  int val5 ;
-  int ecode5 = 0 ;
-  int res6 ;
-  char *buf6 = 0 ;
-  int alloc6 = 0 ;
-  int res7 ;
-  char *buf7 = 0 ;
-  int alloc7 = 0 ;
-  int res8 ;
-  char *buf8 = 0 ;
-  int alloc8 = 0 ;
-  int res9 ;
-  char *buf9 = 0 ;
-  int alloc9 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
-  PyObject * obj6 = 0 ;
-  PyObject * obj7 = 0 ;
-  PyObject * obj8 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CoreSession_playAndGetDigits",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_playAndGetDigits" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  ecode2 = SWIG_AsVal_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_playAndGetDigits" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = static_cast< int >(val2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_playAndGetDigits" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = static_cast< int >(val3);
-  ecode4 = SWIG_AsVal_int(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoreSession_playAndGetDigits" "', argument " "4"" of type '" "int""'");
-  } 
-  arg4 = static_cast< int >(val4);
-  ecode5 = SWIG_AsVal_int(obj4, &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CoreSession_playAndGetDigits" "', argument " "5"" of type '" "int""'");
-  } 
-  arg5 = static_cast< int >(val5);
-  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoreSession_playAndGetDigits" "', argument " "6"" of type '" "char *""'");
-  }
-  arg6 = reinterpret_cast< char * >(buf6);
-  res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
-  if (!SWIG_IsOK(res7)) {
-    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CoreSession_playAndGetDigits" "', argument " "7"" of type '" "char *""'");
-  }
-  arg7 = reinterpret_cast< char * >(buf7);
-  res8 = SWIG_AsCharPtrAndSize(obj7, &buf8, NULL, &alloc8);
-  if (!SWIG_IsOK(res8)) {
-    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CoreSession_playAndGetDigits" "', argument " "8"" of type '" "char *""'");
-  }
-  arg8 = reinterpret_cast< char * >(buf8);
-  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
-  if (!SWIG_IsOK(res9)) {
-    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CoreSession_playAndGetDigits" "', argument " "9"" of type '" "char *""'");
-  }
-  arg9 = reinterpret_cast< char * >(buf9);
-  result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
-  resultobj = SWIG_FromCharPtr((const char *)result);
-  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
-  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
-  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
-  return resultobj;
-fail:
-  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
-  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
-  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[11];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 10); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 9) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_int(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
-          if (_v) {
-            {
-              int res = SWIG_AsVal_int(argv[4], NULL);
-              _v = SWIG_CheckState(res);
-            }
-            if (_v) {
-              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
-              _v = SWIG_CheckState(res);
-              if (_v) {
-                int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
-                _v = SWIG_CheckState(res);
-                if (_v) {
-                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
-                  _v = SWIG_CheckState(res);
-                  if (_v) {
-                    int res = SWIG_AsCharPtrAndSize(argv[8], 0, NULL, 0);
-                    _v = SWIG_CheckState(res);
-                    if (_v) {
-                      return _wrap_CoreSession_playAndGetDigits__SWIG_1(self, args);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  if (argc == 10) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_int(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          {
-            int res = SWIG_AsVal_int(argv[3], NULL);
-            _v = SWIG_CheckState(res);
-          }
-          if (_v) {
-            {
-              int res = SWIG_AsVal_int(argv[4], NULL);
-              _v = SWIG_CheckState(res);
-            }
-            if (_v) {
-              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
-              _v = SWIG_CheckState(res);
-              if (_v) {
-                int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
-                _v = SWIG_CheckState(res);
-                if (_v) {
-                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
-                  _v = SWIG_CheckState(res);
-                  if (_v) {
-                    int res = SWIG_AsCharPtrAndSize(argv[8], 0, NULL, 0);
-                    _v = SWIG_CheckState(res);
-                    if (_v) {
-                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
-                      _v = SWIG_CheckState(res);
-                      if (_v) {
-                        return _wrap_CoreSession_playAndGetDigits__SWIG_0(self, args);
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_playAndGetDigits'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    playAndGetDigits(CoreSession *,int,int,int,int,char *,char *,char *,char *,char const *)\n"
-    "    playAndGetDigits(CoreSession *,int,int,int,int,char *,char *,char *,char *)\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_streamFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_streamFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  int arg3 ;
+  int arg3 = (int) 0 ;
   int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -8705,7 +7106,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_streamFile__SWIG_0(PyObject *SWIGUNUSEDPA
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_streamFile",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|O:CoreSession_streamFile",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_streamFile" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -8716,11 +7117,13 @@ SWIGINTERN PyObject *_wrap_CoreSession_streamFile__SWIG_0(PyObject *SWIGUNUSEDPA
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_streamFile" "', argument " "2"" of type '" "char *""'");
   }
   arg2 = reinterpret_cast< char * >(buf2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_streamFile" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = static_cast< int >(val3);
+  if (obj2) {
+    ecode3 = SWIG_AsVal_int(obj2, &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_streamFile" "', argument " "3"" of type '" "int""'");
+    } 
+    arg3 = static_cast< int >(val3);
+  }
   result = (int)(arg1)->streamFile(arg2,arg3);
   resultobj = SWIG_From_int(static_cast< int >(result));
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -8731,97 +7134,11 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_streamFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_streamFile",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_streamFile" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_streamFile" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  result = (int)(arg1)->streamFile(arg2);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_streamFile(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[4];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_CoreSession_streamFile__SWIG_1(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_CoreSession_streamFile__SWIG_0(self, args);
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_streamFile'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    streamFile(CoreSession *,char *,int)\n"
-    "    streamFile(CoreSession *,char *)\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_sleep__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
-  int arg3 ;
+  int arg3 = (int) 0 ;
   int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -8833,7 +7150,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_sleep__SWIG_0(PyObject *SWIGUNUSEDPARM(se
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_sleep",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|O:CoreSession_sleep",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sleep" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -8844,11 +7161,13 @@ SWIGINTERN PyObject *_wrap_CoreSession_sleep__SWIG_0(PyObject *SWIGUNUSEDPARM(se
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_sleep" "', argument " "2"" of type '" "int""'");
   } 
   arg2 = static_cast< int >(val2);
-  ecode3 = SWIG_AsVal_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_sleep" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = static_cast< int >(val3);
+  if (obj2) {
+    ecode3 = SWIG_AsVal_int(obj2, &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoreSession_sleep" "', argument " "3"" of type '" "int""'");
+    } 
+    arg3 = static_cast< int >(val3);
+  }
   result = (int)(arg1)->sleep(arg2,arg3);
   resultobj = SWIG_From_int(static_cast< int >(result));
   return resultobj;
@@ -8857,93 +7176,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_sleep__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  int arg2 ;
-  int result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_sleep",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_sleep" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  ecode2 = SWIG_AsVal_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoreSession_sleep" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = static_cast< int >(val2);
-  result = (int)(arg1)->sleep(arg2);
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_sleep(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[4];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_int(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_CoreSession_sleep__SWIG_1(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      {
-        int res = SWIG_AsVal_int(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_CoreSession_sleep__SWIG_0(self, args);
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_sleep'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    sleep(CoreSession *,int,int)\n"
-    "    sleep(CoreSession *,int)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_CoreSession_flushEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -9165,11 +7397,11 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_execute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 ;
@@ -9182,7 +7414,7 @@ SWIGINTERN PyObject *_wrap_CoreSession_execute__SWIG_0(PyObject *SWIGUNUSEDPARM(
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:CoreSession_execute",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO|O:CoreSession_execute",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_execute" "', argument " "1"" of type '" "CoreSession *""'"); 
@@ -9193,11 +7425,13 @@ SWIGINTERN PyObject *_wrap_CoreSession_execute__SWIG_0(PyObject *SWIGUNUSEDPARM(
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_execute" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = reinterpret_cast< char * >(buf2);
-  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_execute" "', argument " "3"" of type '" "char const *""'");
+  if (obj2) {
+    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoreSession_execute" "', argument " "3"" of type '" "char const *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
   }
-  arg3 = reinterpret_cast< char * >(buf3);
   (arg1)->execute((char const *)arg2,(char const *)arg3);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -9210,89 +7444,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_CoreSession_execute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  CoreSession *arg1 = (CoreSession *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:CoreSession_execute",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoreSession, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoreSession_execute" "', argument " "1"" of type '" "CoreSession *""'"); 
-  }
-  arg1 = reinterpret_cast< CoreSession * >(argp1);
-  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoreSession_execute" "', argument " "2"" of type '" "char const *""'");
-  }
-  arg2 = reinterpret_cast< char * >(buf2);
-  (arg1)->execute((char const *)arg2);
-  resultobj = SWIG_Py_Void();
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return resultobj;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_CoreSession_execute(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[4];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = (int)PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_CoreSession_execute__SWIG_1(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CoreSession, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_CoreSession_execute__SWIG_0(self, args);
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CoreSession_execute'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    execute(CoreSession *,char const *,char const *)\n"
-    "    execute(CoreSession *,char const *)\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_CoreSession_sendEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   CoreSession *arg1 = (CoreSession *) 0 ;
@@ -10585,8 +8736,6 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"EventConsumer_events_get", _wrap_EventConsumer_events_get, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_e_event_id_set", _wrap_EventConsumer_e_event_id_set, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_e_event_id_get", _wrap_EventConsumer_e_event_id_get, METH_VARARGS, NULL},
-	 { (char *)"EventConsumer_node_set", _wrap_EventConsumer_node_set, METH_VARARGS, NULL},
-	 { (char *)"EventConsumer_node_get", _wrap_EventConsumer_node_get, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_e_callback_set", _wrap_EventConsumer_e_callback_set, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_e_callback_get", _wrap_EventConsumer_e_callback_get, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_e_subclass_name_set", _wrap_EventConsumer_e_subclass_name_set, METH_VARARGS, NULL},
@@ -10595,6 +8744,7 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"EventConsumer_e_cb_arg_get", _wrap_EventConsumer_e_cb_arg_get, METH_VARARGS, NULL},
 	 { (char *)"new_EventConsumer", _wrap_new_EventConsumer, METH_VARARGS, NULL},
 	 { (char *)"delete_EventConsumer", _wrap_delete_EventConsumer, METH_VARARGS, NULL},
+	 { (char *)"EventConsumer_bind", _wrap_EventConsumer_bind, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_pop", _wrap_EventConsumer_pop, METH_VARARGS, NULL},
 	 { (char *)"EventConsumer_swigregister", EventConsumer_swigregister, METH_VARARGS, NULL},
 	 { (char *)"delete_CoreSession", _wrap_delete_CoreSession, METH_VARARGS, NULL},
@@ -10716,7 +8866,6 @@ static swig_type_info _swigt__p_switch_call_cause_t = {"_p_switch_call_cause_t",
 static swig_type_info _swigt__p_switch_channel_state_t = {"_p_switch_channel_state_t", "switch_channel_state_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_event_node_t = {"_p_switch_event_node_t", "switch_event_node_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_event_t = {"_p_switch_event_t", "switch_event_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_event_types_t = {"_p_switch_event_types_t", "switch_event_types_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_switch_input_args_t = {"_p_switch_input_args_t", "switch_input_args_t *", 0, 0, (void*)0, 0};
@@ -10745,7 +8894,6 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_switch_channel_state_t,
   &_swigt__p_switch_channel_t,
   &_swigt__p_switch_core_session_t,
-  &_swigt__p_switch_event_node_t,
   &_swigt__p_switch_event_t,
   &_swigt__p_switch_event_types_t,
   &_swigt__p_switch_input_args_t,
@@ -10774,7 +8922,6 @@ static swig_cast_info _swigc__p_switch_call_cause_t[] = {  {&_swigt__p_switch_ca
 static swig_cast_info _swigc__p_switch_channel_state_t[] = {  {&_swigt__p_switch_channel_state_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_event_node_t[] = {  {&_swigt__p_switch_event_node_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_event_t[] = {  {&_swigt__p_switch_event_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_event_types_t[] = {  {&_swigt__p_switch_event_types_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_switch_input_args_t[] = {  {&_swigt__p_switch_input_args_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -10803,7 +8950,6 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_switch_channel_state_t,
   _swigc__p_switch_channel_t,
   _swigc__p_switch_core_session_t,
-  _swigc__p_switch_event_node_t,
   _swigc__p_switch_event_t,
   _swigc__p_switch_event_types_t,
   _swigc__p_switch_input_args_t,
diff --git a/src/mod/languages/mod_python/mod_python_wrap.cpp.rej b/src/mod/languages/mod_python/mod_python_wrap.cpp.rej
new file mode 100644
index 0000000000..80c9bbaace
--- /dev/null
+++ b/src/mod/languages/mod_python/mod_python_wrap.cpp.rej
@@ -0,0 +1,38 @@
+***************
+*** 5555,5561 ****
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventConsumer_pop" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+    result = (Event *)(arg1)->pop(arg2);
+    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
+    return resultobj;
+  fail:
+--- 5555,5563 ----
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventConsumer_pop" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
++   Py_BEGIN_ALLOW_THREADS;
+    result = (Event *)(arg1)->pop(arg2);
++   Py_END_ALLOW_THREADS;
+    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
+    return resultobj;
+  fail:
+***************
+*** 5577,5583 ****
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_pop" "', argument " "1"" of type '" "EventConsumer *""'"); 
+    }
+    arg1 = reinterpret_cast< EventConsumer * >(argp1);
+    result = (Event *)(arg1)->pop();
+    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
+    return resultobj;
+  fail:
+--- 5579,5587 ----
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_pop" "', argument " "1"" of type '" "EventConsumer *""'"); 
+    }
+    arg1 = reinterpret_cast< EventConsumer * >(argp1);
++   Py_BEGIN_ALLOW_THREADS;
+    result = (Event *)(arg1)->pop();
++   Py_END_ALLOW_THREADS;
+    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
+    return resultobj;
+  fail:
diff --git a/src/switch_core.c.orig b/src/switch_core.c.orig
new file mode 100644
index 0000000000..fe0ffcbaba
--- /dev/null
+++ b/src/switch_core.c.orig
@@ -0,0 +1,2018 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ * Copyright (C) 2005-2010, Anthony Minessale II <anthm@freeswitch.org>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Michael Jerris <mike@jerris.com>
+ * Paul D. Tinsley <pdt at jackhammer.org>
+ * Marcel Barbulescu <marcelbarbulescu@gmail.com>
+ *
+ *
+ * switch_core.c -- Main Core Library
+ *
+ */
+
+
+
+#include <switch.h>
+#include <switch_stun.h>
+#include <switch_nat.h>
+#include <switch_version.h>
+#include "private/switch_core_pvt.h"
+#ifndef WIN32
+#include <switch_private.h>
+#ifdef HAVE_SETRLIMIT
+#include <sys/resource.h>
+#endif
+#endif
+#include <errno.h>
+
+
+SWITCH_DECLARE_DATA switch_directories SWITCH_GLOBAL_dirs = { 0 };
+
+/* The main runtime obj we keep this hidden for ourselves */
+struct switch_runtime runtime = { 0 };
+static void switch_load_core_config(const char *file);
+
+static void send_heartbeat(void)
+{
+	switch_event_t *event;
+	switch_core_time_duration_t duration;
+
+	switch_core_measure_time(switch_core_uptime(), &duration);
+
+	if (switch_event_create(&event, SWITCH_EVENT_HEARTBEAT) == SWITCH_STATUS_SUCCESS) {
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Ready");
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Up-Time",
+								"%u year%s, "
+								"%u day%s, "
+								"%u hour%s, "
+								"%u minute%s, "
+								"%u second%s, "
+								"%u millisecond%s, "
+								"%u microsecond%s",
+								duration.yr, duration.yr == 1 ? "" : "s",
+								duration.day, duration.day == 1 ? "" : "s",
+								duration.hr, duration.hr == 1 ? "" : "s",
+								duration.min, duration.min == 1 ? "" : "s",
+								duration.sec, duration.sec == 1 ? "" : "s",
+								duration.ms, duration.ms == 1 ? "" : "s", duration.mms, duration.mms == 1 ? "" : "s");
+
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Count", "%u", switch_core_session_count());
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec", "%u", runtime.sps);
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Since-Startup", "%" SWITCH_SIZE_T_FMT, switch_core_session_id() - 1);
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Idle-CPU", "%f", switch_core_idle_cpu());
+		switch_event_fire(&event);
+	}
+}
+
+static char main_ip4[256] = "";
+static char main_ip6[256] = "";
+
+static void check_ip(void)
+{
+	char guess_ip4[256] = "";
+	char guess_ip6[256] = "";
+	char old_ip4[256] = "";
+	char old_ip6[256] = "";
+	int ok4 = 1, ok6 = 1;
+	int mask = 0;
+	static char hostname[256] = "";
+
+	gethostname(hostname, sizeof(hostname));
+	switch_core_set_variable("hostname", hostname);
+
+	switch_find_local_ip(guess_ip4, sizeof(guess_ip4), &mask, AF_INET);
+	switch_find_local_ip(guess_ip6, sizeof(guess_ip6), NULL, AF_INET6);
+
+	if (!*main_ip4) {
+		switch_set_string(main_ip4, guess_ip4);
+	} else {
+		if (!(ok4 = !strcmp(main_ip4, guess_ip4))) {
+			struct in_addr in;
+
+			in.s_addr = mask;
+			switch_set_string(old_ip4, main_ip4);
+			switch_set_string(main_ip4, guess_ip4);
+			switch_core_set_variable("local_ip_v4", guess_ip4);
+			switch_core_set_variable("local_mask_v4", inet_ntoa(in));
+		}
+	}
+
+	if (!*main_ip6) {
+		switch_set_string(main_ip6, guess_ip6);
+	} else {
+		if (!(ok6 = !strcmp(main_ip6, guess_ip6))) {
+			switch_set_string(old_ip6, main_ip6);
+			switch_set_string(main_ip6, guess_ip6);
+			switch_core_set_variable("local_ip_v6", guess_ip6);
+		}
+	}
+
+	if (!ok4 || !ok6) {
+		switch_event_t *event;
+
+		if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "network-address-change");
+			if (!ok4) {
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-previous-v4", old_ip4);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-change-v4", main_ip4);
+			}
+			if (!ok6) {
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-previous-v6", old_ip6);
+				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-change-v6", main_ip6);
+			}
+			switch_event_fire(&event);
+		}
+	}
+}
+
+SWITCH_STANDARD_SCHED_FUNC(heartbeat_callback)
+{
+	send_heartbeat();
+	check_ip();
+
+	/* reschedule this task */
+	task->runtime = switch_epoch_time_now(NULL) + 20;
+}
+
+
+SWITCH_DECLARE(switch_status_t) switch_core_set_console(const char *console)
+{
+	if ((runtime.console = fopen(console, "a")) == 0) {
+		fprintf(stderr, "Cannot open output file %s.\n", console);
+		return SWITCH_STATUS_FALSE;
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(FILE *) switch_core_get_console(void)
+{
+	return runtime.console;
+}
+
+SWITCH_DECLARE(FILE *) switch_core_data_channel(switch_text_channel_t channel)
+{
+	FILE *handle = stdout;
+
+	switch (channel) {
+	case SWITCH_CHANNEL_ID_LOG:
+	case SWITCH_CHANNEL_ID_LOG_CLEAN:
+		handle = runtime.console;
+		break;
+	default:
+		handle = runtime.console;
+		break;
+	}
+
+	return handle;
+}
+
+SWITCH_DECLARE(void) switch_core_remove_state_handler(const switch_state_handler_table_t *state_handler)
+{
+	int index, tmp_index = 0;
+	const switch_state_handler_table_t *tmp[SWITCH_MAX_STATE_HANDLERS + 1] = { 0 };
+
+	switch_mutex_lock(runtime.global_mutex);
+
+	for (index = 0; index < runtime.state_handler_index; index++) {
+		const switch_state_handler_table_t *cur = runtime.state_handlers[index];
+		runtime.state_handlers[index] = NULL;
+		if (cur == state_handler) {
+			continue;
+		}
+		tmp[tmp_index++] = cur;
+	}
+
+	runtime.state_handler_index = 0;
+
+	for (index = 0; index < tmp_index; index++) {
+		runtime.state_handlers[runtime.state_handler_index++] = tmp[index];
+	}
+	switch_mutex_unlock(runtime.global_mutex);
+}
+
+
+SWITCH_DECLARE(int) switch_core_add_state_handler(const switch_state_handler_table_t *state_handler)
+{
+	int index;
+
+	switch_mutex_lock(runtime.global_mutex);
+	index = runtime.state_handler_index++;
+
+	if (runtime.state_handler_index >= SWITCH_MAX_STATE_HANDLERS) {
+		index = -1;
+	} else {
+		runtime.state_handlers[index] = state_handler;
+	}
+
+	switch_mutex_unlock(runtime.global_mutex);
+	return index;
+}
+
+SWITCH_DECLARE(const switch_state_handler_table_t *) switch_core_get_state_handler(int index)
+{
+
+	if (index >= SWITCH_MAX_STATE_HANDLERS || index > runtime.state_handler_index) {
+		return NULL;
+	}
+
+	return runtime.state_handlers[index];
+}
+
+SWITCH_DECLARE(void) switch_core_dump_variables(switch_stream_handle_t *stream)
+{
+	switch_hash_index_t *hi;
+	const void *var;
+	void *val;
+	switch_mutex_lock(runtime.global_mutex);
+	for (hi = switch_hash_first(NULL, runtime.global_vars); hi; hi = switch_hash_next(hi)) {
+		char *vvar, *vval;
+		switch_hash_this(hi, &var, NULL, &val);
+		vvar = (char *) var;
+		vval = (char *) val;
+		stream->write_function(stream, "%s=%s\n", vvar, vval);
+	}
+	switch_mutex_unlock(runtime.global_mutex);
+}
+
+SWITCH_DECLARE(char *) switch_core_get_variable(const char *varname)
+{
+	char *val;
+	switch_mutex_lock(runtime.global_var_mutex);
+	val = (char *) switch_core_hash_find(runtime.global_vars, varname);
+	switch_mutex_unlock(runtime.global_var_mutex);
+	return val;
+}
+
+static void switch_core_unset_variables(void)
+{
+	switch_hash_index_t *hi;
+	const void *var;
+	void *val;
+
+	switch_mutex_lock(runtime.global_var_mutex);
+	for (hi = switch_hash_first(NULL, runtime.global_vars); hi; hi = switch_hash_next(hi)) {
+		switch_hash_this(hi, &var, NULL, &val);
+		free(val);
+	}
+	switch_mutex_unlock(runtime.global_var_mutex);
+}
+
+SWITCH_DECLARE(void) switch_core_set_variable(const char *varname, const char *value)
+{
+	char *val;
+
+	if (varname) {
+		switch_mutex_lock(runtime.global_var_mutex);
+		val = (char *) switch_core_hash_find(runtime.global_vars, varname);
+		if (val) {
+			free(val);
+		}
+		if (value) {
+			char *v = strdup(value);
+			switch_string_var_check(v, SWITCH_TRUE);
+			switch_core_hash_insert(runtime.global_vars, varname, v);
+		} else {
+			switch_core_hash_delete(runtime.global_vars, varname);
+		}
+		switch_mutex_unlock(runtime.global_var_mutex);
+	}
+}
+
+SWITCH_DECLARE(char *) switch_core_get_uuid(void)
+{
+	return runtime.uuid_str;
+}
+
+
+static void *SWITCH_THREAD_FUNC switch_core_service_thread(switch_thread_t *thread, void *obj)
+{
+	switch_core_session_t *session = obj;
+	switch_channel_t *channel;
+	switch_frame_t *read_frame;
+
+//  switch_assert(thread != NULL);
+//  switch_assert(session != NULL);
+
+	if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
+		return NULL;
+	}
+
+	switch_mutex_lock(session->frame_read_mutex);
+
+	channel = switch_core_session_get_channel(session);
+
+	switch_channel_set_flag(channel, CF_SERVICE);
+	while (switch_channel_test_flag(channel, CF_SERVICE)) {
+		switch (switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0)) {
+		case SWITCH_STATUS_SUCCESS:
+		case SWITCH_STATUS_TIMEOUT:
+		case SWITCH_STATUS_BREAK:
+			break;
+		default:
+			switch_channel_clear_flag(channel, CF_SERVICE);
+			continue;
+		}
+	}
+
+	switch_mutex_unlock(session->frame_read_mutex);
+
+	switch_core_session_rwunlock(session);
+
+	return NULL;
+}
+
+/* Either add a timeout here or make damn sure the thread cannot get hung somehow (my preference) */
+SWITCH_DECLARE(void) switch_core_thread_session_end(switch_core_session_t *session)
+{
+	switch_channel_t *channel;
+	switch_assert(session);
+
+	channel = switch_core_session_get_channel(session);
+	switch_assert(channel);
+
+	switch_channel_clear_flag(channel, CF_SERVICE);
+}
+
+SWITCH_DECLARE(void) switch_core_service_session(switch_core_session_t *session)
+{
+	switch_channel_t *channel;
+	switch_assert(session);
+
+	channel = switch_core_session_get_channel(session);
+	switch_assert(channel);
+
+	switch_core_session_launch_thread(session, (void *(*)(switch_thread_t *,void *))switch_core_service_thread, session);
+}
+
+/* This function abstracts the thread creation for modules by allowing you to pass a function ptr and
+   a void object and trust that that the function will be run in a thread with arg  This lets
+   you request and activate a thread without giving up any knowledge about what is in the thread
+   neither the core nor the calling module know anything about each other.
+
+   This thread is expected to never exit until the application exits so the func is responsible
+   to make sure that is the case.
+
+   The typical use for this is so switch_loadable_module.c can start up a thread for each module
+   passing the table of module methods as a session obj into the core without actually allowing
+   the core to have any clue and keeping switch_loadable_module.c from needing any thread code.
+
+*/
+
+SWITCH_DECLARE(switch_thread_t *) switch_core_launch_thread(switch_thread_start_t func, void *obj, switch_memory_pool_t *pool)
+{
+	switch_thread_t *thread = NULL;
+	switch_threadattr_t *thd_attr = NULL;
+	switch_core_thread_session_t *ts;
+	int mypool;
+
+	mypool = pool ? 0 : 1;
+
+	if (!pool && switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory pool\n");
+		return NULL;
+	}
+
+	switch_threadattr_create(&thd_attr, pool);
+
+	if ((ts = switch_core_alloc(pool, sizeof(*ts))) == 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory\n");
+	} else {
+		if (mypool) {
+			ts->pool = pool;
+		}
+		ts->objs[0] = obj;
+		ts->objs[1] = thread;
+		switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+		switch_threadattr_priority_increase(thd_attr);
+		switch_thread_create(&thread, thd_attr, func, ts, pool);
+	}
+
+	return thread;
+}
+
+SWITCH_DECLARE(void) switch_core_set_globals(void)
+{
+#define BUFSIZE 1024
+#ifdef WIN32
+	char lpPathBuffer[BUFSIZE];
+	DWORD dwBufSize = BUFSIZE;
+	char base_dir[1024];
+	char *lastbacklash;
+	GetModuleFileName(NULL, base_dir, BUFSIZE);
+	lastbacklash = strrchr(base_dir, '\\');
+	base_dir[(lastbacklash - base_dir)] = '\0';
+#else
+	char base_dir[1024] = SWITCH_PREFIX_DIR;
+#endif
+
+	if (!SWITCH_GLOBAL_dirs.base_dir && (SWITCH_GLOBAL_dirs.base_dir = (char *) malloc(BUFSIZE))) {
+		switch_snprintf(SWITCH_GLOBAL_dirs.base_dir, BUFSIZE, "%s", base_dir);
+	}
+
+	if (!SWITCH_GLOBAL_dirs.mod_dir && (SWITCH_GLOBAL_dirs.mod_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_MOD_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s", SWITCH_MOD_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s%smod", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.conf_dir && (SWITCH_GLOBAL_dirs.conf_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_CONF_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s", SWITCH_CONF_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s%sconf", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.log_dir && (SWITCH_GLOBAL_dirs.log_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_LOG_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s", SWITCH_LOG_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s%slog", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.run_dir && (SWITCH_GLOBAL_dirs.run_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_RUN_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s", SWITCH_RUN_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s%srun", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.recordings_dir && (SWITCH_GLOBAL_dirs.recordings_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_RECORDINGS_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s", SWITCH_RECORDINGS_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s%srecordings", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.sounds_dir && (SWITCH_GLOBAL_dirs.sounds_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_SOUNDS_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s", SWITCH_SOUNDS_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s%ssounds", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.storage_dir && (SWITCH_GLOBAL_dirs.storage_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_STORAGE_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s", SWITCH_STORAGE_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s%sstorage", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.db_dir && (SWITCH_GLOBAL_dirs.db_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_DB_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s", SWITCH_DB_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s%sdb", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.script_dir && (SWITCH_GLOBAL_dirs.script_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_SCRIPT_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s", SWITCH_SCRIPT_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s%sscripts", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.htdocs_dir && (SWITCH_GLOBAL_dirs.htdocs_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_HTDOCS_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s", SWITCH_HTDOCS_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s%shtdocs", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.grammar_dir && (SWITCH_GLOBAL_dirs.grammar_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_GRAMMAR_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s", SWITCH_GRAMMAR_DIR);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s%sgrammar", base_dir, SWITCH_PATH_SEPARATOR);
+#endif
+	}
+
+	if (!SWITCH_GLOBAL_dirs.temp_dir && (SWITCH_GLOBAL_dirs.temp_dir = (char *) malloc(BUFSIZE))) {
+#ifdef SWITCH_TEMP_DIR
+		switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", SWITCH_TEMP_DIR);
+#else
+#ifdef WIN32
+		GetTempPath(dwBufSize, lpPathBuffer);
+		switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", lpPathBuffer);
+#else
+		switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", "/tmp/");
+#endif
+#endif
+	}
+
+	switch_assert(SWITCH_GLOBAL_dirs.base_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.mod_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.conf_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.log_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.run_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.db_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.script_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.htdocs_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.grammar_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.recordings_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.sounds_dir);
+	switch_assert(SWITCH_GLOBAL_dirs.temp_dir);
+}
+
+SWITCH_DECLARE(int32_t) set_high_priority(void)
+{
+#ifdef WIN32
+	SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
+#else
+
+#ifdef USE_SETRLIMIT
+	struct rlimit lim = { RLIM_INFINITY, RLIM_INFINITY };
+#endif
+
+#ifdef USE_SCHED_SETSCHEDULER
+	/*
+	 * Try to use a round-robin scheduler
+	 * with a fallback if that does not work
+	 */
+	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 HAVE_SETPRIORITY
+	/*
+	 * setpriority() works on FreeBSD (6.2), nice() doesn't
+	 */
+	if (setpriority(PRIO_PROCESS, getpid(), -10) < 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not set nice level\n");
+	}
+#else
+	if (nice(-10) != -10) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not set nice level\n");
+	}
+#endif
+
+#ifdef USE_SETRLIMIT
+	/*
+	 * The amount of memory which can be mlocked is limited for non-root users.
+	 * FS will segfault (= hitting the limit) soon after mlockall has been called
+	 * and we've switched to a different user.
+	 * So let's try to remove the mlock limit here...
+	 */
+	if (setrlimit(RLIMIT_MEMLOCK, &lim) < 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to disable memlock limit, application may crash if run as non-root user!\n");
+	}
+#endif
+
+#ifdef USE_MLOCKALL
+	/*
+	 * Pin memory pages to RAM to prevent being swapped to disk
+	 */
+	mlockall(MCL_CURRENT | MCL_FUTURE);
+#endif
+
+#endif
+	return 0;
+}
+
+SWITCH_DECLARE(int32_t) change_user_group(const char *user, const char *group)
+{
+#ifndef WIN32
+	uid_t runas_uid = 0;
+	gid_t runas_gid = 0;
+	struct passwd *runas_pw = NULL;
+
+	if (user) {
+		/*
+		 * Lookup user information in the system's db
+		 */
+		runas_pw = getpwnam(user);
+		if (!runas_pw) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unknown user \"%s\"\n", user);
+			return -1;
+		}
+		runas_uid = runas_pw->pw_uid;
+	}
+
+	if (group) {
+		struct group *gr = NULL;
+
+		/*
+		 * Lookup group information in the system's db
+		 */
+		gr = getgrnam(group);
+		if (!gr) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unknown group \"%s\"\n", group);
+			return -1;
+		}
+		runas_gid = gr->gr_gid;
+	}
+
+	if (runas_uid && getuid() == runas_uid && (!runas_gid || runas_gid == getgid())) {
+		/* already running as the right user and group, nothing to do! */
+		return 0;
+	}
+
+	if (runas_uid) {
+#ifdef HAVE_SETGROUPS
+		/*
+		 * Drop all group memberships prior to changing anything
+		 * or else we're going to inherit the parent's list of groups
+		 * (which is not what we want...)
+		 */
+		if (setgroups(0, NULL) < 0) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to drop group access list\n");
+			return -1;
+		}
+#endif
+		if (runas_gid) {
+			/*
+			 * A group has been passed, switch to it
+			 * (without loading the user's other groups)
+			 */
+			if (setgid(runas_gid) < 0) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to change gid!\n");
+				return -1;
+			}
+		} else {
+			/*
+			 * No group has been passed, use the user's primary group in this case
+			 */
+			if (setgid(runas_pw->pw_gid) < 0) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to change gid!\n");
+				return -1;
+			}
+#ifdef HAVE_INITGROUPS
+			/*
+			 * Set all the other groups the user is a member of
+			 * (This can be really useful for fine-grained access control)
+			 */
+			if (initgroups(runas_pw->pw_name, runas_pw->pw_gid) < 0) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to set group access list for user\n");
+				return -1;
+			}
+#endif
+		}
+
+		/*
+		 * Finally drop all privileges by switching to the new userid
+		 */
+		if (setuid(runas_uid) < 0) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to change uid!\n");
+			return -1;
+		}
+	}
+#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
+		switch_snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
+		shutdown_event = CreateEvent(NULL, FALSE, FALSE, path);
+		if (shutdown_event) {
+			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(const char *) switch_core_mime_ext2type(const char *ext)
+{
+	if (!ext) {
+		return NULL;
+	}
+	return (const char *) switch_core_hash_find(runtime.mime_types, ext);
+}
+
+
+SWITCH_DECLARE(switch_hash_index_t *) switch_core_mime_index(void)
+{
+	return switch_hash_first(NULL, runtime.mime_types);
+}
+
+SWITCH_DECLARE(switch_status_t) switch_core_mime_add_type(const char *type, const char *ext)
+{
+	const char *check;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+
+	switch_assert(type);
+	switch_assert(ext);
+
+	check = (const char *) switch_core_hash_find(runtime.mime_types, ext);
+
+	if (!check) {
+		char *ptype = switch_core_permanent_strdup(type);
+		char *ext_list = strdup(ext);
+		int argc = 0;
+		char *argv[20] = { 0 };
+		int x;
+
+		switch_assert(ext_list);
+
+		if ((argc = switch_separate_string(ext_list, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
+
+			for (x = 0; x < argc; x++) {
+				if (argv[x] && ptype) {
+					switch_core_hash_insert(runtime.mime_types, argv[x], ptype);
+				}
+			}
+
+			status = SWITCH_STATUS_SUCCESS;
+		}
+
+		free(ext_list);
+	}
+
+	return status;
+}
+
+static void load_mime_types(void)
+{
+	char *cf = "mime.types";
+	int fd = -1;
+	char line_buf[1024] = "";
+	char *mime_path = NULL;
+
+	mime_path = switch_mprintf("%s/%s", SWITCH_GLOBAL_dirs.conf_dir, cf);
+	switch_assert(mime_path);
+
+	fd = open(mime_path, O_RDONLY | O_BINARY);
+	if (fd <= 0) {
+		goto end;
+	}
+
+	while ((switch_fd_read_line(fd, line_buf, sizeof(line_buf)))) {
+		char *p;
+		char *type = line_buf;
+
+		if (*line_buf == '#') {
+			continue;
+		}
+
+		if ((p = strchr(line_buf, '\r')) || (p = strchr(line_buf, '\n'))) {
+			*p = '\0';
+		}
+
+		if ((p = strchr(type, '\t')) || (p = strchr(type, ' '))) {
+			*p++ = '\0';
+
+			while (*p == ' ' || *p == '\t') {
+				p++;
+			}
+
+			switch_core_mime_add_type(type, p);
+		}
+
+	}
+
+	if (fd > -1) {
+		close(fd);
+		fd = -1;
+	}
+
+  end:
+
+	switch_safe_free(mime_path);
+
+}
+
+SWITCH_DECLARE(void) switch_core_setrlimits(void)
+{
+#ifdef HAVE_SETRLIMIT
+	struct rlimit rlp;
+
+	/* 
+	   Setting the stack size on FreeBSD results in an instant crash.
+
+	   If anyone knows how to fix this,
+	   feel free to submit a patch to http://jira.freeswitch.org 
+	 */
+
+#ifndef __FreeBSD__
+	memset(&rlp, 0, sizeof(rlp));
+	rlp.rlim_cur = SWITCH_THREAD_STACKSIZE;
+	rlp.rlim_max = SWITCH_SYSTEM_THREAD_STACKSIZE;
+	setrlimit(RLIMIT_STACK, &rlp);
+#endif
+
+	memset(&rlp, 0, sizeof(rlp));
+	rlp.rlim_cur = 999999;
+	rlp.rlim_max = 999999;
+	setrlimit(RLIMIT_NOFILE, &rlp);
+
+	memset(&rlp, 0, sizeof(rlp));
+	rlp.rlim_cur = RLIM_INFINITY;
+	rlp.rlim_max = RLIM_INFINITY;
+
+	setrlimit(RLIMIT_CPU, &rlp);
+	setrlimit(RLIMIT_DATA, &rlp);
+	setrlimit(RLIMIT_FSIZE, &rlp);
+#ifdef RLIMIT_NPROC
+	setrlimit(RLIMIT_NPROC, &rlp);
+#endif
+#ifdef RLIMIT_RTPRIO
+	setrlimit(RLIMIT_RTPRIO, &rlp);
+#endif
+
+#if !defined(__OpenBSD__) && !defined(__NetBSD__)
+	setrlimit(RLIMIT_AS, &rlp);
+#endif
+#endif
+	return;
+}
+
+typedef struct {
+	switch_memory_pool_t *pool;
+	switch_hash_t *hash;
+} switch_ip_list_t;
+
+static switch_ip_list_t IP_LIST = { 0 };
+
+SWITCH_DECLARE(switch_bool_t) switch_check_network_list_ip_token(const char *ip_str, const char *list_name, const char **token)
+{
+	switch_network_list_t *list;
+	uint32_t ip, net, mask, bits;
+	switch_bool_t ok = SWITCH_FALSE;
+
+	switch_mutex_lock(runtime.global_mutex);
+	switch_inet_pton(AF_INET, ip_str, &ip);
+
+	ip = htonl(ip);
+
+	if ((list = switch_core_hash_find(IP_LIST.hash, list_name))) {
+		ok = switch_network_list_validate_ip_token(list, ip, token);
+	} else if (strchr(list_name, '/')) {
+		if (strchr(list_name, ',')) {
+			char *list_name_dup = strdup(list_name);
+			char *argv[32];
+			int argc;
+
+			switch_assert(list_name_dup);
+
+			if ((argc = switch_separate_string(list_name_dup, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
+				int i;
+				for (i = 0; i < argc; i++) {
+					switch_parse_cidr(argv[i], &net, &mask, &bits);
+					if ((ok = switch_test_subnet(ip, net, mask))) {
+						break;
+					}
+				}
+			}
+			free(list_name_dup);
+		} else {
+			switch_parse_cidr(list_name, &net, &mask, &bits);
+			ok = switch_test_subnet(ip, net, mask);
+		}
+	}
+	switch_mutex_unlock(runtime.global_mutex);
+
+	return ok;
+}
+
+
+SWITCH_DECLARE(void) switch_load_network_lists(switch_bool_t reload)
+{
+	switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, x_node = NULL, cfg = NULL;
+	switch_network_list_t *rfc_list, *list;
+	char guess_ip[16] = "";
+	int mask = 0;
+	char guess_mask[16] = "";
+	char *tmp_name;
+	struct in_addr in;
+
+	switch_find_local_ip(guess_ip, sizeof(guess_ip), &mask, AF_INET);
+	in.s_addr = mask;
+	switch_set_string(guess_mask, inet_ntoa(in));
+
+	switch_mutex_lock(runtime.global_mutex);
+
+	if (IP_LIST.hash) {
+		switch_core_hash_destroy(&IP_LIST.hash);
+	}
+
+	if (IP_LIST.pool) {
+		switch_core_destroy_memory_pool(&IP_LIST.pool);
+	}
+
+	memset(&IP_LIST, 0, sizeof(IP_LIST));
+	switch_core_new_memory_pool(&IP_LIST.pool);
+	switch_core_hash_init(&IP_LIST.hash, IP_LIST.pool);
+
+
+	tmp_name = "rfc1918.auto";
+	switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
+	switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_TRUE);
+	switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_TRUE);
+	switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_TRUE);
+	switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
+
+	tmp_name = "wan.auto";
+	switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
+	switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_FALSE);
+	switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_FALSE);
+	switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_FALSE);
+	switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
+
+	tmp_name = "nat.auto";
+	switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
+	if (switch_network_list_add_host_mask(rfc_list, guess_ip, guess_mask, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (deny) to list %s\n", guess_ip, guess_mask, tmp_name);
+	}
+	switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_TRUE);
+	switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_TRUE);
+	switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_TRUE);
+	switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
+
+	tmp_name = "loopback.auto";
+	switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
+	switch_network_list_add_cidr(rfc_list, "127.0.0.0/8", SWITCH_TRUE);
+	switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
+
+	tmp_name = "localnet.auto";
+	switch_network_list_create(&list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
+
+	if (switch_network_list_add_host_mask(list, guess_ip, guess_mask, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (allow) to list %s\n", guess_ip, guess_mask, tmp_name);
+	}
+	switch_core_hash_insert(IP_LIST.hash, tmp_name, list);
+
+
+	if ((xml = switch_xml_open_cfg("acl.conf", &cfg, NULL))) {
+		if ((x_lists = switch_xml_child(cfg, "network-lists"))) {
+			for (x_list = switch_xml_child(x_lists, "list"); x_list; x_list = x_list->next) {
+				const char *name = switch_xml_attr(x_list, "name");
+				const char *dft = switch_xml_attr(x_list, "default");
+				switch_bool_t default_type = SWITCH_TRUE;
+
+				if (zstr(name)) {
+					continue;
+				}
+
+				if (dft) {
+					default_type = switch_true(dft);
+				}
+
+				if (switch_network_list_create(&list, name, default_type, IP_LIST.pool) != SWITCH_STATUS_SUCCESS) {
+					abort();
+				}
+
+				if (reload) {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (%s)\n", name, default_type ? "allow" : "deny");
+				} else {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Created ip list %s default (%s)\n", name, default_type ? "allow" : "deny");
+				}
+
+
+				for (x_node = switch_xml_child(x_list, "node"); x_node; x_node = x_node->next) {
+					const char *cidr = NULL, *host = NULL, *mask = NULL, *domain = NULL;
+					switch_bool_t ok = default_type;
+					const char *type = switch_xml_attr(x_node, "type");
+
+					if (type) {
+						ok = switch_true(type);
+					}
+
+					cidr = switch_xml_attr(x_node, "cidr");
+					host = switch_xml_attr(x_node, "host");
+					mask = switch_xml_attr(x_node, "mask");
+					domain = switch_xml_attr(x_node, "domain");
+
+					if (domain) {
+						switch_event_t *my_params = NULL;
+						switch_xml_t x_domain, xml_root;
+						switch_xml_t gt, gts, ut, uts;
+
+						switch_event_create(&my_params, SWITCH_EVENT_GENERAL);
+						switch_assert(my_params);
+						switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "domain", domain);
+						switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "purpose", "network-list");
+
+						if (switch_xml_locate_domain(domain, my_params, &xml_root, &x_domain) != SWITCH_STATUS_SUCCESS) {
+							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Cannot locate domain %s\n", domain);
+							switch_event_destroy(&my_params);
+							continue;
+						}
+
+						switch_event_destroy(&my_params);
+
+						for (ut = switch_xml_child(x_domain, "user"); ut; ut = ut->next) {
+							const char *user_cidr = switch_xml_attr(ut, "cidr");
+							const char *id = switch_xml_attr(ut, "id");
+
+							if (id && user_cidr) {
+								char *token = switch_mprintf("%s@%s", id, domain);
+								switch_assert(token);
+								switch_network_list_add_cidr_token(list, user_cidr, ok, token);
+								free(token);
+							}
+						}
+
+						for (gts = switch_xml_child(x_domain, "groups"); gts; gts = gts->next) {
+							for (gt = switch_xml_child(gts, "group"); gt; gt = gt->next) {
+								for (uts = switch_xml_child(gt, "users"); uts; uts = uts->next) {
+									for (ut = switch_xml_child(uts, "user"); ut; ut = ut->next) {
+										const char *user_cidr = switch_xml_attr(ut, "cidr");
+										const char *id = switch_xml_attr(ut, "id");
+
+										if (id && user_cidr) {
+											char *token = switch_mprintf("%s@%s", id, domain);
+											switch_assert(token);
+											switch_network_list_add_cidr_token(list, user_cidr, ok, token);
+											free(token);
+										}
+									}
+								}
+							}
+						}
+
+						switch_xml_free(xml_root);
+					} else if (cidr) {
+						if (switch_network_list_add_cidr(list, cidr, ok) == SWITCH_STATUS_SUCCESS) {
+							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s (%s) to list %s\n", cidr, ok ? "allow" : "deny", name);
+						} else {
+							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+											  "Error Adding %s (%s) to list %s\n", cidr, ok ? "allow" : "deny", name);
+						}
+					} else if (host && mask) {
+						if (switch_network_list_add_host_mask(list, host, mask, ok) == SWITCH_STATUS_SUCCESS) {
+							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
+											  "Adding %s/%s (%s) to list %s\n", host, mask, ok ? "allow" : "deny", name);
+						}
+					}
+
+					switch_core_hash_insert(IP_LIST.hash, name, list);
+				}
+			}
+		}
+
+		switch_xml_free(xml);
+	}
+
+	switch_mutex_unlock(runtime.global_mutex);
+}
+
+SWITCH_DECLARE(uint32_t) switch_core_max_dtmf_duration(uint32_t duration)
+{
+	if (duration) {
+		if (duration > SWITCH_MAX_DTMF_DURATION) {
+			duration = SWITCH_MAX_DTMF_DURATION;
+		}
+		if (duration < SWITCH_MIN_DTMF_DURATION) {
+			duration = SWITCH_MIN_DTMF_DURATION;
+		}
+		runtime.max_dtmf_duration = duration;
+	}
+	return runtime.max_dtmf_duration;
+}
+
+SWITCH_DECLARE(uint32_t) switch_core_default_dtmf_duration(uint32_t duration)
+{
+	if (duration) {
+		if (duration < SWITCH_MIN_DTMF_DURATION) {
+			duration = SWITCH_MIN_DTMF_DURATION;
+		}
+		if (duration > SWITCH_MAX_DTMF_DURATION) {
+			duration = SWITCH_MAX_DTMF_DURATION;
+		}
+		runtime.default_dtmf_duration = duration;
+	}
+	return runtime.default_dtmf_duration;
+}
+
+SWITCH_DECLARE(uint32_t) switch_core_min_dtmf_duration(uint32_t duration)
+{
+	if (duration) {
+		if (duration < SWITCH_MIN_DTMF_DURATION) {
+			duration = SWITCH_MIN_DTMF_DURATION;
+		}
+		if (duration > SWITCH_MAX_DTMF_DURATION) {
+			duration = SWITCH_MAX_DTMF_DURATION;
+		}
+	}
+	return runtime.min_dtmf_duration;
+}
+
+static void switch_core_set_serial(void)
+{
+	char buf[13] = "";
+	char path[256];
+
+	int fd = -1, write_fd = -1;
+	switch_ssize_t bytes = 0;
+
+	switch_snprintf(path, sizeof(path), "%s%sfreeswitch.serial", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR);
+
+
+	if ((fd = open(path, O_RDONLY, 0)) < 0) {
+		char *ip = switch_core_get_variable("local_ip_v4");
+		uint32_t ipi = 0;
+		switch_byte_t *byte;
+		int i = 0;
+
+		switch_inet_pton(AF_INET, ip, &ipi);
+		byte = (switch_byte_t *) & ipi;
+
+		for (i = 0; i < 8; i += 2) {
+			switch_snprintf(buf + i, sizeof(buf) - i, "%0.2x", *byte);
+			byte++;
+		}
+
+		switch_stun_random_string(buf + 8, 4, "0123456789abcdef");
+
+		if ((write_fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) >= 0) {
+			bytes = write(write_fd, buf, sizeof(buf));
+			close(write_fd);
+			write_fd = -1;
+		}
+	} else {
+		bytes = read(fd, buf, sizeof(buf));
+		close(fd);
+		fd = -1;
+	}
+
+	switch_core_set_variable("switch_serial", buf);
+}
+
+SWITCH_DECLARE(switch_status_t) switch_core_init(switch_core_flag_t flags, switch_bool_t console, const char **err)
+{
+	switch_uuid_t uuid;
+	char guess_ip[256];
+	int mask = 0;
+	struct in_addr in;
+	char hostname[256] = "";
+
+	if (runtime.runlevel > 0) {
+		/* one per customer */
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	runtime.runlevel++;
+
+	runtime.dummy_cng_frame.data = runtime.dummy_data;
+	runtime.dummy_cng_frame.datalen = sizeof(runtime.dummy_data);
+	runtime.dummy_cng_frame.buflen = sizeof(runtime.dummy_data);
+	switch_set_flag((&runtime.dummy_cng_frame), SFF_CNG);
+
+	switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
+	runtime.hard_log_level = SWITCH_LOG_DEBUG;
+	runtime.mailer_app = "sendmail";
+	runtime.mailer_app_args = "-t";
+	runtime.max_dtmf_duration = SWITCH_MAX_DTMF_DURATION;
+	runtime.default_dtmf_duration = SWITCH_DEFAULT_DTMF_DURATION;
+	runtime.min_dtmf_duration = SWITCH_MIN_DTMF_DURATION;
+
+	/* INIT APR and Create the pool context */
+	if (apr_initialize() != SWITCH_STATUS_SUCCESS) {
+		*err = "FATAL ERROR! Could not initialize APR\n";
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	if (!(runtime.memory_pool = switch_core_memory_init())) {
+		*err = "FATAL ERROR! Could not allocate memory pool\n";
+		return SWITCH_STATUS_MEMERR;
+	}
+	switch_assert(runtime.memory_pool != NULL);
+
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.base_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.mod_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.conf_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.log_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.run_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.db_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.script_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.htdocs_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.recordings_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.sounds_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+	switch_dir_make_recursive(SWITCH_GLOBAL_dirs.temp_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
+
+	switch_mutex_init(&runtime.uuid_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
+
+	switch_mutex_init(&runtime.throttle_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
+	switch_mutex_init(&runtime.session_hash_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
+	switch_mutex_init(&runtime.global_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
+	switch_mutex_init(&runtime.global_var_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
+	switch_core_set_globals();
+	switch_core_session_init(runtime.memory_pool);
+	switch_core_hash_init(&runtime.global_vars, runtime.memory_pool);
+	switch_core_hash_init(&runtime.mime_types, runtime.memory_pool);
+	load_mime_types();
+	runtime.flags = flags;
+	runtime.sps_total = 30;
+
+	*err = NULL;
+
+	if (console) {
+		runtime.console = stdout;
+	}
+
+	gethostname(hostname, sizeof(hostname));
+	switch_core_set_variable("hostname", hostname);
+
+	switch_find_local_ip(guess_ip, sizeof(guess_ip), &mask, AF_INET);
+	switch_core_set_variable("local_ip_v4", guess_ip);
+	in.s_addr = mask;
+	switch_core_set_variable("local_mask_v4", inet_ntoa(in));
+
+
+	switch_find_local_ip(guess_ip, sizeof(guess_ip), NULL, AF_INET6);
+	switch_core_set_variable("local_ip_v6", guess_ip);
+	switch_core_set_variable("base_dir", SWITCH_GLOBAL_dirs.base_dir);
+	switch_core_set_variable("recordings_dir", SWITCH_GLOBAL_dirs.recordings_dir);
+	switch_core_set_variable("sound_prefix", SWITCH_GLOBAL_dirs.sounds_dir);
+	switch_core_set_variable("sounds_dir", SWITCH_GLOBAL_dirs.sounds_dir);
+	switch_core_set_serial();
+
+	switch_console_init(runtime.memory_pool);
+	switch_event_init(runtime.memory_pool);
+
+	if (switch_xml_init(runtime.memory_pool, err) != SWITCH_STATUS_SUCCESS) {
+		apr_terminate();
+		return SWITCH_STATUS_MEMERR;
+	}
+
+	if (switch_test_flag((&runtime), SCF_USE_AUTO_NAT)) {
+		switch_nat_init(runtime.memory_pool);
+	}
+
+	switch_log_init(runtime.memory_pool, runtime.colorize_console);
+
+	runtime.tipping_point = 5000;
+	runtime.timer_affinity = -1;
+	switch_load_core_config("switch.conf");
+
+
+	switch_core_state_machine_init(runtime.memory_pool);
+
+	if (switch_core_sqldb_start(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_SQL) ? SWITCH_TRUE : SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) {
+		abort();
+	}
+
+	switch_scheduler_task_thread_start();
+
+	switch_rtp_init(runtime.memory_pool);
+
+	runtime.running = 1;
+	runtime.initiated = switch_time_now();
+	
+	switch_scheduler_add_task(switch_epoch_time_now(NULL), heartbeat_callback, "heartbeat", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL);
+
+	switch_uuid_get(&uuid);
+	switch_uuid_format(runtime.uuid_str, &uuid);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+#ifdef SIGQUIT
+static void handle_SIGQUIT(int sig)
+{
+	if (sig);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Sig Quit!\n");
+	return;
+}
+#endif
+
+#ifdef SIGPIPE
+static void handle_SIGPIPE(int sig)
+{
+	if (sig);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Sig Pipe!\n");
+	return;
+}
+#endif
+
+#ifdef SIGPOLL
+static void handle_SIGPOLL(int sig)
+{
+	if (sig);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Sig Poll!\n");
+	return;
+}
+#endif
+
+#ifdef SIGIO
+static void handle_SIGIO(int sig)
+{
+	if (sig);
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Sig I/O!\n");
+	return;
+}
+#endif
+
+#ifdef TRAP_BUS
+static void handle_SIGBUS(int sig)
+{
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Sig BUS!\n");
+	return;
+}
+#endif
+
+static void handle_SIGHUP(int sig)
+{
+	if (sig) {
+		switch_event_t *event;
+
+		if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Trapped-Signal", "HUP");
+			switch_event_fire(&event);
+		}
+	}
+	return;
+}
+
+
+static void switch_load_core_config(const char *file)
+{
+	switch_xml_t xml = NULL, cfg = NULL;
+
+	if ((xml = switch_xml_open_cfg(file, &cfg, NULL))) {
+		switch_xml_t settings, param;
+
+		if ((settings = switch_xml_child(cfg, "settings"))) {
+			for (param = switch_xml_child(settings, "param"); param; param = param->next) {
+				const char *var = switch_xml_attr_soft(param, "name");
+				const char *val = switch_xml_attr_soft(param, "value");
+
+				if (!strcasecmp(var, "loglevel")) {
+					int level;
+					if (*val > 47 && *val < 58) {
+						level = atoi(val);
+					} else {
+						level = switch_log_str2level(val);
+					}
+
+					if (level != SWITCH_LOG_INVALID) {
+						switch_core_session_ctl(SCSC_LOGLEVEL, &level);
+					}
+#ifdef HAVE_SETRLIMIT
+				} else if (!strcasecmp(var, "dump-cores")) {
+					struct rlimit rlp;
+					memset(&rlp, 0, sizeof(rlp));
+					rlp.rlim_cur = RLIM_INFINITY;
+					rlp.rlim_max = RLIM_INFINITY;
+					setrlimit(RLIMIT_CORE, &rlp);
+#endif
+				} else if (!strcasecmp(var, "debug-level")) {
+					int tmp = atoi(val);
+					if (tmp > -1 && tmp < 11) {
+						switch_core_session_ctl(SCSC_DEBUG_LEVEL, &tmp);
+					}
+				} else if (!strcasecmp(var, "enable-early-hangup") && switch_true(val)) {
+					switch_set_flag((&runtime), SCF_EARLY_HANGUP);
+				} else if (!strcasecmp(var, "colorize-console") && switch_true(val)) {
+					runtime.colorize_console = SWITCH_TRUE;
+				} else if (!strcasecmp(var, "mailer-app") && !zstr(val)) {
+					runtime.mailer_app = switch_core_strdup(runtime.memory_pool, val);
+				} else if (!strcasecmp(var, "mailer-app-args") && val) {
+					runtime.mailer_app_args = switch_core_strdup(runtime.memory_pool, val);
+				} else if (!strcasecmp(var, "sessions-per-second") && !zstr(val)) {
+					switch_core_sessions_per_second(atoi(val));
+				} else if (!strcasecmp(var, "max-dtmf-duration") && !zstr(val)) {
+					int tmp = atoi(val);
+					if (tmp > 0) {
+						switch_core_max_dtmf_duration((uint32_t) tmp);
+					}
+				} else if (!strcasecmp(var, "min-dtmf-duration") && !zstr(val)) {
+					int tmp = atoi(val);
+					if (tmp > 0) {
+						switch_core_min_dtmf_duration((uint32_t) tmp);
+					}
+				} else if (!strcasecmp(var, "default-dtmf-duration") && !zstr(val)) {
+					int tmp = atoi(val);
+					if (tmp > 0) {
+						switch_core_default_dtmf_duration((uint32_t) tmp);
+					}
+				} else if (!strcasecmp(var, "enable-monotonic-timing")) {
+					switch_time_set_monotonic(switch_true(var));
+				} else if (!strcasecmp(var, "enable-clock-nanosleep")) {
+					switch_time_set_nanosleep(switch_true(var));
+				} else if (!strcasecmp(var, "enable-cond-yield")) {
+					switch_time_set_cond_yield(switch_true(var));
+				} else if (!strcasecmp(var, "enable-timer-matrix")) {
+					switch_time_set_matrix(switch_true(var));
+				} else if (!strcasecmp(var, "max-sessions") && !zstr(val)) {
+					switch_core_session_limit(atoi(val));
+				} else if (!strcasecmp(var, "min-idle-cpu") && !zstr(val)) {
+					switch_core_min_idle_cpu(atof(val));
+				} else if (!strcasecmp(var, "tipping-point") && !zstr(val)) {
+					runtime.tipping_point = atoi(val);
+				} else if (!strcasecmp(var, "timer-affinity") && !zstr(val)) {
+					if (!strcasecmp(val, "disabled")) {
+						runtime.timer_affinity = -1;
+					} else {
+						runtime.timer_affinity = atoi(val);
+					}
+				} else if (!strcasecmp(var, "rtp-start-port") && !zstr(val)) {
+					switch_rtp_set_start_port((switch_port_t) atoi(val));
+				} else if (!strcasecmp(var, "rtp-end-port") && !zstr(val)) {
+					switch_rtp_set_end_port((switch_port_t) atoi(val));
+				} else if (!strcasecmp(var, "core-db-dsn") && !zstr(val)) {
+					if (switch_odbc_available()) {
+						runtime.odbc_dsn = switch_core_strdup(runtime.memory_pool, val);
+						if ((runtime.odbc_user = strchr(runtime.odbc_dsn, ':'))) {
+							*runtime.odbc_user++ = '\0';
+							if ((runtime.odbc_pass = strchr(runtime.odbc_user, ':'))) {
+								*runtime.odbc_pass++ = '\0';
+							}
+						}
+					} else {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
+					}
+#ifdef ENABLE_ZRTP
+				} else if (!strcasecmp(var, "rtp-enable-zrtp")) {
+					switch_core_set_variable("zrtp_enabled", val);
+#endif
+				}
+			}
+		}
+
+		if ((settings = switch_xml_child(cfg, "variables"))) {
+			for (param = switch_xml_child(settings, "variable"); param; param = param->next) {
+				const char *var = switch_xml_attr_soft(param, "name");
+				const char *val = switch_xml_attr_soft(param, "value");
+				if (var && val) {
+					switch_core_set_variable(var, val);
+				}
+			}
+		}
+
+		switch_xml_free(xml);
+	}
+
+
+}
+
+SWITCH_DECLARE(const char *) switch_core_banner(void)
+{
+
+
+	return ("\n"
+			"   _____              ______        _____ _____ ____ _   _  \n"
+			"  |  ___| __ ___  ___/ ___\\ \\      / /_ _|_   _/ ___| | | | \n"
+			"  | |_ | '__/ _ \\/ _ \\___ \\\\ \\ /\\ / / | |  | || |   | |_| | \n"
+			"  |  _|| | |  __/  __/___) |\\ V  V /  | |  | || |___|  _  | \n"
+			"  |_|  |_|  \\___|\\___|____/  \\_/\\_/  |___| |_| \\____|_| |_| \n"
+			"\n"
+			"************************************************************\n"
+			"* Anthony Minessale II, Michael Jerris, Brian West, Others *\n"
+			"* FreeSWITCH (http://www.freeswitch.org)                   *\n"
+			"* Paypal Donations Appreciated: paypal@freeswitch.org      *\n"
+			"* Brought to you by ClueCon http://www.cluecon.com/        *\n" "************************************************************\n" "\n");
+}
+
+
+SWITCH_DECLARE(switch_status_t) switch_core_init_and_modload(switch_core_flag_t flags, switch_bool_t console, const char **err)
+{
+	switch_event_t *event;
+
+	if (switch_core_init(flags, console, err) != SWITCH_STATUS_SUCCESS) {
+		return SWITCH_STATUS_GENERR;
+	}
+
+	if (runtime.runlevel > 1) {
+		/* one per customer */
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	runtime.runlevel++;
+
+	/* set signal handlers */
+	signal(SIGINT, SIG_IGN);
+#ifdef SIGPIPE
+	signal(SIGPIPE, handle_SIGPIPE);
+#endif
+#ifdef SIGQUIT
+	signal(SIGQUIT, handle_SIGQUIT);
+#endif
+#ifdef SIGPOLL
+	signal(SIGPOLL, handle_SIGPOLL);
+#endif
+#ifdef SIGIO
+	signal(SIGIO, handle_SIGIO);
+#endif
+#ifdef TRAP_BUS
+	signal(SIGBUS, handle_SIGBUS);
+#endif
+#ifdef SIGUSR1
+	signal(SIGUSR1, handle_SIGHUP);
+#endif
+	signal(SIGHUP, handle_SIGHUP);
+
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Bringing up environment.\n");
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Loading Modules.\n");
+	if (switch_loadable_module_init() != SWITCH_STATUS_SUCCESS) {
+		*err = "Cannot load modules";
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error: %s\n", *err);
+		return SWITCH_STATUS_GENERR;
+	}
+
+	switch_load_network_lists(SWITCH_FALSE);
+
+	switch_load_core_config("post_load_switch.conf");
+
+	if (switch_event_create(&event, SWITCH_EVENT_STARTUP) == SWITCH_STATUS_SUCCESS) {
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Ready");
+		switch_event_fire(&event);
+	}
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s", switch_core_banner());
+
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,
+					  "\nFreeSWITCH Version %s Started.\nMax Sessions[%u]\nSession Rate[%d]\nSQL [%s]\n", SWITCH_VERSION_FULL,
+					  switch_core_session_limit(0),
+					  switch_core_sessions_per_second(0), switch_test_flag((&runtime), SCF_USE_SQL) ? "Enabled" : "Disabled");
+
+	switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
+
+	return SWITCH_STATUS_SUCCESS;
+
+}
+
+SWITCH_DECLARE(void) switch_core_measure_time(switch_time_t total_ms, switch_core_time_duration_t *duration)
+{
+	switch_time_t temp = total_ms / 1000;
+	memset(duration, 0, sizeof(*duration));
+	duration->mms = (uint32_t) (total_ms % 1000);
+	duration->ms = (uint32_t) (temp % 1000);
+	temp = temp / 1000;
+	duration->sec = (uint32_t) (temp % 60);
+	temp = temp / 60;
+	duration->min = (uint32_t) (temp % 60);
+	temp = temp / 60;
+	duration->hr = (uint32_t) (temp % 24);
+	temp = temp / 24;
+	duration->day = (uint32_t) (temp % 365);
+	duration->yr = (uint32_t) (temp / 365);
+}
+
+SWITCH_DECLARE(switch_time_t) switch_core_uptime(void)
+{
+	return switch_micro_time_now() - runtime.initiated;
+}
+
+
+#ifdef _MSC_VER
+static void win_shutdown(void)
+{
+
+	HANDLE shutdown_event;
+	char path[512];
+	/* for windows we need the event to signal for shutting down a background FreeSWITCH */
+	snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
+
+	/* open the event so we can signal it */
+	shutdown_event = OpenEvent(EVENT_MODIFY_STATE, FALSE, path);
+
+	if (shutdown_event) {
+		/* signal the event to shutdown */
+		SetEvent(shutdown_event);
+		/* cleanup */
+		CloseHandle(shutdown_event);
+	}
+}
+#endif
+
+SWITCH_DECLARE(uint32_t) switch_core_debug_level(void)
+{
+	return runtime.debug_level;
+}
+
+
+SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *val)
+{
+	int *intval = (int *) val;
+
+	if (switch_test_flag((&runtime), SCF_SHUTTING_DOWN)) {
+		return -1;
+	}
+
+	switch (cmd) {
+	case SCSC_CALIBRATE_CLOCK:
+		switch_time_calibrate_clock();
+		break;
+	case SCSC_FLUSH_DB_HANDLES:
+		switch_cache_db_flush_handles();
+		break;
+	case SCSC_SEND_SIGHUP:
+		handle_SIGHUP(1);
+		break;
+	case SCSC_SYNC_CLOCK:
+		switch_time_sync();
+		*intval = 0;
+		break;
+	case SCSC_PAUSE_INBOUND:
+		if (*intval) {
+			switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
+		} else {
+			switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
+		}
+		break;
+	case SCSC_HUPALL:
+		switch_core_session_hupall(SWITCH_CAUSE_MANAGER_REQUEST);
+		break;
+	case SCSC_CANCEL_SHUTDOWN:
+		switch_clear_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
+		break;
+	case SCSC_SAVE_HISTORY:
+		switch_console_save_history();
+		break;
+	case SCSC_CRASH:
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Declinatio Mortuus Obfirmo!\n");
+		switch_console_save_history();
+		abort();
+		break;
+	case SCSC_SHUTDOWN_NOW:
+		switch_console_save_history();
+		exit(0);
+		break;
+	case SCSC_SHUTDOWN_ELEGANT:
+	case SCSC_SHUTDOWN_ASAP:
+		{
+			int x = 19;
+			uint32_t count;
+
+			switch_set_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
+			if (cmd == SCSC_SHUTDOWN_ASAP) {
+				switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
+			}
+
+			while (runtime.running && switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED) && (count = switch_core_session_count())) {
+				switch_yield(500000);
+				if (++x == 20) {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+									  "Shutdown in progress, %u session(s) remain.\nShutting down %s\n",
+									  count, cmd == SCSC_SHUTDOWN_ASAP ? "ASAP" : "once there are no active calls.");
+					x = 0;
+				}
+			}
+
+			if (switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED)) {
+				switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
+#ifdef _MSC_VER
+				win_shutdown();
+#endif
+
+				if (*intval) {
+					switch_set_flag((&runtime), SCF_RESTART);
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
+				} else {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutting down\n");
+#ifdef _MSC_VER
+					fclose(stdin);
+#endif
+				}
+				runtime.running = 0;
+			} else {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutdown Cancelled\n");
+				switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
+			}
+		}
+		break;
+	case SCSC_SHUTDOWN:
+
+#ifdef _MSC_VER
+		win_shutdown();
+#endif
+
+		if (*intval) {
+			switch_set_flag((&runtime), SCF_RESTART);
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
+		} else {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutting down\n");
+#ifdef _MSC_VER
+			fclose(stdin);
+#endif
+		}
+		runtime.running = 0;
+		break;
+	case SCSC_CHECK_RUNNING:
+		*intval = runtime.running;
+		break;
+	case SCSC_LOGLEVEL:
+		if (*intval > -1) {
+			runtime.hard_log_level = *intval;
+		}
+
+		if (runtime.hard_log_level > SWITCH_LOG_DEBUG) {
+			runtime.hard_log_level = SWITCH_LOG_DEBUG;
+		}
+		*intval = runtime.hard_log_level;
+		break;
+	case SCSC_DEBUG_LEVEL:
+		if (*intval > -1) {
+			if (*intval > 10)
+				*intval = 10;
+			runtime.debug_level = *intval;
+		}
+		*intval = runtime.debug_level;
+		break;
+	case SCSC_MIN_IDLE_CPU:
+		{
+			double *dval = (double *) val;
+			*dval = switch_core_min_idle_cpu(*dval);
+		}
+		break;
+	case SCSC_MAX_SESSIONS:
+		*intval = switch_core_session_limit(*intval);
+		break;
+	case SCSC_LAST_SPS:
+		*intval = runtime.sps_last;
+		break;
+	case SCSC_MAX_DTMF_DURATION:
+		*intval = switch_core_max_dtmf_duration(*intval);
+		break;
+	case SCSC_MIN_DTMF_DURATION:
+		*intval = switch_core_min_dtmf_duration(*intval);
+		break;
+	case SCSC_DEFAULT_DTMF_DURATION:
+		*intval = switch_core_default_dtmf_duration(*intval);
+		break;
+	case SCSC_SPS:
+		switch_mutex_lock(runtime.throttle_mutex);
+		if (*intval > 0) {
+			runtime.sps_total = *intval;
+		}
+		*intval = runtime.sps_total;
+		switch_mutex_unlock(runtime.throttle_mutex);
+		break;
+
+	case SCSC_RECLAIM:
+		switch_core_memory_reclaim_all();
+		*intval = 0;
+		break;
+	}
+
+
+	return 0;
+}
+
+SWITCH_DECLARE(switch_core_flag_t) switch_core_flags(void)
+{
+	return runtime.flags;
+}
+
+SWITCH_DECLARE(switch_bool_t) switch_core_ready(void)
+{
+	return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
+{
+	switch_event_t *event;
+
+	if (switch_event_create(&event, SWITCH_EVENT_SHUTDOWN) == SWITCH_STATUS_SUCCESS) {
+		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Shutting Down");
+		switch_event_fire(&event);
+	}
+
+	switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
+	switch_set_flag((&runtime), SCF_SHUTTING_DOWN);
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "End existing sessions\n");
+	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();
+
+	if (switch_test_flag((&runtime), SCF_USE_SQL)) {
+		switch_core_sqldb_stop();
+	}
+	switch_scheduler_task_thread_stop();
+
+	switch_rtp_shutdown();
+	if (switch_test_flag((&runtime), SCF_USE_AUTO_NAT)) {
+		switch_nat_shutdown();
+	}
+	switch_xml_destroy();
+
+	switch_console_shutdown();
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Closing Event Engine.\n");
+	switch_event_shutdown();
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Finalizing Shutdown.\n");
+	switch_log_shutdown();
+
+	switch_core_unset_variables();
+	switch_core_memory_stop();
+
+	if (runtime.console && runtime.console != stdout && runtime.console != stderr) {
+		fclose(runtime.console);
+		runtime.console = NULL;
+	}
+
+	switch_safe_free(SWITCH_GLOBAL_dirs.base_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.mod_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.conf_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.log_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.db_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.script_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.htdocs_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.grammar_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.recordings_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.sounds_dir);
+	switch_safe_free(SWITCH_GLOBAL_dirs.temp_dir);
+
+	switch_core_hash_destroy(&runtime.global_vars);
+	switch_core_hash_destroy(&runtime.mime_types);
+
+	if (runtime.memory_pool) {
+		apr_pool_destroy(runtime.memory_pool);
+		apr_terminate();
+	}
+
+	return switch_test_flag((&runtime), SCF_RESTART) ? SWITCH_STATUS_RESTART : SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_core_chat_send(const char *name, const char *proto, const char *from, const char *to,
+													  const char *subject, const char *body, const char *type, const char *hint)
+{
+	switch_chat_interface_t *ci;
+	switch_status_t status;
+
+	if (!name || !(ci = switch_loadable_module_get_chat_interface(name)) || !ci->chat_send) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Chat Interface [%s]!\n", name);
+		return SWITCH_STATUS_FALSE;
+	}
+
+	status = ci->chat_send(proto, from, to, subject, body, type, hint);
+
+	UNPROTECT_INTERFACE(ci);
+
+	return status;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_core_management_exec(char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
+{
+	const switch_management_interface_t *ptr;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+
+	if ((ptr = switch_loadable_module_get_management_interface(relative_oid))) {
+		status = ptr->management_function(relative_oid, action, data, datalen);
+	}
+
+	return status;
+}
+
+SWITCH_DECLARE(void) switch_core_memory_reclaim_all(void)
+{
+	switch_core_memory_reclaim_logger();
+	switch_core_memory_reclaim_events();
+	switch_core_memory_reclaim();
+}
+
+
+struct system_thread_handle {
+	const char *cmd;
+	switch_thread_cond_t *cond;
+	switch_mutex_t *mutex;
+	switch_memory_pool_t *pool;
+	int ret;
+};
+
+static void *SWITCH_THREAD_FUNC system_thread(switch_thread_t *thread, void *obj)
+{
+	struct system_thread_handle *sth = (struct system_thread_handle *) obj;
+
+#if 0							// if we are a luser we can never turn this back down, didn't we already set the stack size?
+#if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
+	struct rlimit rlim;
+
+	rlim.rlim_cur = SWITCH_SYSTEM_THREAD_STACKSIZE;
+	rlim.rlim_max = SWITCH_SYSTEM_THREAD_STACKSIZE;
+	if (setrlimit(RLIMIT_STACK, &rlim) < 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
+	}
+#endif
+#endif
+
+	sth->ret = system(sth->cmd);
+
+#if 0
+#if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
+	rlim.rlim_cur = SWITCH_THREAD_STACKSIZE;
+	rlim.rlim_max = SWITCH_SYSTEM_THREAD_STACKSIZE;
+	if (setrlimit(RLIMIT_STACK, &rlim) < 0) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
+	}
+#endif
+#endif
+
+	switch_mutex_lock(sth->mutex);
+	switch_thread_cond_signal(sth->cond);
+	switch_mutex_unlock(sth->mutex);
+
+	switch_core_destroy_memory_pool(&sth->pool);
+
+	return NULL;
+}
+
+SWITCH_DECLARE(int) switch_system(const char *cmd, switch_bool_t wait)
+{
+	switch_thread_t *thread;
+	switch_threadattr_t *thd_attr;
+	int ret = 0;
+	struct system_thread_handle *sth;
+	switch_memory_pool_t *pool;
+
+	if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+		return 1;
+	}
+
+	if (!(sth = switch_core_alloc(pool, sizeof(struct system_thread_handle)))) {
+		switch_core_destroy_memory_pool(&pool);
+		return 1;
+	}
+
+	sth->pool = pool;
+	sth->cmd = switch_core_strdup(pool, cmd);
+
+	switch_thread_cond_create(&sth->cond, sth->pool);
+	switch_mutex_init(&sth->mutex, SWITCH_MUTEX_NESTED, sth->pool);
+	switch_mutex_lock(sth->mutex);
+
+	switch_threadattr_create(&thd_attr, sth->pool);
+	switch_threadattr_stacksize_set(thd_attr, SWITCH_SYSTEM_THREAD_STACKSIZE);
+	switch_threadattr_detach_set(thd_attr, 1);
+	switch_thread_create(&thread, thd_attr, system_thread, sth, sth->pool);
+
+	if (wait) {
+		switch_thread_cond_wait(sth->cond, sth->mutex);
+		ret = sth->ret;
+	}
+	switch_mutex_unlock(sth->mutex);
+
+	return ret;
+}
+
+
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
diff --git a/src/switch_cpp.cpp b/src/switch_cpp.cpp
index d0f085088c..656bc83184 100644
--- a/src/switch_cpp.cpp
+++ b/src/switch_cpp.cpp
@@ -52,25 +52,35 @@ static void event_handler(switch_event_t *event)
 
 SWITCH_DECLARE_CONSTRUCTOR EventConsumer::EventConsumer(const char *event_name, const char *subclass_name)
 {
-	switch_name_event(event_name, &e_event_id);
-	switch_core_new_memory_pool(&pool);
-	
-	if (!zstr(subclass_name)) {
-		e_subclass_name = switch_core_strdup(pool, subclass_name);
-	} else {
-		e_subclass_name = NULL;
-	}
 
+	switch_core_new_memory_pool(&pool);	
 	switch_queue_create(&events, 5000, pool);
 	
-	if (switch_event_bind_removable(__FILE__, e_event_id, e_subclass_name, event_handler, this, &node) == SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "bound to %s %s\n", event_name, switch_str_nil(e_subclass_name));
-	} else {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot bind to %s %s\n", event_name, switch_str_nil(e_subclass_name));
+	if (!zstr(event_name)) {
+		bind(event_name, subclass_name);
 	}
 
 }
 
+SWITCH_DECLARE(int) EventConsumer::bind(const char *event_name, const char *subclass_name)
+{
+	switch_event_types_t event_id = SWITCH_EVENT_CUSTOM;
+	switch_name_event(event_name, &event_id);
+
+
+	if (zstr(subclass_name)) {
+		subclass_name = NULL;
+	}
+	
+	if (switch_event_bind(__FILE__, event_id, subclass_name, event_handler, this) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "bound to %s %s\n", event_name, switch_str_nil(subclass_name));
+		return 1;
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot bind to %s %s\n", event_name, switch_str_nil(subclass_name));
+		return 0;
+	}
+}
+
 
 SWITCH_DECLARE(Event *) EventConsumer::pop(int block)
 {
@@ -93,9 +103,8 @@ SWITCH_DECLARE(Event *) EventConsumer::pop(int block)
 
 SWITCH_DECLARE_CONSTRUCTOR EventConsumer::~EventConsumer()
 {
-	if (node) {
-		switch_event_unbind(&node);
-	}
+
+	switch_event_unbind_callback(event_handler);
 
 	if (events) {
 		switch_queue_interrupt_all(events);
diff --git a/src/switch_event.c b/src/switch_event.c
index 00a08fba1b..f473f3d40a 100644
--- a/src/switch_event.c
+++ b/src/switch_event.c
@@ -1198,7 +1198,7 @@ SWITCH_DECLARE(switch_status_t) switch_event_bind_removable(const char *id, swit
 	if (node) {
 		*node = NULL;
 	}
-
+	
 	if (subclass_name) {
 		if (!(subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name))) {
 			switch_event_reserve_subclass_detailed(id, subclass_name);
diff --git a/src/switch_time.c.orig b/src/switch_time.c.orig
new file mode 100644
index 0000000000..cbdc2f8eb1
--- /dev/null
+++ b/src/switch_time.c.orig
@@ -0,0 +1,1962 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ * Copyright (C) 2005-2010, Anthony Minessale II <anthm@freeswitch.org>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Anthony Minessale II <anthm@freeswitch.org>
+ * Massimo Cetra <devel@navynet.it> - Timezone functionality
+ *
+ *
+ * softtimer.c -- Software Timer Module
+ *
+ */
+
+#include <switch.h>
+#include <stdio.h>
+#include "private/switch_core_pvt.h"
+
+//#if defined(DARWIN)
+#define DISABLE_1MS_COND
+//#endif
+
+#ifndef UINT32_MAX
+#define UINT32_MAX 0xffffffff
+#endif
+
+#define MAX_TICK UINT32_MAX - 1024
+
+#define MAX_ELEMENTS 3600
+#define IDLE_SPEED 100
+
+#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
+static int MONO = 1;
+#else
+static int MONO = 0;
+#endif
+
+#if defined(HAVE_CLOCK_NANOSLEEP)
+static int NANO = 1;
+#else
+static int NANO = 0;
+#endif
+
+
+static int OFFSET = 0;
+
+static int COND = 1;
+
+static int MATRIX = 1;
+
+#define ONEMS
+#ifdef ONEMS
+static int STEP_MS = 1;
+static int STEP_MIC = 1000;
+static uint32_t TICK_PER_SEC = 1000;
+static int MS_PER_TICK = 10;
+#else
+static int STEP_MS = 10;
+static int STEP_MIC = 10000;
+static uint32_t TICK_PER_SEC = 1000;
+static int MS_PER_TICK = 10;
+#endif
+
+static switch_memory_pool_t *module_pool = NULL;
+
+static struct {
+	int32_t RUNNING;
+	int32_t STARTED;
+	int32_t use_cond_yield;
+	switch_mutex_t *mutex;
+	uint32_t timer_count;
+} globals;
+
+#ifdef WIN32
+#undef SWITCH_MOD_DECLARE_DATA
+#define SWITCH_MOD_DECLARE_DATA __declspec(dllexport)
+#endif
+
+SWITCH_MODULE_LOAD_FUNCTION(softtimer_load);
+SWITCH_MODULE_SHUTDOWN_FUNCTION(softtimer_shutdown);
+SWITCH_MODULE_RUNTIME_FUNCTION(softtimer_runtime);
+SWITCH_MODULE_DEFINITION(CORE_SOFTTIMER_MODULE, softtimer_load, softtimer_shutdown, softtimer_runtime);
+
+struct timer_private {
+	switch_size_t reference;
+	switch_size_t start;
+	uint32_t roll;
+	uint32_t ready;
+};
+typedef struct timer_private timer_private_t;
+
+struct timer_matrix {
+	switch_size_t tick;
+	uint32_t count;
+	uint32_t roll;
+	switch_mutex_t *mutex;
+	switch_thread_cond_t *cond;
+	switch_thread_rwlock_t *rwlock;
+};
+typedef struct timer_matrix timer_matrix_t;
+
+static timer_matrix_t TIMER_MATRIX[MAX_ELEMENTS + 1];
+
+static void os_yield(void)
+{
+#if defined(WIN32)
+	SwitchToThread();
+#else
+	sched_yield();
+#endif
+}
+
+static void do_sleep(switch_interval_time_t t)
+{
+#if defined(HAVE_CLOCK_NANOSLEEP) || defined(DARWIN)
+	struct timespec ts;
+#endif
+
+#if defined(WIN32)
+	if (t < 1000) {
+		t = 1000;
+	}
+#endif
+
+#if !defined(DARWIN)
+	if (t > 100000 || !NANO) {
+		apr_sleep(t);
+		return;
+	}
+#endif
+
+#if defined(HAVE_CLOCK_NANOSLEEP)
+	t -= OFFSET;
+	ts.tv_sec = t / 1000000;
+	ts.tv_nsec = ((t % 1000000) * 1000);
+	clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
+
+#elif defined(DARWIN)
+	ts.tv_sec = t / APR_USEC_PER_SEC;
+	ts.tv_nsec = (t % APR_USEC_PER_SEC) * 1000;
+	nanosleep(&ts, NULL);
+#else
+	apr_sleep(t);
+#endif
+
+#if defined(DARWIN)
+	sched_yield();
+#endif
+
+}
+
+static switch_interval_time_t average_time(switch_interval_time_t t, int reps)
+{
+	int x = 0;
+	switch_time_t start, stop, sum = 0;
+
+	for (x = 0; x < reps; x++) {
+		start = switch_time_now();
+		do_sleep(t);
+		stop = switch_time_now();
+		sum += (stop - start);
+	}
+
+	return sum / reps;
+
+}
+
+#define calc_step() if (step > 11) step -= 10; else if (step > 1) step--
+SWITCH_DECLARE(void) switch_time_calibrate_clock(void)
+{
+	int x;
+	switch_interval_time_t avg, val = 1000, want = 1000;
+	int over = 0, under = 0, good = 0, step = 50, diff = 0, retry = 0, lastgood = 0, one_k = 0;
+
+#ifdef HAVE_CLOCK_GETRES
+	struct timespec ts;
+	long res = 0;
+	clock_getres(CLOCK_MONOTONIC, &ts);
+	res = ts.tv_nsec / 1000;
+
+
+	if (res > 900 && res < 1100) {
+		one_k = 1;
+	}
+	
+	if (res > 1500) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+						  "Timer resolution of %ld microseconds detected!\n"
+						  "Do you have your kernel timer frequency set to lower than 1,000Hz? You may experience audio problems.\n", ts.tv_nsec / 1000);
+		do_sleep(5000000);
+		switch_time_set_cond_yield(SWITCH_TRUE);
+		return;
+	}
+#endif
+
+  top:
+	val = 1000;
+	step = 50;
+	over = under = good = 0;
+	OFFSET = 0;
+
+	for (x = 0; x < 100; x++) {
+		avg = average_time(val, 50);
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Test: %ld Average: %ld Step: %d\n", (long) val, (long) avg, step);
+
+		diff = abs((int) (want - avg));
+		if (diff > 1500) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+							  "Abnormally large timer gap %d detected!\n"
+							  "Do you have your kernel timer frequency set to lower than 1,000Hz? You may experience audio problems.\n", diff);
+			do_sleep(5000000);
+			switch_time_set_cond_yield(SWITCH_TRUE);
+			return;
+		}
+
+		if (diff <= 100) {
+			lastgood = (int) val;
+		}
+
+		if (diff <= 2) {
+			under = over = 0;
+			lastgood = (int) val;
+			if (++good > 10) {
+				break;
+			}
+		} else if (avg > want) {
+			if (under) {
+				calc_step();
+			}
+			under = good = 0;
+			if ((val - step) < 0) {
+				if (++retry > 2)
+					break;
+				goto top;
+			}
+			val -= step;
+			over++;
+		} else if (avg < want) {
+			if (over) {
+				calc_step();
+			}
+			over = good = 0;
+			if ((val - step) < 0) {
+				if (++retry > 2)
+					break;
+				goto top;
+			}
+			val += step;
+			under++;
+		}
+	}
+
+	if (good >= 10) {
+		OFFSET = (int) (want - val);
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Timer offset of %d calculated\n", OFFSET);
+	} else if (lastgood) {
+		OFFSET = (int) (want - lastgood);
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Timer offset of %d calculated (fallback)\n", OFFSET);
+		switch_time_set_cond_yield(SWITCH_TRUE);
+	} else if (one_k) {
+		OFFSET = 900;
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Timer offset CANNOT BE DETECTED, forcing OFFSET to 900\n");
+		switch_time_set_cond_yield(SWITCH_TRUE);
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Timer offset NOT calculated\n");
+		switch_time_set_cond_yield(SWITCH_TRUE);
+	}
+}
+
+
+SWITCH_DECLARE(switch_time_t) switch_micro_time_now(void)
+{
+	return (globals.RUNNING == 1 && runtime.timestamp) ? runtime.timestamp : switch_time_now();
+}
+
+
+SWITCH_DECLARE(time_t) switch_epoch_time_now(time_t *t)
+{
+	time_t now = switch_micro_time_now() / APR_USEC_PER_SEC;
+	if (t) {
+		*t = now;
+	}
+	return now;
+}
+
+SWITCH_DECLARE(void) switch_time_set_monotonic(switch_bool_t enable)
+{
+	MONO = enable ? 1 : 0;
+	switch_time_sync();
+}
+
+
+SWITCH_DECLARE(void) switch_time_set_matrix(switch_bool_t enable)
+{
+	MATRIX = enable ? 1 : 0;
+	switch_time_sync();
+}
+
+SWITCH_DECLARE(void) switch_time_set_nanosleep(switch_bool_t enable)
+{
+#if defined(HAVE_CLOCK_NANOSLEEP)
+	NANO = enable ? 1 : 0;
+#endif
+}
+
+SWITCH_DECLARE(void) switch_time_set_cond_yield(switch_bool_t enable)
+{
+	COND = enable ? 1 : 0;
+	if (COND) {
+		MATRIX = 1;
+	}
+	switch_time_sync();
+}
+
+static switch_time_t time_now(int64_t offset)
+{
+	switch_time_t now;
+
+#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
+	if (MONO) {
+		struct timespec ts;
+		clock_gettime(CLOCK_MONOTONIC, &ts);
+		now = ts.tv_sec * APR_USEC_PER_SEC + (ts.tv_nsec / 1000) + offset;
+	} else {
+#endif
+		now = switch_time_now();
+
+#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
+	}
+#endif
+
+	return now;
+}
+
+SWITCH_DECLARE(void) switch_time_sync(void)
+{
+	runtime.reference = switch_time_now();
+	runtime.offset = runtime.reference - time_now(0);
+	runtime.reference = time_now(runtime.offset);
+}
+
+SWITCH_DECLARE(void) switch_micro_sleep(switch_interval_time_t t)
+{
+	do_sleep(t);
+}
+
+SWITCH_DECLARE(void) switch_sleep(switch_interval_time_t t)
+{
+
+	if (globals.RUNNING != 1 || t < 1000 || t >= 10000) {
+		do_sleep(t);
+		return;
+	}
+#ifndef DISABLE_1MS_COND
+	if (globals.use_cond_yield == 1) {
+		switch_cond_yield(t);
+		return;
+	}
+#endif
+
+	do_sleep(t);
+}
+
+
+SWITCH_DECLARE(void) switch_cond_next(void)
+{
+	if (globals.timer_count >= runtime.tipping_point) {
+		os_yield();
+		return;
+	}
+#ifdef DISABLE_1MS_COND
+	do_sleep(1000);
+#else
+	if (globals.RUNNING != 1 || !runtime.timestamp || globals.use_cond_yield != 1) {
+		do_sleep(1000);
+		return;
+	}
+	switch_mutex_lock(TIMER_MATRIX[1].mutex);
+	switch_thread_cond_wait(TIMER_MATRIX[1].cond, TIMER_MATRIX[1].mutex);
+	switch_mutex_unlock(TIMER_MATRIX[1].mutex);
+#endif
+}
+
+SWITCH_DECLARE(void) switch_cond_yield(switch_interval_time_t t)
+{
+	switch_time_t want;
+	if (!t)
+		return;
+
+	if (globals.RUNNING != 1 || !runtime.timestamp || globals.use_cond_yield != 1) {
+		do_sleep(t);
+		return;
+	}
+	want = runtime.timestamp + t;
+	while (globals.RUNNING == 1 && globals.use_cond_yield == 1 && runtime.timestamp < want) {
+		switch_mutex_lock(TIMER_MATRIX[1].mutex);
+		if (runtime.timestamp < want) {
+			switch_thread_cond_wait(TIMER_MATRIX[1].cond, TIMER_MATRIX[1].mutex);
+		}
+		switch_mutex_unlock(TIMER_MATRIX[1].mutex);
+	}
+
+
+}
+
+static switch_status_t timer_init(switch_timer_t *timer)
+{
+	timer_private_t *private_info;
+	int sanity = 0;
+
+	while (globals.STARTED == 0) {
+		do_sleep(100000);
+		if (++sanity == 300) {
+			abort();
+		}
+	}
+
+	if (globals.RUNNING != 1 || !globals.mutex || timer->interval < 1) {
+		return SWITCH_STATUS_FALSE;
+	}
+
+	if ((private_info = switch_core_alloc(timer->memory_pool, sizeof(*private_info)))) {
+		switch_mutex_lock(globals.mutex);
+		if (!TIMER_MATRIX[timer->interval].mutex) {
+			switch_mutex_init(&TIMER_MATRIX[timer->interval].mutex, SWITCH_MUTEX_NESTED, module_pool);
+			switch_thread_cond_create(&TIMER_MATRIX[timer->interval].cond, module_pool);
+		}
+		TIMER_MATRIX[timer->interval].count++;
+		switch_mutex_unlock(globals.mutex);
+		timer->private_info = private_info;
+		private_info->start = private_info->reference = TIMER_MATRIX[timer->interval].tick;
+		private_info->roll = TIMER_MATRIX[timer->interval].roll;
+		private_info->ready = 1;
+
+		if (timer->interval > 0 && timer->interval < MS_PER_TICK) {
+			MS_PER_TICK = timer->interval;
+			STEP_MS = 1;
+			STEP_MIC = 1000;
+			TICK_PER_SEC = 10000;
+			switch_time_sync();
+		}
+
+		switch_mutex_lock(globals.mutex);
+		globals.timer_count++;
+		if (globals.timer_count == (runtime.tipping_point + 1)) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Crossed tipping point of %u, shifting into high-gear.\n", runtime.tipping_point);
+		}
+		switch_mutex_unlock(globals.mutex);
+
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	return SWITCH_STATUS_MEMERR;
+}
+
+#define check_roll() if (private_info->roll < TIMER_MATRIX[timer->interval].roll) {	\
+		private_info->roll++;											\
+		private_info->reference = private_info->start = TIMER_MATRIX[timer->interval].tick;	\
+	}																	\
+
+
+static switch_status_t timer_step(switch_timer_t *timer)
+{
+	timer_private_t *private_info = timer->private_info;
+	uint64_t samples;
+
+	if (globals.RUNNING != 1 || private_info->ready == 0) {
+		return SWITCH_STATUS_FALSE;
+	}
+
+	check_roll();
+	samples = timer->samples * (private_info->reference - private_info->start);
+
+	if (samples > UINT32_MAX) {
+		private_info->start = private_info->reference;
+		samples = timer->samples;
+	}
+
+	timer->samplecount = (uint32_t) samples;
+	private_info->reference++;
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t timer_sync(switch_timer_t *timer)
+{
+	timer_private_t *private_info = timer->private_info;
+
+	if (globals.RUNNING != 1 || private_info->ready == 0) {
+		return SWITCH_STATUS_FALSE;
+	}
+
+	/* sync the clock */
+	private_info->reference = timer->tick = TIMER_MATRIX[timer->interval].tick;
+
+	/* apply timestamp */
+	if (timer_step(timer) == SWITCH_STATUS_SUCCESS) {
+		/* push the reference into the future to prevent collision */
+		private_info->reference++;
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+static switch_status_t timer_next(switch_timer_t *timer)
+{
+	timer_private_t *private_info = timer->private_info;
+
+#ifdef DISABLE_1MS_COND
+	int cond_index = timer->interval;
+#else
+	int cond_index = 1;
+#endif
+	int delta = (int) (private_info->reference - TIMER_MATRIX[timer->interval].tick);
+
+	/* sync up timer if it's not been called for a while otherwise it will return instantly several times until it catches up */
+	if (delta < -1) {
+		private_info->reference = timer->tick = TIMER_MATRIX[timer->interval].tick;
+	}
+	timer_step(timer);
+
+	if (!MATRIX) {
+		do_sleep(1000 * timer->interval);
+		goto end;
+	}
+
+	while (globals.RUNNING == 1 && private_info->ready && TIMER_MATRIX[timer->interval].tick < private_info->reference) {
+		check_roll();
+
+		if (globals.timer_count >= runtime.tipping_point) {
+			os_yield();
+			globals.use_cond_yield = 0;
+		} else {
+			if (globals.use_cond_yield == 1) {
+				switch_mutex_lock(TIMER_MATRIX[cond_index].mutex);
+				if (TIMER_MATRIX[timer->interval].tick < private_info->reference) {
+					switch_thread_cond_wait(TIMER_MATRIX[cond_index].cond, TIMER_MATRIX[cond_index].mutex);
+				}
+				switch_mutex_unlock(TIMER_MATRIX[cond_index].mutex);
+			} else {
+				do_sleep(1000);
+			}
+		}
+	}
+
+  end:
+	return globals.RUNNING == 1 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
+}
+
+static switch_status_t timer_check(switch_timer_t *timer, switch_bool_t step)
+{
+	timer_private_t *private_info = timer->private_info;
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+	if (globals.RUNNING != 1 || !private_info->ready) {
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	check_roll();
+
+	timer->tick = TIMER_MATRIX[timer->interval].tick;
+
+	if (timer->tick < private_info->reference) {
+		timer->diff = private_info->reference - timer->tick;
+	} else {
+		timer->diff = 0;
+	}
+
+	if (timer->diff) {
+		status = SWITCH_STATUS_FALSE;
+	} else if (step) {
+		timer_step(timer);
+	}
+
+
+	return status;
+}
+
+static switch_status_t timer_destroy(switch_timer_t *timer)
+{
+	timer_private_t *private_info = timer->private_info;
+	if (timer->interval < MAX_ELEMENTS) {
+		switch_mutex_lock(globals.mutex);
+		TIMER_MATRIX[timer->interval].count--;
+		if (TIMER_MATRIX[timer->interval].count == 0) {
+			TIMER_MATRIX[timer->interval].tick = 0;
+		}
+		switch_mutex_unlock(globals.mutex);
+	}
+	if (private_info) {
+		private_info->ready = 0;
+	}
+
+	switch_mutex_lock(globals.mutex);
+	if (globals.timer_count) {
+		globals.timer_count--;
+		if (globals.timer_count == (runtime.tipping_point - 1)) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Fell Below tipping point of %u, shifting into low-gear.\n", runtime.tipping_point);
+		}
+	}
+	switch_mutex_unlock(globals.mutex);
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_MODULE_RUNTIME_FUNCTION(softtimer_runtime)
+{
+	switch_time_t too_late = STEP_MIC * 1000;
+	uint32_t current_ms = 0;
+	uint32_t x, tick = 0;
+	switch_time_t ts = 0, last = 0;
+	int fwd_errs = 0, rev_errs = 0;
+	int profile_tick = 0;
+
+	runtime.profile_timer = switch_new_profile_timer();
+	switch_get_system_idle_time(runtime.profile_timer, &runtime.profile_time);
+
+#ifdef HAVE_CPU_SET_MACROS
+	if (runtime.timer_affinity > -1) {
+		cpu_set_t set;
+		CPU_ZERO(&set);
+		CPU_SET(0, &set);
+		sched_setaffinity(runtime.timer_affinity, sizeof(set), &set);
+	}
+#endif
+
+	switch_time_sync();
+
+	globals.STARTED = globals.RUNNING = 1;
+	switch_mutex_lock(runtime.throttle_mutex);
+	runtime.sps = runtime.sps_total;
+	switch_mutex_unlock(runtime.throttle_mutex);
+
+	if (MONO) {
+		int loops;
+		for (loops = 0; loops < 3; loops++) {
+			ts = time_now(0);
+			/* if it returns the same value every time it won't be of much use. */
+			if (ts == last) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Broken MONOTONIC Clock Detected!, Support Disabled.\n");
+				MONO = 0;
+				NANO = 0;
+				runtime.reference = switch_time_now();
+				runtime.initiated = runtime.reference;
+				break;
+			}
+			do_sleep(STEP_MIC);
+			last = ts;
+		}
+	}
+
+	ts = 0;
+	last = 0;
+	fwd_errs = rev_errs = 0;
+
+#ifndef DISABLE_1MS_COND
+	if (!NANO) {
+		switch_mutex_init(&TIMER_MATRIX[1].mutex, SWITCH_MUTEX_NESTED, module_pool);
+		switch_thread_cond_create(&TIMER_MATRIX[1].cond, module_pool);
+	}
+#endif
+
+
+	switch_time_sync();
+
+	globals.use_cond_yield = COND;
+	globals.RUNNING = 1;
+
+	while (globals.RUNNING == 1) {
+		runtime.reference += STEP_MIC;
+		while ((ts = time_now(runtime.offset)) < runtime.reference) {
+			if (ts < last) {
+				if (MONO) {
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Virtual Migration Detected! Syncing Clock\n");
+					switch_time_sync();
+				} else {
+					int64_t diff = (int64_t) (ts - last);
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Reverse Clock Skew Detected!\n");
+					runtime.reference = switch_time_now();
+					current_ms = 0;
+					tick = 0;
+					runtime.initiated += diff;
+					rev_errs++;
+				}
+			} else {
+				rev_errs = 0;
+			}
+
+			if (globals.timer_count >= runtime.tipping_point) {
+				os_yield();
+			} else {
+				do_sleep(1000);
+			}
+
+			last = ts;
+		}
+
+		if (ts > (runtime.reference + too_late)) {
+			if (MONO) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Virtual Migration Detected! Syncing Clock\n");
+				switch_time_sync();
+			} else {
+				switch_time_t diff = ts - runtime.reference - STEP_MIC;
+#ifndef WIN32
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Forward Clock Skew Detected!\n");
+#endif
+				fwd_errs++;
+				runtime.reference = switch_time_now();
+				current_ms = 0;
+				tick = 0;
+				runtime.initiated += diff;
+			}
+		} else {
+			fwd_errs = 0;
+		}
+
+		if (fwd_errs > 9 || rev_errs > 9) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Auto Re-Syncing clock.\n");
+			switch_time_sync();
+			fwd_errs = rev_errs = 0;
+		}
+
+		runtime.timestamp = ts;
+		current_ms += STEP_MS;
+		tick += STEP_MS;
+
+		if (tick >= TICK_PER_SEC) {
+			if (++profile_tick == 1) {
+				switch_get_system_idle_time(runtime.profile_timer, &runtime.profile_time);
+				profile_tick = 0;
+			}
+			
+			if (runtime.sps <= 0) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Over Session Rate of %d!\n", runtime.sps_total);
+			}
+			switch_mutex_lock(runtime.throttle_mutex);
+			runtime.sps_last = runtime.sps_total - runtime.sps;
+			runtime.sps = runtime.sps_total;
+			switch_mutex_unlock(runtime.throttle_mutex);
+			tick = 0;
+		}
+#ifndef DISABLE_1MS_COND
+		TIMER_MATRIX[1].tick++;
+		if (switch_mutex_trylock(TIMER_MATRIX[1].mutex) == SWITCH_STATUS_SUCCESS) {
+			switch_thread_cond_broadcast(TIMER_MATRIX[1].cond);
+			switch_mutex_unlock(TIMER_MATRIX[1].mutex);
+		}
+		if (TIMER_MATRIX[1].tick == MAX_TICK) {
+			TIMER_MATRIX[1].tick = 0;
+			TIMER_MATRIX[1].roll++;
+		}
+#endif
+
+
+		if (MATRIX && (current_ms % MS_PER_TICK) == 0) {
+			for (x = MS_PER_TICK; x <= MAX_ELEMENTS; x += MS_PER_TICK) {
+				if ((current_ms % x) == 0) {
+					if (TIMER_MATRIX[x].count) {
+						TIMER_MATRIX[x].tick++;
+#ifdef DISABLE_1MS_COND
+
+						if (TIMER_MATRIX[x].mutex && switch_mutex_trylock(TIMER_MATRIX[x].mutex) == SWITCH_STATUS_SUCCESS) {
+							switch_thread_cond_broadcast(TIMER_MATRIX[x].cond);
+							switch_mutex_unlock(TIMER_MATRIX[x].mutex);
+						}
+#endif
+						if (TIMER_MATRIX[x].tick == MAX_TICK) {
+							TIMER_MATRIX[x].tick = 0;
+							TIMER_MATRIX[x].roll++;
+						}
+					}
+				}
+			}
+		}
+
+		if (current_ms == MAX_ELEMENTS) {
+			current_ms = 0;
+		}
+	}
+
+	globals.use_cond_yield = 0;
+
+	for (x = MS_PER_TICK; x <= MAX_ELEMENTS; x += MS_PER_TICK) {
+		if (TIMER_MATRIX[x].mutex && switch_mutex_trylock(TIMER_MATRIX[x].mutex) == SWITCH_STATUS_SUCCESS) {
+			switch_thread_cond_broadcast(TIMER_MATRIX[x].cond);
+			switch_mutex_unlock(TIMER_MATRIX[x].mutex);
+		}
+	}
+
+
+	switch_mutex_lock(globals.mutex);
+	globals.RUNNING = 0;
+	switch_mutex_unlock(globals.mutex);
+
+	switch_delete_profile_timer(&runtime.profile_timer);
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Soft timer thread exiting.\n");
+
+	return SWITCH_STATUS_TERM;
+}
+
+/* 
+   This converts a struct tm to a switch_time_exp_t
+   We have to use UNIX structures to do our exams
+   and use switch_* functions for the output.
+*/
+
+static void tm2switchtime(struct tm *tm, switch_time_exp_t *xt)
+{
+
+	if (!xt || !tm) {
+		return;
+	}
+	memset(xt, 0, sizeof(xt));
+
+	xt->tm_sec = tm->tm_sec;
+	xt->tm_min = tm->tm_min;
+	xt->tm_hour = tm->tm_hour;
+	xt->tm_mday = tm->tm_mday;
+	xt->tm_mon = tm->tm_mon;
+	xt->tm_year = tm->tm_year;
+	xt->tm_wday = tm->tm_wday;
+	xt->tm_yday = tm->tm_yday;
+	xt->tm_isdst = tm->tm_isdst;
+
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+	xt->tm_gmtoff = tm->tm_gmtoff;
+#endif
+
+	return;
+}
+
+/* **************************************************************************
+   LOADING OF THE XML DATA - HASH TABLE & MEMORY POOL MANAGEMENT
+   ************************************************************************** */
+
+typedef struct {
+	switch_memory_pool_t *pool;
+	switch_hash_t *hash;
+} switch_timezones_list_t;
+
+static switch_timezones_list_t TIMEZONES_LIST = { 0 };
+static switch_event_node_t *NODE = NULL;
+
+const char *switch_lookup_timezone(const char *tz_name)
+{
+	char *value = NULL;
+
+	if (tz_name && (value = switch_core_hash_find(TIMEZONES_LIST.hash, tz_name)) == NULL) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timezone '%s' not found!\n", tz_name);
+	}
+
+	return value;
+}
+
+void switch_load_timezones(switch_bool_t reload)
+{
+	switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, cfg = NULL;
+	unsigned total = 0;
+
+	if (TIMEZONES_LIST.hash) {
+		switch_core_hash_destroy(&TIMEZONES_LIST.hash);
+	}
+
+	if (TIMEZONES_LIST.pool) {
+		switch_core_destroy_memory_pool(&TIMEZONES_LIST.pool);
+	}
+
+	memset(&TIMEZONES_LIST, 0, sizeof(TIMEZONES_LIST));
+	switch_core_new_memory_pool(&TIMEZONES_LIST.pool);
+	switch_core_hash_init(&TIMEZONES_LIST.hash, TIMEZONES_LIST.pool);
+
+	if ((xml = switch_xml_open_cfg("timezones.conf", &cfg, NULL))) {
+		if ((x_lists = switch_xml_child(cfg, "timezones"))) {
+			for (x_list = switch_xml_child(x_lists, "zone"); x_list; x_list = x_list->next) {
+				const char *name = switch_xml_attr(x_list, "name");
+				const char *value = switch_xml_attr(x_list, "value");
+
+				if (zstr(name)) {
+					continue;
+				}
+
+				if (zstr(value)) {
+					continue;
+				}
+
+				switch_core_hash_insert(TIMEZONES_LIST.hash, name, switch_core_strdup(TIMEZONES_LIST.pool, value));
+				total++;
+			}
+		}
+
+		switch_xml_free(xml);
+	}
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Timezone %sloaded %d definitions\n", reload ? "re" : "", total);
+}
+
+static void event_handler(switch_event_t *event)
+{
+	switch_mutex_lock(globals.mutex);
+	switch_load_timezones(1);
+	switch_mutex_unlock(globals.mutex);
+}
+
+static void tztime(const time_t *const timep, const char *tzstring, struct tm *const tmp);
+
+SWITCH_DECLARE(switch_status_t) switch_time_exp_tz_name(const char *tz, switch_time_exp_t *tm, switch_time_t thetime)
+{
+	struct tm xtm = { 0 };
+	const char *tz_name = tz;
+	const char *tzdef;
+	time_t timep;
+
+	if (!thetime) {
+		thetime = switch_micro_time_now();
+	}
+
+	timep = (thetime) / (int64_t) (1000000);
+
+	if (!zstr(tz_name)) {
+		tzdef = switch_lookup_timezone(tz_name);
+	} else {
+		/* We set the default timezone to GMT. */
+		tz_name = "GMT";
+		tzdef = "GMT";
+	}
+
+	if (tzdef) {				/* The lookup of the zone may fail. */
+		tztime(&timep, tzdef, &xtm);
+		tm2switchtime(&xtm, tm);
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	return SWITCH_STATUS_FALSE;
+
+}
+
+SWITCH_DECLARE(switch_status_t) switch_strftime_tz(const char *tz, const char *format, char *date, size_t len, switch_time_t thetime)
+{
+	time_t timep;
+
+	const char *tz_name = tz;
+	const char *tzdef;
+
+	switch_size_t retsize;
+
+	struct tm tm = { 0 };
+	switch_time_exp_t stm;
+
+	if (!thetime) {
+		thetime = switch_micro_time_now();
+	}
+
+	timep = (thetime) / (int64_t) (1000000);
+
+	if (!zstr(tz_name)) {
+		tzdef = switch_lookup_timezone(tz_name);
+	} else {
+		/* We set the default timezone to GMT. */
+		tz_name = "GMT";
+		tzdef = "GMT";
+	}
+
+	if (tzdef) {				/* The lookup of the zone may fail. */
+		tztime(&timep, tzdef, &tm);
+		tm2switchtime(&tm, &stm);
+		switch_strftime_nocheck(date, &retsize, len, zstr(format) ? "%Y-%m-%d %T" : format, &stm);
+		if (!zstr_buf(date)) {
+			return SWITCH_STATUS_SUCCESS;
+		}
+	}
+	return SWITCH_STATUS_FALSE;
+}
+
+SWITCH_MODULE_LOAD_FUNCTION(softtimer_load)
+{
+	switch_timer_interface_t *timer_interface;
+	module_pool = pool;
+
+#if defined(WIN32)
+	timeBeginPeriod(1);
+#endif
+
+	memset(&globals, 0, sizeof(globals));
+	switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, module_pool);
+
+	if ((switch_event_bind_removable(modname, SWITCH_EVENT_RELOADXML, NULL, event_handler, NULL, &NODE) != SWITCH_STATUS_SUCCESS)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind!\n");
+	}
+	switch_load_timezones(0);
+
+	/* connect my internal structure to the blank pointer passed to me */
+	*module_interface = switch_loadable_module_create_module_interface(pool, modname);
+	timer_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_TIMER_INTERFACE);
+	timer_interface->interface_name = "soft";
+	timer_interface->timer_init = timer_init;
+	timer_interface->timer_next = timer_next;
+	timer_interface->timer_step = timer_step;
+	timer_interface->timer_sync = timer_sync;
+	timer_interface->timer_check = timer_check;
+	timer_interface->timer_destroy = timer_destroy;
+
+	if (!switch_test_flag((&runtime), SCF_USE_CLOCK_RT)) {
+		switch_time_set_nanosleep(SWITCH_FALSE);
+	}
+
+	if (switch_test_flag((&runtime), SCF_USE_HEAVY_TIMING)) {
+		switch_time_set_cond_yield(SWITCH_FALSE);
+	}
+
+	if (switch_test_flag((&runtime), SCF_CALIBRATE_CLOCK)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Calibrating timer, please wait...\n");
+		switch_time_calibrate_clock();
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clock calibration disabled.\n");
+	}
+
+	/* indicate that the module should continue to be loaded */
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_MODULE_SHUTDOWN_FUNCTION(softtimer_shutdown)
+{
+	globals.use_cond_yield = 0;
+
+	if (globals.RUNNING == 1) {
+		switch_mutex_lock(globals.mutex);
+		globals.RUNNING = -1;
+		switch_mutex_unlock(globals.mutex);
+
+		while (globals.RUNNING == -1) {
+			do_sleep(10000);
+		}
+	}
+#if defined(WIN32)
+	timeEndPeriod(1);
+#endif
+
+	if (TIMEZONES_LIST.hash) {
+		switch_core_hash_destroy(&TIMEZONES_LIST.hash);
+	}
+
+	if (TIMEZONES_LIST.pool) {
+		switch_core_destroy_memory_pool(&TIMEZONES_LIST.pool);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+
+
+/*
+ *    This file was originally written for NetBSD and is in the public domain, 
+ *    so clarified as of 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).
+ *    
+ *    Iw was modified by Massimo Cetra in order to be used with Callweaver and Freeswitch.
+ */
+
+//#define TESTING_IT 1
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <assert.h>
+
+
+#ifdef TESTING_IT
+#include <sys/time.h>
+#endif
+
+
+#ifndef TRUE
+#define TRUE	1
+#endif /* !defined TRUE */
+
+#ifndef FALSE
+#define FALSE	0
+#endif /* !defined FALSE */
+
+
+
+#ifndef TZ_MAX_TIMES
+/*
+** The TZ_MAX_TIMES value below is enough to handle a bit more than a
+** year's worth of solar time (corrected daily to the nearest second) or
+** 138 years of Pacific Presidential Election time
+** (where there are three time zone transitions every fourth year).
+*/
+#define TZ_MAX_TIMES	370
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZ_MAX_TYPES
+
+#ifndef NOSOLAR
+#define TZ_MAX_TYPES	256		/* Limited by what (unsigned char)'s can hold */
+#endif /* !defined NOSOLAR */
+
+#ifdef NOSOLAR
+/*
+** Must be at least 14 for Europe/Riga as of Jan 12 1995,
+** as noted by Earl Chew <earl@hpato.aus.hp.com>.
+*/
+#define TZ_MAX_TYPES	20		/* Maximum number of local time types */
+#endif /* !defined NOSOLAR */
+
+#endif /* !defined TZ_MAX_TYPES */
+
+#ifndef TZ_MAX_CHARS
+#define TZ_MAX_CHARS	50		/* Maximum number of abbreviation characters */
+				/* (limited by what unsigned chars can hold) */
+#endif /* !defined TZ_MAX_CHARS */
+
+#ifndef TZ_MAX_LEAPS
+#define TZ_MAX_LEAPS	50		/* Maximum number of leap second corrections */
+#endif /* !defined TZ_MAX_LEAPS */
+
+#ifdef TZNAME_MAX
+#define MY_TZNAME_MAX	TZNAME_MAX
+#endif /* defined TZNAME_MAX */
+
+#ifndef TZNAME_MAX
+#define MY_TZNAME_MAX	255
+#endif /* !defined TZNAME_MAX */
+
+
+#define SECSPERMIN	60
+#define MINSPERHOUR	60
+#define HOURSPERDAY	24
+#define DAYSPERWEEK	7
+#define DAYSPERNYEAR	365
+#define DAYSPERLYEAR	366
+#define SECSPERHOUR	(SECSPERMIN * MINSPERHOUR)
+#define SECSPERDAY	((long) SECSPERHOUR * HOURSPERDAY)
+#define MONSPERYEAR	12
+
+#define JULIAN_DAY		0		/* Jn - Julian day */
+#define DAY_OF_YEAR		1		/* n - day of year */
+#define MONTH_NTH_DAY_OF_WEEK	2	/* Mm.n.d - month, week, day of week */
+
+#define EPOCH_YEAR	1970
+#define EPOCH_WDAY	TM_THURSDAY
+
+
+#ifndef TZ_MAX_TIMES
+/*
+** The TZ_MAX_TIMES value below is enough to handle a bit more than a
+** year's worth of solar time (corrected daily to the nearest second) or
+** 138 years of Pacific Presidential Election time
+** (where there are three time zone transitions every fourth year).
+*/
+#define TZ_MAX_TIMES	370
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZDEFRULES
+#define TZDEFRULES	"posixrules"
+#endif /* !defined TZDEFRULES */
+
+/*
+** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.
+** We default to US rules as of 1999-08-17.
+** POSIX 1003.1 section 8.1.1 says that the default DST rules are
+** implementation dependent; for historical reasons, US rules are a
+** common default.
+*/
+#ifndef TZDEFRULESTRING
+#define TZDEFRULESTRING ",M4.1.0,M10.5.0"
+#endif /* !defined TZDEFDST */
+
+/* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX.  */
+#define is_digit(c) ((unsigned)(c) - '0' <= 9)
+
+#define BIGGEST(a, b)	(((a) > (b)) ? (a) : (b))
+
+#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
+
+
+
+/*
+** INITIALIZE(x)
+*/
+
+#ifndef GNUC_or_lint
+#ifdef lint
+#define GNUC_or_lint
+#endif /* defined lint */
+#ifndef lint
+#ifdef __GNUC__
+#define GNUC_or_lint
+#endif /* defined __GNUC__ */
+#endif /* !defined lint */
+#endif /* !defined GNUC_or_lint */
+#ifdef WIN32
+#define GNUC_or_lint
+#endif
+
+#ifndef INITIALIZE
+#ifdef GNUC_or_lint
+#define INITIALIZE(x)	((x) = 0)
+#endif /* defined GNUC_or_lint */
+#ifndef GNUC_or_lint
+#define INITIALIZE(x)
+#endif /* !defined GNUC_or_lint */
+#endif /* !defined INITIALIZE */
+
+
+#define TM_SUNDAY	0
+#define TM_MONDAY	1
+#define TM_TUESDAY	2
+#define TM_WEDNESDAY	3
+#define TM_THURSDAY	4
+#define TM_FRIDAY	5
+#define TM_SATURDAY	6
+
+#define TM_JANUARY	0
+#define TM_FEBRUARY	1
+#define TM_MARCH	2
+#define TM_APRIL	3
+#define TM_MAY		4
+#define TM_JUNE		5
+#define TM_JULY		6
+#define TM_AUGUST	7
+#define TM_SEPTEMBER	8
+#define TM_OCTOBER	9
+#define TM_NOVEMBER	10
+#define TM_DECEMBER	11
+
+#define TM_YEAR_BASE	1900
+
+#define EPOCH_YEAR	1970
+#define EPOCH_WDAY	TM_THURSDAY
+
+
+/* **************************************************************************
+	    
+   ************************************************************************** */
+
+static const char gmt[] = "GMT";
+
+#define CHARS_DEF BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), (2 * (MY_TZNAME_MAX + 1)))
+
+struct rule {
+	int r_type;					/* type of rule--see below */
+	int r_day;					/* day number of rule */
+	int r_week;					/* week number of rule */
+	int r_mon;					/* month number of rule */
+	long r_time;				/* transition time of rule */
+};
+
+struct ttinfo {					/* time type information */
+	long tt_gmtoff;				/* UTC offset in seconds */
+	int tt_isdst;				/* used to set tm_isdst */
+	int tt_abbrind;				/* abbreviation list index */
+	int tt_ttisstd;				/* TRUE if transition is std time */
+	int tt_ttisgmt;				/* TRUE if transition is UTC */
+};
+
+struct lsinfo {					/* leap second information */
+	time_t ls_trans;			/* transition time */
+	long ls_corr;				/* correction to apply */
+};
+
+
+struct state {
+	int leapcnt;
+	int timecnt;
+	int typecnt;
+	int charcnt;
+	time_t ats[TZ_MAX_TIMES];
+	unsigned char types[TZ_MAX_TIMES];
+	struct ttinfo ttis[TZ_MAX_TYPES];
+	char chars[ /* LINTED constant */ CHARS_DEF];
+	struct lsinfo lsis[TZ_MAX_LEAPS];
+};
+
+
+static const int mon_lengths[2][MONSPERYEAR] = {
+	{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+	{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+};
+
+static const int year_lengths[2] = {
+	DAYSPERNYEAR, DAYSPERLYEAR
+};
+
+
+/* **************************************************************************
+	    
+   ************************************************************************** */
+
+
+/*
+    Given a pointer into a time zone string, scan until a character that is not
+    a valid character in a zone name is found.  Return a pointer to that
+    character.
+*/
+
+static const char *getzname(register const char *strp)
+{
+	register char c;
+
+	while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && c != '+')
+		++strp;
+	return strp;
+}
+
+
+/*
+    Given a pointer into a time zone string, extract a number from that string.
+    Check that the number is within a specified range; if it is not, return
+    NULL.
+    Otherwise, return a pointer to the first character not part of the number.
+*/
+
+static const char *getnum(register const char *strp, int *const nump, const int min, const int max)
+{
+	register char c;
+	register int num;
+
+	if (strp == NULL || !is_digit(c = *strp))
+		return NULL;
+	num = 0;
+	do {
+		num = num * 10 + (c - '0');
+		if (num > max)
+			return NULL;		/* illegal value */
+		c = *++strp;
+	} while (is_digit(c));
+	if (num < min)
+		return NULL;			/* illegal value */
+	*nump = num;
+	return strp;
+}
+
+/*
+    Given a pointer into a time zone string, extract a number of seconds,
+    in hh[:mm[:ss]] form, from the string.
+    If any error occurs, return NULL.
+    Otherwise, return a pointer to the first character not part of the number
+    of seconds.
+*/
+
+static const char *getsecs(register const char *strp, long *const secsp)
+{
+	int num;
+
+	/*
+	 ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
+	 ** "M10.4.6/26", which does not conform to Posix,
+	 ** but which specifies the equivalent of
+	 ** ``02:00 on the first Sunday on or after 23 Oct''.
+	 */
+	strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
+	if (strp == NULL)
+		return NULL;
+	*secsp = num * (long) SECSPERHOUR;
+	if (*strp == ':') {
+		++strp;
+		strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
+		if (strp == NULL)
+			return NULL;
+		*secsp += num * SECSPERMIN;
+		if (*strp == ':') {
+			++strp;
+			/* `SECSPERMIN' allows for leap seconds.  */
+			strp = getnum(strp, &num, 0, SECSPERMIN);
+			if (strp == NULL)
+				return NULL;
+			*secsp += num;
+		}
+	}
+	return strp;
+}
+
+/*
+    Given a pointer into a time zone string, extract an offset, in
+    [+-]hh[:mm[:ss]] form, from the string.
+    If any error occurs, return NULL.
+    Otherwise, return a pointer to the first character not part of the time.
+*/
+
+static const char *getoffset(register const char *strp, long *const offsetp)
+{
+	register int neg = 0;
+
+	if (*strp == '-') {
+		neg = 1;
+		++strp;
+	} else if (*strp == '+')
+		++strp;
+	strp = getsecs(strp, offsetp);
+	if (strp == NULL)
+		return NULL;			/* illegal time */
+	if (neg)
+		*offsetp = -*offsetp;
+	return strp;
+}
+
+/*
+    Given a pointer into a time zone string, extract a rule in the form
+    date[/time].  See POSIX section 8 for the format of "date" and "time".
+    If a valid rule is not found, return NULL.
+    Otherwise, return a pointer to the first character not part of the rule.
+*/
+
+static const char *getrule(const char *strp, register struct rule *const rulep)
+{
+	if (*strp == 'J') {
+		/*
+		 ** Julian day.
+		 */
+		rulep->r_type = JULIAN_DAY;
+		++strp;
+		strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
+	} else if (*strp == 'M') {
+		/*
+		 ** Month, week, day.
+		 */
+		rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
+		++strp;
+		strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
+		if (strp == NULL)
+			return NULL;
+		if (*strp++ != '.')
+			return NULL;
+		strp = getnum(strp, &rulep->r_week, 1, 5);
+		if (strp == NULL)
+			return NULL;
+		if (*strp++ != '.')
+			return NULL;
+		strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
+	} else if (is_digit(*strp)) {
+		/*
+		 ** Day of year.
+		 */
+		rulep->r_type = DAY_OF_YEAR;
+		strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
+	} else
+		return NULL;			/* invalid format */
+	if (strp == NULL)
+		return NULL;
+	if (*strp == '/') {
+		/*
+		 ** Time specified.
+		 */
+		++strp;
+		strp = getsecs(strp, &rulep->r_time);
+	} else
+		rulep->r_time = 2 * SECSPERHOUR;	/* default = 2:00:00 */
+	return strp;
+}
+
+
+/*
+    Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the
+    year, a rule, and the offset from UTC at the time that rule takes effect,
+    calculate the Epoch-relative time that rule takes effect.
+*/
+
+static time_t transtime(const time_t janfirst, const int year, register const struct rule *const rulep, const long offset)
+{
+	register int leapyear;
+	register time_t value;
+	register int i;
+	int d, m1, yy0, yy1, yy2, dow;
+
+	INITIALIZE(value);
+	leapyear = isleap(year);
+	switch (rulep->r_type) {
+
+	case JULIAN_DAY:
+		/*
+		 ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
+		 ** years.
+		 ** In non-leap years, or if the day number is 59 or less, just
+		 ** add SECSPERDAY times the day number-1 to the time of
+		 ** January 1, midnight, to get the day.
+		 */
+		value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
+		if (leapyear && rulep->r_day >= 60)
+			value += SECSPERDAY;
+		break;
+
+	case DAY_OF_YEAR:
+		/*
+		 ** n - day of year.
+		 ** Just add SECSPERDAY times the day number to the time of
+		 ** January 1, midnight, to get the day.
+		 */
+		value = janfirst + rulep->r_day * SECSPERDAY;
+		break;
+
+	case MONTH_NTH_DAY_OF_WEEK:
+		/*
+		 ** Mm.n.d - nth "dth day" of month m.
+		 */
+		value = janfirst;
+		for (i = 0; i < rulep->r_mon - 1; ++i)
+			value += mon_lengths[leapyear][i] * SECSPERDAY;
+
+		/*
+		 ** Use Zeller's Congruence to get day-of-week of first day of
+		 ** month.
+		 */
+		m1 = (rulep->r_mon + 9) % 12 + 1;
+		yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
+		yy1 = yy0 / 100;
+		yy2 = yy0 % 100;
+		dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
+		if (dow < 0)
+			dow += DAYSPERWEEK;
+
+		/*
+		 ** "dow" is the day-of-week of the first day of the month.  Get
+		 ** the day-of-month (zero-origin) of the first "dow" day of the
+		 ** month.
+		 */
+		d = rulep->r_day - dow;
+		if (d < 0)
+			d += DAYSPERWEEK;
+		for (i = 1; i < rulep->r_week; ++i) {
+			if (d + DAYSPERWEEK >= mon_lengths[leapyear][rulep->r_mon - 1])
+				break;
+			d += DAYSPERWEEK;
+		}
+
+		/*
+		 ** "d" is the day-of-month (zero-origin) of the day we want.
+		 */
+		value += d * SECSPERDAY;
+		break;
+	}
+
+	/*
+	 ** "value" is the Epoch-relative time of 00:00:00 UTC on the day in
+	 ** question.  To get the Epoch-relative time of the specified local
+	 ** time on that day, add the transition time and the current offset
+	 ** from UTC.
+	 */
+	return value + rulep->r_time + offset;
+}
+
+
+
+/*
+    Given a POSIX section 8-style TZ string, fill in the rule tables as
+    appropriate.
+*/
+
+static int tzparse(const char *name, register struct state *const sp, const int lastditch)
+{
+	const char *stdname;
+	const char *dstname;
+	size_t stdlen;
+	size_t dstlen;
+	long stdoffset;
+	long dstoffset;
+	register time_t *atp;
+	register unsigned char *typep;
+	register char *cp;
+
+
+	INITIALIZE(dstname);
+	stdname = name;
+
+	if (lastditch) {
+		stdlen = strlen(name);	/* length of standard zone name */
+		name += stdlen;
+		if (stdlen >= sizeof sp->chars)
+			stdlen = (sizeof sp->chars) - 1;
+		stdoffset = 0;
+	} else {
+		name = getzname(name);
+		stdlen = name - stdname;
+		if (stdlen < 3)
+			return -1;
+		if (*name == '\0')
+			return -1;
+		name = getoffset(name, &stdoffset);
+		if (name == NULL)
+			return -1;
+	}
+
+	sp->leapcnt = 0;			/* so, we're off a little */
+
+	if (*name != '\0') {
+		dstname = name;
+		name = getzname(name);
+		dstlen = name - dstname;	/* length of DST zone name */
+		if (dstlen < 3)
+			return -1;
+		if (*name != '\0' && *name != ',' && *name != ';') {
+			name = getoffset(name, &dstoffset);
+			if (name == NULL)
+				return -1;
+		} else
+			dstoffset = stdoffset - SECSPERHOUR;
+
+		/* Go parsing the daylight saving stuff */
+		if (*name == ',' || *name == ';') {
+			struct rule start;
+			struct rule end;
+			register int year;
+			register time_t janfirst;
+			time_t starttime;
+			time_t endtime;
+
+			++name;
+			if ((name = getrule(name, &start)) == NULL)
+				return -1;
+			if (*name++ != ',')
+				return -1;
+			if ((name = getrule(name, &end)) == NULL)
+				return -1;
+			if (*name != '\0')
+				return -1;
+
+			sp->typecnt = 2;	/* standard time and DST */
+
+			/*
+			 ** Two transitions per year, from EPOCH_YEAR to 2037.
+			 */
+			sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
+
+			if (sp->timecnt > TZ_MAX_TIMES)
+				return -1;
+
+			sp->ttis[0].tt_gmtoff = -dstoffset;
+			sp->ttis[0].tt_isdst = 1;
+			sp->ttis[0].tt_abbrind = (int) (stdlen + 1);
+			sp->ttis[1].tt_gmtoff = -stdoffset;
+			sp->ttis[1].tt_isdst = 0;
+			sp->ttis[1].tt_abbrind = 0;
+
+			atp = sp->ats;
+			typep = sp->types;
+			janfirst = 0;
+
+			for (year = EPOCH_YEAR; year <= 2037; ++year) {
+				starttime = transtime(janfirst, year, &start, stdoffset);
+				endtime = transtime(janfirst, year, &end, dstoffset);
+				if (starttime > endtime) {
+					*atp++ = endtime;
+					*typep++ = 1;	/* DST ends */
+					*atp++ = starttime;
+					*typep++ = 0;	/* DST begins */
+				} else {
+					*atp++ = starttime;
+					*typep++ = 0;	/* DST begins */
+					*atp++ = endtime;
+					*typep++ = 1;	/* DST ends */
+				}
+
+				janfirst += year_lengths[isleap(year)] * SECSPERDAY;
+			}
+
+		} else {
+			register long theirstdoffset;
+			register long theirdstoffset;
+			register long theiroffset;
+			register int isdst;
+			register int i;
+			register int j;
+
+			if (*name != '\0')
+				return -1;
+			/*
+			   Initial values of theirstdoffset and theirdstoffset.
+			 */
+			theirstdoffset = 0;
+			for (i = 0; i < sp->timecnt; ++i) {
+				j = sp->types[i];
+				if (!sp->ttis[j].tt_isdst) {
+					theirstdoffset = -sp->ttis[j].tt_gmtoff;
+					break;
+				}
+			}
+			theirdstoffset = 0;
+			for (i = 0; i < sp->timecnt; ++i) {
+				j = sp->types[i];
+				if (sp->ttis[j].tt_isdst) {
+					theirdstoffset = -sp->ttis[j].tt_gmtoff;
+					break;
+				}
+			}
+			/*
+			 ** Initially we're assumed to be in standard time.
+			 */
+			isdst = FALSE;
+			theiroffset = theirstdoffset;
+			/*
+			 ** Now juggle transition times and types
+			 ** tracking offsets as you do.
+			 */
+			for (i = 0; i < sp->timecnt; ++i) {
+				j = sp->types[i];
+				sp->types[i] = (unsigned char) sp->ttis[j].tt_isdst;
+				if (sp->ttis[j].tt_ttisgmt) {
+					/* No adjustment to transition time */
+				} else {
+					/*
+					 ** If summer time is in effect, and the
+					 ** transition time was not specified as
+					 ** standard time, add the summer time
+					 ** offset to the transition time;
+					 ** otherwise, add the standard time
+					 ** offset to the transition time.
+					 */
+					/*
+					 ** Transitions from DST to DDST
+					 ** will effectively disappear since
+					 ** POSIX provides for only one DST
+					 ** offset.
+					 */
+					if (isdst && !sp->ttis[j].tt_ttisstd) {
+						sp->ats[i] += dstoffset - theirdstoffset;
+					} else {
+						sp->ats[i] += stdoffset - theirstdoffset;
+					}
+				}
+				theiroffset = -sp->ttis[j].tt_gmtoff;
+				if (sp->ttis[j].tt_isdst)
+					theirdstoffset = theiroffset;
+				else
+					theirstdoffset = theiroffset;
+			}
+			/*
+			 ** Finally, fill in ttis.
+			 ** ttisstd and ttisgmt need not be handled.
+			 */
+			sp->ttis[0].tt_gmtoff = -stdoffset;
+			sp->ttis[0].tt_isdst = FALSE;
+			sp->ttis[0].tt_abbrind = 0;
+			sp->ttis[1].tt_gmtoff = -dstoffset;
+			sp->ttis[1].tt_isdst = TRUE;
+			sp->ttis[1].tt_abbrind = (int) (stdlen + 1);
+			sp->typecnt = 2;
+		}
+	} else {
+		dstlen = 0;
+		sp->typecnt = 1;		/* only standard time */
+		sp->timecnt = 0;
+		sp->ttis[0].tt_gmtoff = -stdoffset;
+		sp->ttis[0].tt_isdst = 0;
+		sp->ttis[0].tt_abbrind = 0;
+	}
+
+	sp->charcnt = (int) (stdlen + 1);
+	if (dstlen != 0)
+		sp->charcnt += (int) (dstlen + 1);
+	if ((size_t) sp->charcnt > sizeof sp->chars)
+		return -1;
+	cp = sp->chars;
+	(void) strncpy(cp, stdname, stdlen);
+	cp += stdlen;
+	*cp++ = '\0';
+	if (dstlen != 0) {
+		(void) strncpy(cp, dstname, dstlen);
+		*(cp + dstlen) = '\0';
+	}
+	return 0;
+}
+
+/* **************************************************************************
+	    
+   ************************************************************************** */
+#if (_MSC_VER >= 1400)			// VC8+
+#define switch_assert(expr) assert(expr);__analysis_assume( expr )
+#else
+#define switch_assert(expr) assert(expr)
+#endif
+
+static void timesub(const time_t *const timep, const long offset, register const struct state *const sp, register struct tm *const tmp)
+{
+	register const struct lsinfo *lp;
+	register long days;
+	register time_t rem;
+	register int y;
+	register int yleap;
+	register const int *ip;
+	register long corr;
+	register int hit;
+	register int i;
+
+	switch_assert(timep != NULL);
+	switch_assert(sp != NULL);
+	switch_assert(tmp != NULL);
+
+	corr = 0;
+	hit = 0;
+	i = (sp == NULL) ? 0 : sp->leapcnt;
+
+	while (--i >= 0) {
+		lp = &sp->lsis[i];
+		if (*timep >= lp->ls_trans) {
+			if (*timep == lp->ls_trans) {
+				hit = ((i == 0 && lp->ls_corr > 0) || (i > 0 && lp->ls_corr > sp->lsis[i - 1].ls_corr));
+				if (hit)
+					while (i > 0 && sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 && sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1) {
+						++hit;
+						--i;
+					}
+			}
+			corr = lp->ls_corr;
+			break;
+		}
+	}
+	days = (long) (*timep / SECSPERDAY);
+	rem = *timep % SECSPERDAY;
+
+
+#ifdef mc68k
+	/* If this is for CPU bugs workarounds, i would remove this anyway. Who would use it on an old mc68k ? */
+	if (*timep == 0x80000000) {
+		/*
+		 ** A 3B1 muffs the division on the most negative number.
+		 */
+		days = -24855;
+		rem = -11648;
+	}
+#endif
+
+	rem += (offset - corr);
+	while (rem < 0) {
+		rem += SECSPERDAY;
+		--days;
+	}
+	while (rem >= SECSPERDAY) {
+		rem -= SECSPERDAY;
+		++days;
+	}
+	tmp->tm_hour = (int) (rem / SECSPERHOUR);
+	rem = rem % SECSPERHOUR;
+	tmp->tm_min = (int) (rem / SECSPERMIN);
+
+	/*
+	 ** A positive leap second requires a special
+	 ** representation.  This uses "... ??:59:60" et seq.
+	 */
+	tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
+	tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
+
+	if (tmp->tm_wday < 0)
+		tmp->tm_wday += DAYSPERWEEK;
+
+	y = EPOCH_YEAR;
+
+#define LEAPS_THRU_END_OF(y)	((y) / 4 - (y) / 100 + (y) / 400)
+
+	while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) {
+		register int newy;
+
+		newy = (int) (y + days / DAYSPERNYEAR);
+		if (days < 0)
+			--newy;
+		days -= (newy - y) * DAYSPERNYEAR + LEAPS_THRU_END_OF(newy - 1) - LEAPS_THRU_END_OF(y - 1);
+		y = newy;
+	}
+
+	tmp->tm_year = y - TM_YEAR_BASE;
+	tmp->tm_yday = (int) days;
+
+	ip = mon_lengths[yleap];
+
+	for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon))
+		days = days - (long) ip[tmp->tm_mon];
+
+	tmp->tm_mday = (int) (days + 1);
+	tmp->tm_isdst = 0;
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+	tmp->tm_gmtoff = offset;
+#endif
+}
+
+/* **************************************************************************
+	    
+   ************************************************************************** */
+
+static void tztime(const time_t *const timep, const char *tzstring, struct tm *const tmp)
+{
+	struct state *tzptr, *sp;
+	const time_t t = *timep;
+	register int i;
+	register const struct ttinfo *ttisp;
+
+	if (tzstring == NULL)
+		tzstring = gmt;
+
+	tzptr = (struct state *) malloc(sizeof(struct state));
+	sp = tzptr;
+
+	if (tzptr != NULL) {
+
+		memset(tzptr, 0, sizeof(struct state));
+
+		(void) tzparse(tzstring, tzptr, FALSE);
+
+		if (sp->timecnt == 0 || t < sp->ats[0]) {
+			i = 0;
+			while (sp->ttis[i].tt_isdst)
+				if (++i >= sp->typecnt) {
+					i = 0;
+					break;
+				}
+		} else {
+			for (i = 1; i < sp->timecnt; ++i)
+				if (t < sp->ats[i])
+					break;
+			i = sp->types[i - 1];	// DST begin or DST end
+		}
+		ttisp = &sp->ttis[i];
+
+		/*
+		   To get (wrong) behavior that's compatible with System V Release 2.0
+		   you'd replace the statement below with
+		   t += ttisp->tt_gmtoff;
+		   timesub(&t, 0L, sp, tmp);
+		 */
+		if (tmp != NULL) {		/* Just a check not to assert */
+			timesub(&t, ttisp->tt_gmtoff, sp, tmp);
+			tmp->tm_isdst = ttisp->tt_isdst;
+#if defined(HAVE_STRUCT_TM_TM_ZONE)
+			tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
+#endif
+		}
+
+		free(tzptr);
+	}
+
+}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */