Diff
Added: freeswitch/trunk/build/strip.pl (0 => 17516)
--- freeswitch/trunk/build/strip.pl (rev 0)
+++ freeswitch/trunk/build/strip.pl 2010-05-10 18:07:34 UTC (rev 17516)
@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+while(<>) {
+ s/SWITCH_DECLARE_CONSTRUCTOR//g;
+ s/SWITCH_DECLARE[^\(]*\((.*?)\)/$1/g;
+ print;
+}
Property changes on: freeswitch/trunk/build/strip.pl
___________________________________________________________________
Name: svn:executable
+ on
Modified: freeswitch/trunk/src/include/switch_cpp.h (17515 => 17516)
--- freeswitch/trunk/src/include/switch_cpp.h 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/include/switch_cpp.h 2010-05-10 18:07:34 UTC (rev 17516)
@@ -170,12 +170,12 @@
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);
};
Added: freeswitch/trunk/src/include/switch_types.h.orig (0 => 17516)
--- freeswitch/trunk/src/include/switch_types.h.orig (rev 0)
+++ freeswitch/trunk/src/include/switch_types.h.orig 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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:
+ */
Added: freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c.orig (0 => 17516)
--- freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c.orig (rev 0)
+++ freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c.orig 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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(¶ms, 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(¶ms);
+ }
+ 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(¶ms, 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(¶ms);
+ 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(¶ms, 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(¶ms);
+
+ /* 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:
+ */
Added: freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c.rej (0 => 17516)
--- freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c.rej (rev 0)
+++ freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c.rej 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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;
+ }
Added: freeswitch/trunk/src/mod/formats/mod_sndfile/mod_sndfile.c.orig (0 => 17516)
--- freeswitch/trunk/src/mod/formats/mod_sndfile/mod_sndfile.c.orig (rev 0)
+++ freeswitch/trunk/src/mod/formats/mod_sndfile/mod_sndfile.c.orig 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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:
+ */
Modified: freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/API.java 2010-05-10 18:07:34 UTC (rev 17516)
@@ -38,13 +38,9 @@
}
public String execute(String command, String data) {
- return freeswitchJNI.API_execute__SWIG_0(swigCPtr, this, command, data);
+ return freeswitchJNI.API_execute(swigCPtr, this, command, data);
}
- public String execute(String command) {
- return freeswitchJNI.API_execute__SWIG_1(swigCPtr, this, command);
- }
-
public String executeString(String command) {
return freeswitchJNI.API_executeString(swigCPtr, this, command);
}
Modified: freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/CoreSession.java 2010-05-10 18:07:34 UTC (rev 17516)
@@ -125,13 +125,9 @@
}
public void hangup(String cause) {
- freeswitchJNI.CoreSession_hangup__SWIG_0(swigCPtr, this, cause);
+ freeswitchJNI.CoreSession_hangup(swigCPtr, this, cause);
}
- public void hangup() {
- freeswitchJNI.CoreSession_hangup__SWIG_1(swigCPtr, this);
- }
-
public void hangupState() {
freeswitchJNI.CoreSession_hangupState(swigCPtr, this);
}
@@ -158,25 +154,13 @@
}
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);
+ freeswitchJNI.CoreSession_say(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);
- }
-
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);
+ freeswitchJNI.CoreSession_sayPhrase(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);
- }
-
public String hangupCause() {
return freeswitchJNI.CoreSession_hangupCause(swigCPtr, this);
}
@@ -186,33 +170,13 @@
}
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);
+ return freeswitchJNI.CoreSession_recordFile(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);
- }
-
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));
+ 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 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);
- }
-
public void destroy() {
freeswitchJNI.CoreSession_destroy(swigCPtr, this);
}
@@ -246,45 +210,25 @@
}
public int transfer(String extension, String dialplan, String context) {
- return freeswitchJNI.CoreSession_transfer__SWIG_0(swigCPtr, this, extension, dialplan, context);
+ return freeswitchJNI.CoreSession_transfer(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);
- }
-
public String read(int min_digits, int max_digits, String prompt_audio_file, int timeout, String valid_terminators) {
return freeswitchJNI.CoreSession_read(swigCPtr, this, min_digits, max_digits, prompt_audio_file, timeout, valid_terminators);
}
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);
+ 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 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);
- }
-
public int streamFile(String file, int starting_sample_count) {
- return freeswitchJNI.CoreSession_streamFile__SWIG_0(swigCPtr, this, file, starting_sample_count);
+ return freeswitchJNI.CoreSession_streamFile(swigCPtr, this, file, starting_sample_count);
}
- public int streamFile(String file) {
- return freeswitchJNI.CoreSession_streamFile__SWIG_1(swigCPtr, this, file);
- }
-
public int sleep(int ms, int sync) {
- return freeswitchJNI.CoreSession_sleep__SWIG_0(swigCPtr, this, ms, sync);
+ return freeswitchJNI.CoreSession_sleep(swigCPtr, this, ms, sync);
}
- public int sleep(int ms) {
- return freeswitchJNI.CoreSession_sleep__SWIG_1(swigCPtr, this, ms);
- }
-
public int flushEvents() {
return freeswitchJNI.CoreSession_flushEvents(swigCPtr, this);
}
@@ -322,13 +266,9 @@
}
public void execute(String app, String data) {
- freeswitchJNI.CoreSession_execute__SWIG_0(swigCPtr, this, app, data);
+ freeswitchJNI.CoreSession_execute(swigCPtr, this, app, data);
}
- public void execute(String app) {
- freeswitchJNI.CoreSession_execute__SWIG_1(swigCPtr, this, app);
- }
-
public void sendEvent(Event sendME) {
freeswitchJNI.CoreSession_sendEvent(swigCPtr, this, Event.getCPtr(sendME), sendME);
}
Modified: freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/DTMF.java 2010-05-10 18:07:34 UTC (rev 17516)
@@ -50,11 +50,7 @@
}
public DTMF(char idigit, SWIGTYPE_p_uint32_t iduration) {
- this(freeswitchJNI.new_DTMF__SWIG_0(idigit, SWIGTYPE_p_uint32_t.getCPtr(iduration)), true);
+ this(freeswitchJNI.new_DTMF(idigit, SWIGTYPE_p_uint32_t.getCPtr(iduration)), true);
}
- public DTMF(char idigit) {
- this(freeswitchJNI.new_DTMF__SWIG_1(idigit), true);
- }
-
}
Modified: freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/Event.java 2010-05-10 18:07:34 UTC (rev 17516)
@@ -62,34 +62,18 @@
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);
+ this(freeswitchJNI.new_Event__SWIG_1(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);
- }
-
public String serialize(String format) {
- return freeswitchJNI.Event_serialize__SWIG_0(swigCPtr, this, format);
+ return freeswitchJNI.Event_serialize(swigCPtr, this, format);
}
- public String serialize() {
- return freeswitchJNI.Event_serialize__SWIG_1(swigCPtr, this);
- }
-
public boolean setPriority(SWIGTYPE_p_switch_priority_t priority) {
- return freeswitchJNI.Event_setPriority__SWIG_0(swigCPtr, this, SWIGTYPE_p_switch_priority_t.getCPtr(priority));
+ return freeswitchJNI.Event_setPriority(swigCPtr, this, SWIGTYPE_p_switch_priority_t.getCPtr(priority));
}
- public boolean setPriority() {
- return freeswitchJNI.Event_setPriority__SWIG_1(swigCPtr, this);
- }
-
public String getHeader(String header_name) {
return freeswitchJNI.Event_getHeader(swigCPtr, this, header_name);
}
Modified: freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/EventConsumer.java 2010-05-10 18:07:34 UTC (rev 17516)
@@ -50,15 +50,6 @@
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,21 +75,16 @@
}
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);
+ long cPtr = freeswitchJNI.EventConsumer_pop(swigCPtr, this, block);
return (cPtr == 0) ? null : new Event(cPtr, true);
}
- public Event pop() {
- long cPtr = freeswitchJNI.EventConsumer_pop__SWIG_1(swigCPtr, this);
- return (cPtr == 0) ? null : new Event(cPtr, true);
- }
-
}
Modified: freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/src/org/freeswitch/swig/freeswitchJNI.java 2010-05-10 18:07:34 UTC (rev 17516)
@@ -17,8 +17,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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_);
Modified: freeswitch/trunk/src/mod/languages/mod_java/switch_swig_wrap.cpp (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_java/switch_swig_wrap.cpp 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_java/switch_swig_wrap.cpp 2010-05-10 18:07:34 UTC (rev 17516)
@@ -421,11 +421,11 @@
}
-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_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_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_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 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_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_new_1Event_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
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) {
- 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_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 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_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_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 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 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_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,33 +1402,47 @@
}
-SWIGEXPORT jlong JNICALL Java_org_freeswitch_swig_freeswitchJNI_EventConsumer_1pop_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
- jlong jresult = 0 ;
+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 ;
- int arg2 ;
- Event *result = 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) "" ;
+ int result;
(void)jenv;
(void)jcls;
(void)jarg1_;
arg1 = *(EventConsumer **)&jarg1;
- arg2 = (int)jarg2;
- result = (Event *)(arg1)->pop(arg2);
- *(Event **)&jresult = result;
+ 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_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
+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) 0 ;
Event *result = 0 ;
(void)jenv;
(void)jcls;
(void)jarg1_;
arg1 = *(EventConsumer **)&jarg1;
- result = (Event *)(arg1)->pop();
+ arg2 = (int)jarg2;
+ result = (Event *)(arg1)->pop(arg2);
*(Event **)&jresult = result;
return jresult;
}
@@ -1961,9 +1828,9 @@
}
-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_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 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,12 +2014,11 @@
}
-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 ;
+ char *arg3 = (char *) "" ;
+ char *arg4 = (char *) NULL ;
(void)jenv;
(void)jcls;
@@ -2184,44 +2039,6 @@
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 ;
-
- (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 ;
- }
(arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
@@ -2229,49 +2046,6 @@
}
-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 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_1recordFile_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
+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 ;
- 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) {
- 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_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 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_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_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 @@
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_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_1streamFile_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
+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 ;
- 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) {
- 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_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_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_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 ;
Modified: freeswitch/trunk/src/mod/languages/mod_lua/mod_lua_wrap.cpp (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_lua/mod_lua_wrap.cpp 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_lua/mod_lua_wrap.cpp 2010-05-10 18:07:34 UTC (rev 17516)
@@ -1499,20 +1499,19 @@
#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 @@
}
-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 @@
}
-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 @@
}
-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 @@
}
-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 @@
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++;
@@ -2876,40 +2733,21 @@
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 @@
}
-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 @@
};
argc = lua_gettop(L);
- if (argc == 1) {
+ if ((argc >= 1) && (argc <= 2)) {
int _v;
{
void *ptr;
@@ -2966,43 +2779,26 @@
}
}
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 @@
}
-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 @@
}
-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 @@
}
-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 @@
}
-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 @@
}
-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 @@
}
-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,24 +3470,29 @@
}
-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 ;
- Event *result = 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) "" ;
+ int result;
- SWIG_check_num_args("pop",2,2)
- if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pop",1,"EventConsumer *");
- if(!lua_isnumber(L,2)) SWIG_fail_arg("pop",2,"int");
+ 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_pop",1,SWIGTYPE_p_EventConsumer);
+ SWIG_fail_ptr("EventConsumer_bind",1,SWIGTYPE_p_EventConsumer);
}
- arg2 = (int)lua_tonumber(L, 2);
- result = (Event *)(arg1)->pop(arg2);
+ 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;
- SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++;
+ lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
if(0) SWIG_fail;
@@ -3957,19 +3503,24 @@
}
-static int _wrap_EventConsumer_pop__SWIG_1(lua_State* L) {
+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",1,1)
+ SWIG_check_num_args("pop",1,2)
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pop",1,"EventConsumer *");
+ 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);
}
- result = (Event *)(arg1)->pop();
+ 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++;
return SWIG_arg;
@@ -3982,64 +3533,18 @@
}
-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 @@
}
-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 @@
}
-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 @@
}
-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 @@
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,206 +4451,31 @@
}
-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);
- (arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
- SWIG_arg=0;
-
- return SWIG_arg;
-
- if(0) SWIG_fail;
-
-fail:
- lua_error(L);
- return SWIG_arg;
-}
-
-
-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);
+ if(lua_gettop(L)>=3){
+ arg3 = (char *)lua_tostring(L, 3);
}
-
- 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);
+ if(lua_gettop(L)>=4){
+ arg4 = (char *)lua_tostring(L, 4);
}
-
- arg2 = (char *)lua_tostring(L, 2);
- (arg1)->sayPhrase((char const *)arg2);
+ (arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
SWIG_arg=0;
return SWIG_arg;
@@ -5224,91 +4488,6 @@
}
-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,124 +4538,37 @@
}
-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);
- result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
- 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_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);
+ if(lua_gettop(L)>=3){
+ arg3 = (int)lua_tonumber(L, 3);
}
-
- 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);
+ if(lua_gettop(L)>=4){
+ arg4 = (int)lua_tonumber(L, 4);
}
-
- 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);
+ if(lua_gettop(L)>=5){
+ arg5 = (int)lua_tonumber(L, 5);
}
-
- arg2 = (char *)lua_tostring(L, 2);
- result = (int)(arg1)->recordFile(arg2);
+ result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
SWIG_arg=0;
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
@@ -5489,140 +4581,21 @@
}
-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 @@
}
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 @@
}
-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,87 +5002,32 @@
}
-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);
- result = (int)(arg1)->transfer(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_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);
+ if(lua_gettop(L)>=3){
+ arg3 = (char *)lua_tostring(L, 3);
}
-
- 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);
+ if(lua_gettop(L)>=4){
+ arg4 = (char *)lua_tostring(L, 4);
}
-
- arg2 = (char *)lua_tostring(L, 2);
- result = (int)(arg1)->transfer(arg2);
+ result = (int)(arg1)->transfer(arg2,arg3,arg4);
SWIG_arg=0;
lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
return SWIG_arg;
@@ -6313,91 +5040,6 @@
}
-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 @@
}
-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 @@
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 @@
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 @@
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 @@
}
-static int _wrap_CoreSession_playAndGetDigits__SWIG_1(lua_State* L) {
+static int _wrap_CoreSession_streamFile(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) {
- 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 @@
}
-static int _wrap_CoreSession_streamFile__SWIG_1(lua_State* L) {
+static int _wrap_CoreSession_sleep(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) {
- 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 @@
}
-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 @@
}
-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 @@
}
-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_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 @@
&_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_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 @@
_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,
Modified: freeswitch/trunk/src/mod/languages/mod_managed/freeswitch_wrap.cxx (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_managed/freeswitch_wrap.cxx 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_managed/freeswitch_wrap.cxx 2010-05-10 18:07:34 UTC (rev 17516)
@@ -7975,6 +7975,18 @@
}
+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 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 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 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 ;
Modified: freeswitch/trunk/src/mod/languages/mod_managed/managed/swig.cs (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_managed/managed/swig.cs 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_managed/managed/swig.cs 2010-05-10 18:07:34 UTC (rev 17516)
@@ -554,17 +554,6 @@
}
}
- 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 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 @@
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 @@
[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 @@
[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 @@
[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 @@
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;
Modified: freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_perl/freeswitch.pm 2010-05-10 18:07:34 UTC (rev 17516)
@@ -324,8 +324,6 @@
*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 @@
}
}
+*bind = *freeswitchc::EventConsumer_bind;
*pop = *freeswitchc::EventConsumer_pop;
sub DISOWN {
my $self = shift;
Modified: freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_perl/mod_perl_wrap.cpp 2010-05-10 18:07:34 UTC (rev 17516)
@@ -1462,20 +1462,19 @@
#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_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 @@
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 @@
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_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_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 @@
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 @@
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_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_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 @@
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 @@
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;
@@ -3645,37 +3424,8 @@
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 @@
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 @@
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_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 @@
_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 @@
}
check_1:
- if (items == 1) {
+ if ((items >= 1) && (items <= 2)) {
SWIG_TypeRank _ranki = 0;
SWIG_TypeRank _rankm = 0;
SWIG_TypeRank _pi = 1;
@@ -3778,81 +3514,28 @@
_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 == 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;
- {
+ if (items > 1) {
{
- int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ 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 (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
+ _rank = _ranki; _index = 2;
if (_rank == _rankm) goto dispatch;
}
}
- check_3:
+ check_2:
- 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_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 @@
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 @@
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_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 @@
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 @@
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_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_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_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 @@
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_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,144 +4333,98 @@
}
-XS(_wrap_EventConsumer_pop__SWIG_0) {
+XS(_wrap_EventConsumer_bind) {
{
EventConsumer *arg1 = (EventConsumer *) 0 ;
- int arg2 ;
- Event *result = 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) "" ;
+ int result;
void *argp1 = 0 ;
int res1 = 0 ;
- int val2 ;
- int ecode2 = 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 > 2)) {
- SWIG_croak("Usage: EventConsumer_pop(self,block);");
+ 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_pop" "', argument " "1"" of type '" "EventConsumer *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_bind" "', 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);
- result = (Event *)(arg1)->pop(arg2);
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ 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__SWIG_1) {
+XS(_wrap_EventConsumer_pop) {
{
EventConsumer *arg1 = (EventConsumer *) 0 ;
+ int arg2 = (int) 0 ;
Event *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: EventConsumer_pop(self);");
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: EventConsumer_pop(self,block);");
}
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();
+ 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++ ;
+
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_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 @@
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 @@
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_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_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 @@
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 @@
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,13 +5558,12 @@
}
-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 ;
+ char *arg3 = (char *) "" ;
+ char *arg4 = (char *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
@@ -6384,214 +5575,10 @@
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 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int res4 ;
- char *buf4 = 0 ;
- int alloc4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
+ 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 @@
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_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_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 @@
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,394 +5713,53 @@
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);
- result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
- 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_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);");
+ 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);
}
- 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 *""'");
+ 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);
}
- 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 *""'");
+ 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);
}
- 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);
+ result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
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;
-
+XS(_wrap_CoreSession_originate) {
{
- 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) {
- {
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 @@
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 @@
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);
}
- arg5 = reinterpret_cast< switch_state_handler_table_t * >(argp5);
+ 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);
+ }
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_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_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 @@
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 @@
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_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_playAndGetDigits__SWIG_0) {
+XS(_wrap_CoreSession_playAndGetDigits) {
{
CoreSession *arg1 = (CoreSession *) 0 ;
int arg2 ;
@@ -8634,7 +6577,7 @@
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 @@
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 @@
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_1) {
+XS(_wrap_CoreSession_streamFile) {
{
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) {
- {
- 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 @@
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 @@
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_1) {
+XS(_wrap_CoreSession_sleep) {
{
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) {
- {
- CoreSession *arg1 = (CoreSession *) 0 ;
int arg2 ;
- int arg3 ;
+ int arg3 = (int) 0 ;
int result;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -9263,7 +6757,7 @@
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 @@
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_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_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 @@
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 @@
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_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_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 @@
&_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_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 @@
_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 @@
{"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 @@
{"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 @@
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);
Modified: freeswitch/trunk/src/mod/languages/mod_python/freeswitch.py (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_python/freeswitch.py 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_python/freeswitch.py 2010-05-10 18:07:34 UTC (rev 17516)
@@ -198,9 +198,6 @@
__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 @@
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)
Modified: freeswitch/trunk/src/mod/languages/mod_python/mod_python_wrap.cpp (17515 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_python/mod_python_wrap.cpp 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/mod/languages/mod_python/mod_python_wrap.cpp 2010-05-10 18:07:34 UTC (rev 17516)
@@ -2510,20 +2510,19 @@
#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 @@
}
-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 @@
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 @@
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 @@
}
-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 @@
}
-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 @@
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 @@
}
-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 @@
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 @@
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;
@@ -4472,33 +4327,8 @@
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 @@
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 @@
}
-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 @@
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- if (argc == 1) {
+ 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) {
- 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) {
- 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 @@
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 @@
}
-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 @@
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 @@
}
-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 @@
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 @@
}
-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 @@
}
-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 @@
}
-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 @@
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 @@
}
-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,56 +5091,80 @@
}
-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 ;
- Event *result = 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) "" ;
+ int result;
void *argp1 = 0 ;
int res1 = 0 ;
- int val2 ;
- int ecode2 = 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:EventConsumer_pop",&obj0,&obj1)) SWIG_fail;
+ 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_pop" "', argument " "1"" of type '" "EventConsumer *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventConsumer_bind" "', 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;
- result = (Event *)(arg1)->pop(arg2);
- Py_END_ALLOW_THREADS;
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN | 0 );
+ 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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+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 ;
+ int val2 ;
+ int ecode2 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:EventConsumer_pop",&obj0)) 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);
- Py_BEGIN_ALLOW_THREADS;
- result = (Event *)(arg1)->pop();
- Py_END_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);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
@@ -5589,50 +5172,6 @@
}
-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 @@
}
-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 @@
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 @@
}
-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 @@
}
-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 @@
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 @@
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,13 +6141,12 @@
}
-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 ;
+ char *arg3 = (char *) "" ;
+ char *arg4 = (char *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
@@ -6679,174 +6158,36 @@
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;
+ 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_say" "', argument " "1"" of type '" "CoreSession *""'");
+ 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_say" "', argument " "2"" of type '" "char const *""'");
+ 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_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 (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);
}
- 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);
- }
- }
- }
- }
- }
+ 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);
}
-
-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 ;
- 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 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"OOOO: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 *""'");
- }
- 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);
- 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);
(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 @@
}
-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 @@
}
-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 @@
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,117 +6282,28 @@
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);
- result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
- 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_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 *""'");
+ 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);
}
- 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 *""'");
+ 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);
}
- 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 *""'");
+ 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);
}
- 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);
+ result = (int)(arg1)->recordFile(arg2,arg3,arg4,arg5);
resultobj = SWIG_From_int(static_cast< int >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
@@ -7211,157 +6313,13 @@
}
-SWIGINTERN PyObject *_wrap_CoreSession_recordFile__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_originate(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) {
- 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 @@
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 @@
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);
}
- arg5 = reinterpret_cast< switch_state_handler_table_t * >(argp5);
+ 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);
+ }
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 @@
}
-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 @@
}
-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 @@
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 @@
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 @@
}
-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 @@
}
-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 @@
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 @@
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 @@
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 @@
}
-SWIGINTERN PyObject *_wrap_CoreSession_playAndGetDigits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_streamFile(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) {
- 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 @@
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 @@
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 @@
}
-SWIGINTERN PyObject *_wrap_CoreSession_streamFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CoreSession_sleep(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) {
- 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 @@
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 @@
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 @@
}
-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 @@
}
-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 @@
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 @@
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 @@
}
-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 @@
{ (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 @@
{ (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_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 @@
&_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_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 @@
_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,
Added: freeswitch/trunk/src/mod/languages/mod_python/mod_python_wrap.cpp.rej (0 => 17516)
--- freeswitch/trunk/src/mod/languages/mod_python/mod_python_wrap.cpp.rej (rev 0)
+++ freeswitch/trunk/src/mod/languages/mod_python/mod_python_wrap.cpp.rej 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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:
Added: freeswitch/trunk/src/switch_core.c.orig (0 => 17516)
--- freeswitch/trunk/src/switch_core.c.orig (rev 0)
+++ freeswitch/trunk/src/switch_core.c.orig 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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:
+ */
Modified: freeswitch/trunk/src/switch_cpp.cpp (17515 => 17516)
--- freeswitch/trunk/src/switch_cpp.cpp 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/switch_cpp.cpp 2010-05-10 18:07:34 UTC (rev 17516)
@@ -52,23 +52,33 @@
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);
+
+ switch_core_new_memory_pool(&pool);
+ switch_queue_create(&events, 5000, pool);
- if (!zstr(subclass_name)) {
- e_subclass_name = switch_core_strdup(pool, subclass_name);
- } else {
- e_subclass_name = NULL;
+ if (!zstr(event_name)) {
+ bind(event_name, subclass_name);
}
- switch_queue_create(&events, 5000, pool);
+}
+
+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_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));
+ 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(e_subclass_name));
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot bind to %s %s\n", event_name, switch_str_nil(subclass_name));
+ return 0;
}
-
}
@@ -93,10 +103,9 @@
SWITCH_DECLARE_CONSTRUCTOR EventConsumer::~EventConsumer()
{
- if (node) {
- switch_event_unbind(&node);
- }
+ switch_event_unbind_callback(event_handler);
+
if (events) {
switch_queue_interrupt_all(events);
}
Modified: freeswitch/trunk/src/switch_event.c (17515 => 17516)
--- freeswitch/trunk/src/switch_event.c 2010-05-10 17:03:22 UTC (rev 17515)
+++ freeswitch/trunk/src/switch_event.c 2010-05-10 18:07:34 UTC (rev 17516)
@@ -1198,7 +1198,7 @@
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);
Added: freeswitch/trunk/src/switch_time.c.orig (0 => 17516)
--- freeswitch/trunk/src/switch_time.c.orig (rev 0)
+++ freeswitch/trunk/src/switch_time.c.orig 2010-05-10 18:07:34 UTC (rev 17516)
@@ -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:
+ */