[Freeswitch-trunk] [commit] r3784 - freeswitch/trunk/src/mod/applications/mod_conference

Freeswitch SVN mikej at freeswitch.org
Thu Dec 21 15:27:52 EST 2006


Author: mikej
Date: Thu Dec 21 15:27:51 2006
New Revision: 3784

Modified:
   freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c

Log:
add knhor changes

Modified: freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c	(original)
+++ freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c	Thu Dec 21 15:27:51 2006
@@ -9,7 +9,7 @@
  * 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,
+ * 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.
@@ -48,14 +48,14 @@
 #define CONF_CHAT_PROTO "conf"
 
 #ifndef MIN
-#define MIN(a,b) ((a)<(b)?(a):(b))
+#define MIN(a, b) ((a)<(b)?(a):(b))
 #endif
 
 /* this doesn't work correctly yet, don't bother trying! */
 //#define OPTION_IVR_MENU_SUPPORT */
 
 typedef enum {
-	FILE_STOP_CURRENT,
+	FILE_STOP_CURRENT, 
 	FILE_STOP_ALL
 } file_stop_t;
 
@@ -72,20 +72,20 @@
 } globals;
 
 typedef enum {
-	CALLER_CONTROL_MUTE,
-	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_MUTE, 
+	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_t;
 
 /* forward declaration for conference_obj and caller_control */
@@ -110,30 +110,30 @@
 } 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_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)
 } 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_RUNNING = (1 << 0), 
+	CFLAG_DYNAMIC = (1 << 1), 
+	CFLAG_ENFORCE_MIN = (1 << 2), 
+	CFLAG_DESTRUCT = (1 << 3), 
+	CFLAG_LOCKED = (1 << 4), 
 	CFLAG_ANSWERED = (1 << 5)
 } conf_flag_t;
 
 typedef enum {
-	RFLAG_CAN_SPEAK = (1 << 0),
+	RFLAG_CAN_SPEAK = (1 << 0), 
 	RFLAG_CAN_HEAR = (1 << 1)
 } relation_flag_t;
 
 typedef enum {
-	NODE_TYPE_FILE,
+	NODE_TYPE_FILE, 
 	NODE_TYPE_SPEECH
 } node_type_t;
 
@@ -147,6 +147,15 @@
 	struct conference_file_node *next;
 } conference_file_node_t;
 
+/* conference xml config sections */
+typedef struct conf_xml_cfg {
+	switch_xml_t profile;
+	switch_xml_t controls;
+#ifdef OPTION_IVR_MENU_SUPPORT
+	switch_xml_t menus;
+#endif
+} conf_xml_cfg_t;
+
 /* Conference Object */
 typedef struct conference_obj {
 	char *name;
@@ -223,6 +232,7 @@
 	switch_audio_resampler_t *read_resampler;
 	conference_file_node_t *fnode;
 	conference_relationship_t *relationships;
+	switch_ivr_digit_stream_t *digit_stream;
 	struct conference_member *next;
 };
 
@@ -233,57 +243,75 @@
 	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;
+
 /* API command parser */
 typedef struct api_command {
 	char *pname;
 	void *pfnapicmd;
-	int  fntype;
+	conference_fntype_t fntype;
 	char *psyntax;
 } api_command_t;
 
+
 /* Function Prototypes */
 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 void member_del_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 void conference_del_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 conference_loop(conference_member_t *member);
+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);
-static switch_status_t conference_say(conference_obj_t *conference, char *text, uint32_t leadin);
+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 switch_status_t conf_function(char *buf, switch_core_session_t *session, switch_stream_handle_t *stream);
+static switch_status_t conf_api_main(char *buf, switch_core_session_t *session, switch_stream_handle_t *stream);
 static switch_status_t audio_bridge_on_ring(switch_core_session_t *session);
-static switch_status_t conference_outcall(conference_obj_t *conference,
-										  switch_core_session_t *session,
-										  char *bridgeto,
-										  uint32_t timeout,
-										  char *flags,
-										  char *cid_name,
+static switch_status_t conference_outcall(conference_obj_t *conference, 
+										  switch_core_session_t *session, 
+										  char *bridgeto, 
+										  uint32_t timeout, 
+										  char *flags, 
+										  char *cid_name, 
 										  char *cid_num);
 static void conference_function(switch_core_session_t *session, char *data);
 static void launch_conference_thread(conference_obj_t *conference);
-static void *SWITCH_THREAD_FUNC input_thread_run(switch_thread_t *thread, void *obj);
-static void launch_input_thread(conference_member_t *member, switch_memory_pool_t *pool);
+static void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj);
 static switch_status_t conference_local_play_file(switch_core_session_t *session, char *path, uint32_t leadin, char *buf, switch_size_t len);
 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_obj_t *conference, conference_member_t *member, char *text, 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, switch_xml_t profile, switch_memory_pool_t *pool);
+static conference_obj_t *conference_new(char *name, conf_xml_cfg_t cfg, switch_memory_pool_t *pool);
 static switch_status_t chat_send(char *proto, char *from, char *to, char *subject, char *body, char *hint);
 static void launch_conference_record_thread(conference_obj_t *conference, char *path);
 
-typedef int (*conf_api_args_cmd_t)(conference_obj_t*, switch_stream_handle_t*, int, char**);
-typedef int (*conf_api_member_cmd_t)(conference_member_t*, switch_stream_handle_t*, void*);
-typedef int (*conf_api_text_cmd_t)(conference_obj_t*, switch_stream_handle_t*, char*);
+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,
-										int (*pfncallback)(conference_obj_t*, conference_member_t*, int, switch_stream_handle_t*, void*),
+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);
 
 /* Return a Distinct ID # */
 static uint32_t next_member_id(void)
@@ -300,31 +328,35 @@
 /* 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;
+	conference_relationship_t *rel = NULL;
 
-	switch_mutex_lock(member->flag_mutex);
-	switch_mutex_lock(other_member->flag_mutex);
+	if (member != NULL && other_member != NULL) {
+		conference_relationship_t *global = NULL;
 
-	if (member->relationships) {
-		for (rel = member->relationships; rel; rel = rel->next) {
-			if (rel->id == other_member->id) {
-				break;
-			}
+		switch_mutex_lock(member->flag_mutex);
+		switch_mutex_lock(other_member->flag_mutex);
 
-			/* 0 matches everyone.
-			   (We will still test the others brcause a real match carries more clout) */
+		if (member->relationships) {
+			for (rel = member->relationships; rel; rel = rel->next) {
+				if (rel->id == other_member->id) {
+					break;
+				}
 
-			if (rel->id == 0) { 
-				global = rel;
+				/* 0 matches everyone.
+				   (We will still test the others brcause a real match carries more clout) */
+
+				if (rel->id == 0) { 
+					global = rel;
+				}
 			}
 		}
-	}
 
-	switch_mutex_unlock(other_member->flag_mutex);
-	switch_mutex_unlock(member->flag_mutex);
+		switch_mutex_unlock(other_member->flag_mutex);
+		switch_mutex_unlock(member->flag_mutex);
 
-	if (!rel && global) {
-		rel = global;
+		if (!rel && global) {
+			rel = global;
+		}
 	}
 
 	return rel;
@@ -335,33 +367,39 @@
 {
 	conference_member_t *member = NULL;
 
-	for(member = conference->members; member; member = member->next) {
+    assert(conference != NULL);
+    assert(id != 0);
 
-		if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
-			continue;
-		}
+    for(member = conference->members; member; member = member->next) {
+        
+        if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
+            continue;
+        }
+        
+        if (member->id == id) {
+            break;
+        }
+    }
+	
 
-		if (member->id == id) {
-			break;
-		}
-	}
-
 	return member;
 }
 
 /* stop the specified recording */
-static int conference_record_stop(conference_obj_t *conference, char *path)
+static switch_status_t conference_record_stop(conference_obj_t *conference, char *path)
 {
 	conference_member_t *member = NULL;
 	int count = 0;
 
-	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++;
-		}
-	}
+	assert (conference != NULL);
 
+    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++;
+        }
+    }
+
 	return count;
 }
 
@@ -370,7 +408,7 @@
 {
 	conference_relationship_t *rel = NULL;
 
-	if ((rel = switch_core_alloc(member->pool, sizeof(*rel)))) {
+	if (member != NULL && id != 0 && (rel = switch_core_alloc(member->pool, sizeof(*rel)))) {
 		rel->id = id;
 
 		switch_mutex_lock(member->flag_mutex);
@@ -383,114 +421,133 @@
 }
 
 /* Remove a custom relationship from a member */
-static void member_del_relationship(conference_member_t *member, uint32_t id)
+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;
 
-	switch_mutex_lock(member->flag_mutex);
-	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 */
-			if (last) {
-				last->next = rel->next;
-			} else {
-				member->relationships = rel->next;
+	if (member != NULL && id != 0) {
+		switch_mutex_lock(member->flag_mutex);
+		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;
+				}
 			}
+			last = rel;
 		}
-		last = rel;
+		switch_mutex_unlock(member->flag_mutex);
 	}
-	switch_mutex_unlock(member->flag_mutex);
+
+	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_event_t *event;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+    switch_event_t *event;
 
-	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);
-	switch_mutex_lock(member->flag_mutex);
-	member->conference = member->last_conference = conference;
-	member->next = conference->members;
-	member->energy_level = conference->energy_level;
-	conference->members = member;
+    assert(conference != NULL);
+    assert(member != NULL);
 
+    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);
+    switch_mutex_lock(member->flag_mutex);
+    member->conference = member->last_conference = conference;
+    member->next = conference->members;
+    member->energy_level = conference->energy_level;
+    conference->members = member;
 
-	if (!switch_test_flag(member, MFLAG_NOCHANNEL)) {
-		conference->count++;
-		if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", 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(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
-			switch_event_fire(&event);
-		}
 
+    if (!switch_test_flag(member, MFLAG_NOCHANNEL)) {
+        conference->count++;
+        if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", 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(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+            switch_event_fire(&event);
+        }
 
-		if (conference->enter_sound) {
-			conference_play_file(conference, conference->enter_sound, CONF_DEFAULT_LEADIN, switch_core_session_get_channel(member->session));
-		}
 
-		if (conference->count == 1 && conference->alone_sound) {
-			conference_play_file(conference, conference->alone_sound, 0, switch_core_session_get_channel(member->session));
-		}
+        if (conference->enter_sound) {
+            conference_play_file(conference, conference->enter_sound, CONF_DEFAULT_LEADIN, switch_core_session_get_channel(member->session));
+        }
 
-		if (conference->min && conference->count >= conference->min) {
-			switch_set_flag(conference, CFLAG_ENFORCE_MIN);	
-		}
+        if (conference->count == 1 && conference->alone_sound) {
+            conference_play_file(conference, conference->alone_sound, 0, switch_core_session_get_channel(member->session));
+        }
 
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        if (conference->min && conference->count >= conference->min) {
+            switch_set_flag(conference, CFLAG_ENFORCE_MIN);	
+        }
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "add-member");
-			switch_event_fire(&event);
-		}
-	}
-	switch_mutex_unlock(member->flag_mutex);
-	switch_mutex_unlock(member->audio_out_mutex);
-	switch_mutex_unlock(member->audio_in_mutex);
-	switch_mutex_unlock(conference->member_mutex);
-	switch_mutex_unlock(conference->mutex);
+        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
 
-	return SWITCH_STATUS_SUCCESS;
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "add-member");
+            switch_event_fire(&event);
+        }
+    }
+    switch_mutex_unlock(member->flag_mutex);
+    switch_mutex_unlock(member->audio_out_mutex);
+    switch_mutex_unlock(member->audio_in_mutex);
+    switch_mutex_unlock(conference->member_mutex);
+    switch_mutex_unlock(conference->mutex);
+    status = SWITCH_STATUS_SUCCESS;
+	
+
+	return status;
 }
 
 /* Gain exclusive access and remove the member from the list */
-static void conference_del_member(conference_obj_t *conference, conference_member_t *member)
+static switch_status_t conference_del_member(conference_obj_t *conference, conference_member_t *member)
 {
-	conference_member_t *imember, *last = NULL;
-	switch_event_t *event;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+    conference_member_t *imember, *last = NULL;
+    switch_event_t *event;
 
-	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);
-	switch_mutex_lock(member->flag_mutex);
+    assert(conference != NULL);
+    assert(member != NULL);
+    
 
-	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;
-	}
 
 
-    if (member->fnode) { /* Close Unused Handles */
+    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);
+    switch_mutex_lock(member->flag_mutex);
+
+    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;
@@ -502,55 +559,57 @@
             } else {
                 switch_core_file_close(&cur->fh);
             }
-            
+
             pool = cur->pool;
             switch_core_destroy_memory_pool(&pool);
         }
-
-        member->fnode = NULL;
     }
 
-	member->conference = NULL;
+    member->conference = NULL;
 
-	if (!switch_test_flag(member, MFLAG_NOCHANNEL)) {
-		conference->count--;
-		if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", 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(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
-			switch_event_fire(&event);
-		}
+    if (!switch_test_flag(member, MFLAG_NOCHANNEL)) {
+        conference->count--;
+        if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", 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(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
+            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));
-			}
-			if (conference->count == 1 && conference->alone_sound) {
-				conference_play_file(conference, conference->alone_sound, 0, switch_core_session_get_channel(member->session));
-			} 
-		}
+        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));
+            }
+            if (conference->count == 1 && conference->alone_sound) {
+                conference_play_file(conference, conference->alone_sound, 0, switch_core_session_get_channel(member->session));
+            } 
+        }
 
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "del-member");
-			switch_event_fire(&event);
-		}
-	}
-	switch_mutex_unlock(member->flag_mutex);
-	switch_mutex_unlock(member->audio_out_mutex);
-	switch_mutex_unlock(member->audio_in_mutex);
-	switch_mutex_unlock(conference->member_mutex);
-	switch_mutex_unlock(conference->mutex);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "del-member");
+            switch_event_fire(&event);
+        }
+    }
 
+    switch_mutex_unlock(member->flag_mutex);
+    switch_mutex_unlock(member->audio_out_mutex);
+    switch_mutex_unlock(member->audio_in_mutex);
+    switch_mutex_unlock(conference->member_mutex);
+    switch_mutex_unlock(conference->mutex);
+    status = SWITCH_STATUS_SUCCESS;
+	
+
+	return status;
 }
 
 /* Main monitor thread (1 per distinct conference room) */
@@ -609,9 +668,9 @@
 					int len = (int) imember->read;
 
 					imember->mux_resampler->from_len = switch_short_to_float(bptr, imember->mux_resampler->from, (int) len / 2);
-					imember->mux_resampler->to_len = switch_resample_process(imember->mux_resampler, imember->mux_resampler->from,
-																		 imember->mux_resampler->from_len, imember->mux_resampler->to,
-																		 imember->mux_resampler->to_size, 0);
+					imember->mux_resampler->to_len = switch_resample_process(imember->mux_resampler, imember->mux_resampler->from, 
+                                                                             imember->mux_resampler->from_len, imember->mux_resampler->to, 
+                                                                             imember->mux_resampler->to_size, 0);
 					switch_float_to_short(imember->mux_resampler->to, out, len);
 					len = imember->mux_resampler->to_len * 2;
 					switch_buffer_write(imember->resample_buffer, out, len);
@@ -637,10 +696,10 @@
 					switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_BLOCKING;
 					uint32_t rate = conference->rate;
 
-					if (switch_core_speech_read_tts(&conference->fnode->sh,
-													file_frame,
-													&file_data_len,
-													&rate,
+					if (switch_core_speech_read_tts(&conference->fnode->sh, 
+													file_frame, 
+													&file_data_len, 
+													&rate, 
 													&flags) == SWITCH_STATUS_SUCCESS) {
 						file_sample_len = file_data_len / 2;
 					} else {
@@ -748,8 +807,6 @@
 		switch_mutex_unlock(conference->mutex);
 	} /* Rinse ... Repeat */
 
-
-
 	if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
 		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", conference->name);
@@ -761,34 +818,34 @@
 		switch_event_fire(&event);
 	}
 
-    
 	switch_core_timer_destroy(&timer);
     
 	if (switch_test_flag(conference, CFLAG_DESTRUCT)) {
 
 		switch_mutex_lock(conference->mutex);
 
-		if (conference->fnode) { /* Close Unused Handles */
-			conference_file_node_t *fnode, *cur;
-			switch_memory_pool_t *pool;
+		/* 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;
+			fnode = conference->fnode; 
+			while (fnode) { 
+				cur = fnode; 
+				fnode = fnode->next; 
 
-                if (cur->type == NODE_TYPE_SPEECH) {
-                    switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
-                    switch_core_speech_close(&cur->sh, &flags);
-                } else {
-                    switch_core_file_close(&cur->fh);
-                }
+				if (cur->type == NODE_TYPE_SPEECH) { 
+					switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE; 
+					switch_core_speech_close(&cur->sh, &flags); 
+				} else { 
+					switch_core_file_close(&cur->fh); 
+				} 
 
-                pool = cur->pool;
-                switch_core_destroy_memory_pool(&pool);
-            }
-            conference->fnode = NULL;
-		}
+				pool = cur->pool; 
+				switch_core_destroy_memory_pool(&pool); 
+			} 
+			conference->fnode = NULL; 
+		} 
 
 		for(imember = conference->members; imember; imember = imember->next) {
 			switch_channel_t *channel;
@@ -822,7 +879,9 @@
 		switch_thread_rwlock_unlock(conference->rwlock);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Lock OFF\n");
 
-        if (conference->pool) {
+		switch_ivr_digit_stream_parser_destroy(conference->dtmf_parser);
+
+		if (conference->pool) {
 			switch_memory_pool_t *pool = conference->pool;
 			switch_core_destroy_memory_pool(&pool);
 		}
@@ -835,10 +894,502 @@
 	return NULL;
 }
 
-/* Sub-Routine called by a channel inside a conference */
-static void conference_loop(conference_member_t *member)
+static void conference_loop_fn_mute_toggle(conference_member_t *member, void *data)
 {
+	if (member != NULL) {
+		if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+			conf_api_sub_mute(member, NULL, NULL);
+		} else {
+			conf_api_sub_unmute(member, NULL, NULL);
+		}
+	}
+}
+
+static void conference_loop_fn_deafmute_toggle(conference_member_t *member, void *data)
+{
+	if (member != NULL) {
+		if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+			conf_api_sub_mute(member, NULL, NULL);
+			conf_api_sub_deaf(member, NULL, NULL);
+		} else {
+			conf_api_sub_unmute(member, NULL, NULL);
+			conf_api_sub_undeaf(member, NULL, NULL);
+		}
+	}
+}
+
+static void conference_loop_fn_energy_up(conference_member_t *member, void *data)
+{
+	if (member != NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->energy_level += 200;
+		if (member->energy_level > 3000) {
+			member->energy_level = 3000;
+		}
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_energy_equ_conf(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->energy_level = member->conference->energy_level;
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+					
+static void conference_loop_fn_energy_dn(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->energy_level -= 100;
+		if (member->energy_level < 0) {
+			member->energy_level = 0;
+		}
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_volume_talk_up(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->volume_out_level++;
+		switch_normalize_volume(member->volume_out_level);
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_volume_talk_zero(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->volume_out_level = 0;
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_volume_talk_dn(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->volume_out_level--;
+		switch_normalize_volume(member->volume_out_level);
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_volume_listen_up(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->volume_in_level++;
+		switch_normalize_volume(member->volume_in_level);
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_volume_listen_zero(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->volume_in_level = 0;
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_volume_listen_dn(conference_member_t *member, void *data)
+{
+	if (member!= NULL) {
+		char msg[512];
+		switch_event_t *event;
+
+		switch_mutex_lock(member->flag_mutex);
+		member->volume_in_level--;
+		switch_normalize_volume(member->volume_in_level);
+		switch_mutex_unlock(member->flag_mutex);
+
+		snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
+		conference_member_say(member, msg, 0);
+
+		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+			switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+			switch_channel_event_set_data(channel, event);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+			switch_event_add_header(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);
+		}
+	}
+}
+
+static void conference_loop_fn_hangup(conference_member_t *member, void *data)
+{
+	switch_clear_flag_locked(member, MFLAG_RUNNING);
+}
+
+#ifdef OPTION_IVR_MENU_SUPPORT
+typedef struct caller_control_menu_ctx {
+	switch_ivr_menu_xml_ctx_t *xml_ctx;
+	switch_ivr_menu_t *menu_stack;
+	char *name;
+} caller_control_menu_ctx_t;
+
+static void conference_loop_fn_menu(conference_member_t *member, void *data)
+{
+	if (member != NULL && data != NULL) {
+		caller_control_menu_ctx_t *menu_ctx = (caller_control_menu_ctx_t *)data;
+
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "conference_loop_fn_menu handler '%s'\n", menu_ctx->name);
+		if (menu_ctx->menu_stack != NULL && menu_ctx->xml_ctx != NULL) {
+			switch_ivr_menu_execute(member->session, menu_ctx->menu_stack, menu_ctx->name, member);
+		} else {
+			if (menu_ctx->menu_stack == NULL)
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "conference_loop_fn_menu handler NULL menu_stack\n");
+			if (menu_ctx->xml_ctx == NULL)
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "conference_loop_fn_menu handler NULL xml_ctx\n");
+		}
+	}
+}
+#endif
+
+static void conference_loop_fn_dial(conference_member_t *member, void *data)
+{
+	if (member != NULL && data != NULL) {
+		char *lbuf = strdup(data);
+		char *argv[4];
+		int argc = 0;
+
+		if (lbuf != NULL) {
+			memset(argv, 0, sizeof(argv));
+			argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "dial argc %u 1 '%s' 2 '%s' 3 '%s' 4 '%s'\n", 
+                              argc, argv[0], argv[1], argv[2], argv[3]);
+			if (argc >= 4) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "executing conference outcall\n");
+				conference_outcall(member->conference, NULL, argv[0], atoi(argv[1]), NULL, argv[3], argv[2]);
+			} else {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "conference outcall not executed\n");
+			}
+
+			free(lbuf);
+		}
+	}
+}
+
+
+/* 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;
+	switch_codec_t *read_codec;
+	uint32_t hangover = 40, 
+		hangunder = 15, 
+		hangover_hits = 0, 
+		hangunder_hits = 0, 
+		energy_level = 0, 
+		diff_level = 400;
+	uint8_t talking = 0;
+
+	assert(member != NULL);
+
+	channel = switch_core_session_get_channel(member->session);
+	assert(channel != NULL);
+
+	read_codec = switch_core_session_get_read_codec(member->session);
+	assert(read_codec != NULL);
+
+	/* 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)) {
+		/* Read a frame. */
+		status = switch_core_session_read_frame(member->session, &read_frame, -1, 0);
+
+		/* end the loop, if appropriate */
+		if (!SWITCH_READ_ACCEPTABLE(status) || !switch_test_flag(member, MFLAG_RUNNING)) {
+			break;
+		}
+
+		if (switch_test_flag(read_frame, SFF_CNG)) {
+			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) && energy_level) {
+			uint32_t energy = 0, i = 0, samples = 0, j = 0, score = 0;
+			int16_t *data;
+
+			data = read_frame->data;
+			if ((samples = read_frame->datalen / sizeof(*data))) {
+
+				for (i = 0; i < samples; i++) {
+					energy += abs(data[j]);
+					j += read_codec->implementation->number_of_channels;
+				}
+				score = energy / samples;
+			}
+
+			if (score > energy_level) {
+				uint32_t diff = score - energy_level;
+				if (hangover_hits) {
+					hangover_hits--;
+				}
+
+				if (diff >= diff_level || ++hangunder_hits >= hangunder) {
+					hangover_hits = hangunder_hits = 0;
+
+					if (!talking) {
+						switch_event_t *event;
+						talking = 1;		
+						if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+							switch_channel_event_set_data(channel, event);
+							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "start-talking");
+							switch_event_fire(&event);
+						}
+					}
+				} 
+			} else {
+				if (hangunder_hits) {
+					hangunder_hits--;
+				}
+				if (talking) {
+					switch_event_t *event;
+					if (++hangover_hits >= hangover) {
+						hangover_hits = hangunder_hits = 0;
+						talking = 0;
+
+						if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+							switch_channel_event_set_data(channel, event);
+							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+							switch_event_add_header(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 ((talking || energy_level == 0) && switch_test_flag(member, MFLAG_CAN_SPEAK)) {
+			if (member->read_resampler) {
+				int16_t *bptr = (int16_t *) read_frame->data;
+				int len = (int) read_frame->datalen;;
+
+				member->read_resampler->from_len = switch_short_to_float(bptr, member->read_resampler->from, (int) len / 2);
+				member->read_resampler->to_len = switch_resample_process(member->read_resampler, member->read_resampler->from, 
+																		 member->read_resampler->from_len, member->read_resampler->to, 
+																		 member->read_resampler->to_size, 0);
+				switch_float_to_short(member->read_resampler->to, read_frame->data, len);
+				len = member->read_resampler->to_len * 2;
+				read_frame->datalen = len;
+				read_frame->samples = len / 2;
+			}
+			/* Check for input volume adjustments */
+			if (member->volume_in_level) {
+				switch_change_sln_volume(read_frame->data, read_frame->datalen / 2, member->volume_in_level);
+			}
+
+			/* Write the audio into the input buffer */
+			switch_mutex_lock(member->audio_in_mutex);
+			switch_buffer_write(member->audio_buffer, read_frame->data, read_frame->datalen);
+			switch_mutex_unlock(member->audio_in_mutex);
+		}
+	}
+
+	switch_clear_flag_locked(member, MFLAG_ITHREAD);
+
+	return NULL;
+}
+
+/* launch an input thread for the call leg */
+static void launch_conference_loop_input(conference_member_t *member, switch_memory_pool_t *pool)
+{
+	if (member != NULL) {
+		switch_thread_t *thread;
+		switch_threadattr_t *thd_attr = NULL;
+
+		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}, 
+	{"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}, 
+#ifdef OPTION_IVR_MENU_SUPPORT
+	{"menu", 		NULL, 	CALLER_CONTROL_MENU, 		conference_loop_fn_menu}, 
+#endif
+	{"dial", 		NULL, 	CALLER_CONTROL_DIAL, 		conference_loop_fn_dial}, 
+};
+#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[SWITCH_RECCOMMENDED_BUFFER_SIZE];
 	switch_timer_t timer = {0};
@@ -851,10 +1402,10 @@
 	assert(channel != NULL);
 	assert(member->conference != NULL);
 
-	if (switch_core_timer_init(&timer,
-							   member->conference->timer_name,
-							   member->conference->interval,
-							   samples,
+	if (switch_core_timer_init(&timer, 
+							   member->conference->timer_name, 
+							   member->conference->interval, 
+							   samples, 
 							   NULL) == SWITCH_STATUS_SUCCESS) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "setup timer %s success interval: %u  samples: %u\n", 
 						  member->conference->timer_name, member->conference->interval, samples);	
@@ -871,10 +1422,15 @@
 		switch_channel_answer(channel);
 	}
 
-	/* Start a thread to read data and feed it into the buffer and use this thread to generate output */
-	launch_input_thread(member, switch_core_session_get_pool(member->session));
+	/* Start the input thread */
+	launch_conference_loop_input(member, switch_core_session_get_pool(member->session));
 
-	/* Fair WARNING, If you expect the caller to hear anything or for digit handling to be proccessed,		*/
+	/* 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_LOG, SWITCH_LOG_ERROR, "Warning Will Robinson, there is no digit parser stream object\n");
+	}
+
+	/* Fair WARNING, If you expect the caller to hear anything or for digit handling to be proccessed, 		*/
 	/* 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] = "";
@@ -882,8 +1438,8 @@
 		switch_size_t file_data_len = samples * 2;
 		switch_size_t file_sample_len = samples;
 		char *digit;
-		char msg[512];
 		switch_event_t *event;
+		caller_control_action_t *caller_action = NULL;
 
 		if (switch_core_session_dequeue_event(member->session, &event) == SWITCH_STATUS_SUCCESS) {
 			char *from = switch_event_get_header(event, "from");
@@ -922,246 +1478,41 @@
 		if (switch_channel_has_dtmf(channel)) {
 			switch_channel_dequeue_dtmf(channel, dtmf, sizeof(dtmf));
 
-			for (digit = dtmf; *digit; digit++) {
-				switch(*digit) {
-				case '0':
-                    {
-                        char *action = "mute-member";
+			if (member->conference->dtmf_parser != NULL) {
 
-                        if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
-                            switch_clear_flag_locked(member, MFLAG_CAN_SPEAK | MFLAG_CAN_HEAR);
-                            if (member->conference->muted_sound) {
-                                conference_member_play_file(member, member->conference->muted_sound, 0);
-                            } else {
-                                snprintf(msg, sizeof(msg), "Muted");
-                                conference_member_say(member->conference, member, msg, 0);
-                            }
-                        } else {
-                            action = "unmute-member";
-                            switch_set_flag_locked(member, MFLAG_CAN_SPEAK);
-                            if (member->conference->unmuted_sound) {
-                                conference_member_play_file(member, member->conference->unmuted_sound, 0);
-                            } else {
-                                snprintf(msg, sizeof(msg), "Un-Muted");
-                                conference_member_say(member->conference, member, msg, 0);
-                            }
-                        }
-                        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                            switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                            switch_channel_event_set_data(channel, event);
-                            
-                            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", action);
-                            switch_event_fire(&event);
-                        }
-                    }
-                    break;
-				case '*': 
-                    {
-                        char *action = "mute-deaf-member";
-                        if (switch_test_flag(member, MFLAG_CAN_SPEAK)) {
-                            switch_clear_flag_locked(member, MFLAG_CAN_SPEAK|MFLAG_CAN_HEAR);
-                            if (member->conference->muted_sound) {
-                                conference_member_play_file(member, member->conference->muted_sound, 0);
-                            } else {
-                                snprintf(msg, sizeof(msg), "Muted");
-                                conference_member_say(member->conference, member, msg, 0);
-                            }
-                        } else {
-                            action = "unmute-deaf-member";
-                            switch_set_flag_locked(member, MFLAG_CAN_SPEAK|MFLAG_CAN_HEAR);
-                            if (member->conference->unmuted_sound) {
-                                conference_member_play_file(member, member->conference->unmuted_sound, 0);
-                            } else {
-                                snprintf(msg, sizeof(msg), "UN-Muted");
-                                conference_member_say(member->conference, member, msg, 0);
-                            }
-                        }
+				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 (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                            switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                            switch_channel_event_set_data(channel, event);
-                            
-                            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", action);
-                            switch_event_fire(&event);
-                        }
-                    }
+		/* if a caller action has been detected, handle it */
+		if (caller_action != NULL && caller_action->fndesc != NULL && caller_action->fndesc->handler != NULL) {
+			switch_channel_t *channel		 = switch_core_session_get_channel(member->session);
+			switch_caller_profile_t *profile	 = switch_channel_get_caller_profile(channel);
+            char *param = NULL;
 
-					break;
-				case '9':
-					switch_mutex_lock(member->flag_mutex);
-					member->energy_level += 200;
-					if (member->energy_level > 3000) {
-						member->energy_level = 3000;
-					}
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
-					conference_member_say(member->conference, member, msg, 0);
+            if (caller_action->fndesc->action != CALLER_CONTROL_MENU) {
+                param = caller_action->data;
+            }
 
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '8':
-					switch_mutex_lock(member->flag_mutex);
-					member->energy_level = member->conference->energy_level;
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '7':
-					switch_mutex_lock(member->flag_mutex);
-					member->energy_level -= 100;
-					if (member->energy_level < 0) {
-						member->energy_level = 0;
-					}
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '3':
-					switch_mutex_lock(member->flag_mutex);
-					member->volume_out_level++;
-					switch_normalize_volume(member->volume_out_level);
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '2':
-					switch_mutex_lock(member->flag_mutex);
-					member->volume_out_level = 0;
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '1':
-					switch_mutex_lock(member->flag_mutex);
-					member->volume_out_level--;
-					switch_normalize_volume(member->volume_out_level);
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '6':
-					switch_mutex_lock(member->flag_mutex);
-					member->volume_in_level++;
-					switch_normalize_volume(member->volume_in_level);
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '5':
-					switch_mutex_lock(member->flag_mutex);
-					member->volume_in_level = 0;
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '4':
-					switch_mutex_lock(member->flag_mutex);
-					member->volume_in_level--;
-					switch_normalize_volume(member->volume_in_level);
-					switch_mutex_unlock(member->flag_mutex);
-					snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
-					conference_member_say(member->conference, member, msg, 0);
-                    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                        switch_channel_t *channel = switch_core_session_get_channel(member->session);
-                        switch_channel_event_set_data(channel, event);
-                        
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
-                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
-                        switch_event_fire(&event);
-                    }
-					break;
-				case '#':
-					switch_clear_flag_locked(member, MFLAG_RUNNING);
-					break;
-				default:
-					break;
-				}
-			}
+			switch_log_printf(SWITCH_CHANNEL_LOG, 
+                              SWITCH_LOG_INFO, 
+                              "executing caller control '%s' param '%s' on call '%u, %s, %s, %s'\n", 
+                              caller_action->fndesc->key, 
+                              param ? param : "none", 
+                              member->id, 
+                              switch_channel_get_name(channel), 
+                              profile->caller_id_name, 
+                              profile->caller_id_number
+                              );
+			caller_action->fndesc->handler(member, caller_action->data);
+
+			/* set up for next pass */
+			caller_action = NULL;
 		}
 
 		/* handle file and TTS frames */
@@ -1196,10 +1547,10 @@
 						switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_BLOCKING;
 						uint32_t rate = member->conference->rate;
 
-						if (switch_core_speech_read_tts(&member->fnode->sh,
-														file_frame,
-														&file_data_len,
-														&rate,
+						if (switch_core_speech_read_tts(&member->fnode->sh, 
+														file_frame, 
+														&file_data_len, 
+														&rate, 
 														&flags) == SWITCH_STATUS_SUCCESS) {
 							file_sample_len = file_data_len / 2;
 						} else {
@@ -1252,18 +1603,22 @@
 				}
 
 				switch_mutex_unlock(member->audio_out_mutex);
-                continue;
+				continue;
 			}
-        }
+		}
 
-        switch_core_timer_next(&timer);
+		switch_core_timer_next(&timer);
 	} /* 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_LOG, SWITCH_LOG_DEBUG, "Channel leaving conference, cause: %s\n",
-			switch_channel_cause2str(switch_channel_get_cause(channel)));
+	switch_log_printf(SWITCH_CHANNEL_LOG, 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)) {
@@ -1336,9 +1691,9 @@
 		goto end;
 	}
 
-	if (switch_core_file_open(&fh,
-							  rec->path,
-							  SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT,
+	if (switch_core_file_open(&fh, 
+							  rec->path, 
+							  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;
@@ -1373,7 +1728,7 @@
 	switch_core_file_close(&fh);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Recording Stopped\n");
 
-end:
+ end:
 
 	if (rec->pool) {
 		switch_memory_pool_t *pool = rec->pool;
@@ -1392,24 +1747,26 @@
 /* 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)
 {
-	conference_file_node_t *nptr;
 	uint32_t count = 0;
+    conference_file_node_t *nptr;
 
-	switch_mutex_lock(conference->mutex);
+    assert(conference != NULL);
 
-	if (stop == FILE_STOP_ALL) {
-		for (nptr = conference->fnode; nptr; nptr = nptr->next) {
-			nptr->done++;
-			count++;
-		}
-	} else {
-		if (conference->fnode) {
-			conference->fnode->done++;
-			count++;
-		}
-	}
+    switch_mutex_lock(conference->mutex);
 
-	switch_mutex_unlock(conference->mutex);
+    if (stop == FILE_STOP_ALL) {
+        for (nptr = conference->fnode; nptr; nptr = nptr->next) {
+            nptr->done++;
+            count++;
+        }
+    } else {
+        if (conference->fnode) {
+            conference->fnode->done++;
+            count++;
+        }
+    }
+    
+    switch_mutex_unlock(conference->mutex);	
 
 	return count;
 }
@@ -1417,1537 +1774,1726 @@
 /* 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;
 
-	switch_mutex_lock(member->flag_mutex);
+	if (member != NULL) {
+		conference_file_node_t *nptr;
 
-	if (stop == FILE_STOP_ALL) {
-		for (nptr = member->fnode; nptr; nptr = nptr->next) {
-			nptr->done++;
-			count++;
+		switch_mutex_lock(member->flag_mutex);
+
+		if (stop == FILE_STOP_ALL) {
+			for (nptr = member->fnode; nptr; nptr = nptr->next) {
+				nptr->done++;
+				count++;
+			}
+		} else {
+			if (member->fnode) {
+				member->fnode->done++;
+				count++;
+			}
 		}
-	} else {
-		if (member->fnode) {
-			member->fnode->done++;
-			count++;
-		}
+
+		switch_mutex_unlock(member->flag_mutex);
 	}
 
-	switch_mutex_unlock(member->flag_mutex);
-
 	return count;
 }
 
 /* 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)
 {
-	conference_file_node_t *fnode, *nptr;
-	switch_memory_pool_t *pool;
-	uint32_t count;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+    conference_file_node_t *fnode, *nptr;
+    switch_memory_pool_t *pool;
+    uint32_t count;
     char *expanded = NULL;
-    uint8_t frexp = 0;
-    switch_status_t status = SWITCH_STATUS_SUCCESS;
 
-	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);	
+    assert(conference != NULL);
 
-	if (!count) {
-		return SWITCH_STATUS_FALSE;
-	}
+    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 (channel) {
-		if ((expanded = switch_channel_expand_variables(channel, file)) != file) {
-			file = expanded;
-			frexp = 1;
-		}
-	}
+    if (!count) {
+        status = SWITCH_STATUS_FALSE;
+        goto done;
+    }
 
+    if (channel) {
+        if ((expanded = switch_channel_expand_variables(channel, file)) != file) {
+            file = expanded;
+        } else {
+            expanded = NULL;
+        }
+    }
 
+    if 
 #ifdef WIN32
-	if (*(file +1) != ':' && *file != '/') {
+        (*(file +1) != ':' && *file != '/')
 #else
-	if (*file != '/') {
+        (*file != '/')
 #endif
-		status = conference_say(conference, file, leadin);
-		goto done;
-	}
+            {
+                status = conference_say(conference, 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_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
-		status = SWITCH_STATUS_MEMERR;
-		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;
-	}
+    /* 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;
+    fnode->type = NODE_TYPE_FILE;
+    fnode->leadin = leadin;
 
-	/* Open the file */
-	if (switch_core_file_open(&fnode->fh,
-							  file,
-							  SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT,
-							  pool) != SWITCH_STATUS_SUCCESS) {
-		switch_core_destroy_memory_pool(&pool);
-		status = SWITCH_STATUS_NOTFOUND;
-		goto done;
-	}
+    /* Open the file */
+    if (switch_core_file_open(&fnode->fh, 
+                              file, 
+                              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->pool = pool;
 
-	/* Queue the node */
-	switch_mutex_lock(conference->mutex);
-	for (nptr = conference->fnode; nptr && nptr->next; nptr = nptr->next);
+    /* 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;
-	}
-	switch_mutex_unlock(conference->mutex);
+    if (nptr) {
+        nptr->next = fnode;
+    } else {
+        conference->fnode = fnode;
+    }
+    switch_mutex_unlock(conference->mutex);
 
-    done:
+ done:
 
-    if (frexp) {
-        switch_safe_free(expanded);
-    }
 
-	return status;
+    switch_safe_free(expanded);
+
+	
+
+    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)
 {
-	conference_file_node_t *fnode, *nptr;
-	switch_memory_pool_t *pool;
+    switch_status_t status = SWITCH_STATUS_FALSE;
 
-	if (*file != '/') {
-		return conference_member_say(member->conference, member, file, leadin);
-	}
+    if (member != NULL && file != NULL) {
+        conference_file_node_t *fnode, *nptr;
+        switch_memory_pool_t *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");
-		return SWITCH_STATUS_MEMERR;
-	}
+        if (*file != '/') {
+            return conference_member_say(member, file, leadin);
+        }
 
-	/* 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;
-	}
+        /* 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;
+        }
 
-	fnode->type = NODE_TYPE_FILE;
-	fnode->leadin = leadin;
+        /* 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;
+        }
 
-	/* Open the file */
-	if (switch_core_file_open(&fnode->fh,
-							  file,
-							  SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT,
-							  pool) != SWITCH_STATUS_SUCCESS) {
-		switch_core_destroy_memory_pool(&pool);
-		return SWITCH_STATUS_NOTFOUND;
-	}
+        fnode->type = NODE_TYPE_FILE;
+        fnode->leadin = leadin;
 
-	fnode->pool = pool;
+        /* Open the file */
+        if (switch_core_file_open(&fnode->fh, 
+                                  file, 
+                                  SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, 
+                                  pool) != SWITCH_STATUS_SUCCESS) {
+            switch_core_destroy_memory_pool(&pool);
+            return SWITCH_STATUS_NOTFOUND;
+        }
 
-	/* Queue the node */
-	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "queueing file '%s' for play\n",file);
-	switch_mutex_lock(member->flag_mutex);
-	for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next);
+        fnode->pool = pool;
 
-	if (nptr) {
-		nptr->next = fnode;
-	} else {
-		member->fnode = fnode;
-	}
-	switch_mutex_unlock(member->flag_mutex);
+        /* Queue the node */
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "queueing file '%s' for play\n", file);
+        switch_mutex_lock(member->flag_mutex);
+        for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next);
 
-	return SWITCH_STATUS_SUCCESS;
+        if (nptr) {
+            nptr->next = fnode;
+        } else {
+            member->fnode = fnode;
+        }
+        switch_mutex_unlock(member->flag_mutex);
+
+        status = SWITCH_STATUS_SUCCESS;
+    }
+
+    return status;
 }
 
 /* Say some thing with TTS in the conference room */
-static switch_status_t conference_member_say(conference_obj_t *conference, conference_member_t *member, char *text, uint32_t leadin)
+static switch_status_t conference_member_say(conference_member_t *member, char *text, uint32_t leadin)
 {
-	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 (!(conference->tts_engine && conference->tts_voice)) {
-		return SWITCH_STATUS_SUCCESS;
-	}
+    if (member != NULL && !switch_strlen_zero(text)) {
+        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;
 
-	/* 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;
-	}
+        assert(conference != NULL);
+        
+        if (!(conference->tts_engine && conference->tts_voice)) {
+            return SWITCH_STATUS_SUCCESS;
+        }
 
-	/* 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;
-	}
+        /* 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;
+        }
 
-	fnode->type = NODE_TYPE_SPEECH;
-	fnode->leadin = leadin;
+        /* 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;
+        }
 
-	memset(&fnode->sh, 0, sizeof(fnode->sh));
-	if (switch_core_speech_open(&fnode->sh,
-								conference->tts_engine,
-								conference->tts_voice,
-								conference->rate,
-								&flags,
-								conference->pool) != SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine);
-		return SWITCH_STATUS_FALSE;
-	}
+        fnode->type = NODE_TYPE_SPEECH;
+        fnode->leadin = leadin;
 
+        memset(&fnode->sh, 0, sizeof(fnode->sh));
+        if (switch_core_speech_open(&fnode->sh, 
+                                    conference->tts_engine, 
+                                    conference->tts_voice, 
+                                    conference->rate, 
+                                    &flags, 
+                                    conference->pool) != SWITCH_STATUS_SUCCESS) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine);
+            return SWITCH_STATUS_FALSE;
+        }
 
-	fnode->pool = pool;
+        fnode->pool = pool;
 
-	/* Queue the node */
-	switch_mutex_lock(member->flag_mutex);
-	for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next);
+        /* Queue the node */
+        switch_mutex_lock(member->flag_mutex);
+        for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next);
 
-	if (nptr) {
-		nptr->next = fnode;
-	} else {
-		member->fnode = fnode;
-	}
+        if (nptr) {
+            nptr->next = fnode;
+        } else {
+            member->fnode = fnode;
+        }
 
-	/* Begin Generation */
-	switch_sleep(200000);
-	switch_core_speech_feed_tts(&fnode->sh, text, &flags);
-	switch_mutex_unlock(member->flag_mutex);
+        /* Begin Generation */
+        switch_sleep(200000);
+        switch_core_speech_feed_tts(&fnode->sh, text, &flags);
+        switch_mutex_unlock(member->flag_mutex);
 
-	return SWITCH_STATUS_SUCCESS;
+        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, char *text, uint32_t leadin)
+static switch_status_t conference_say(conference_obj_t *conference, const char *text, uint32_t leadin)
 {
-	conference_file_node_t *fnode, *nptr;
-	switch_memory_pool_t *pool;
-	switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
-	uint32_t count;
+    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_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);	
+    assert(conference != NULL);
 
-	if (!count) {
-		return SWITCH_STATUS_FALSE;
-	}
+    if (switch_strlen_zero(text)) {
+        return SWITCH_STATUS_GENERR;
+    }
 
-	/* 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;
+    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);	
 
-	memset(&fnode->sh, 0, sizeof(fnode->sh));
-	if (switch_core_speech_open(&fnode->sh,
-								conference->tts_engine,
-								conference->tts_voice,
-								conference->rate,
-								&flags,
-								conference->pool) != SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine);
-		return SWITCH_STATUS_FALSE;
-	}
+    if (!count) {
+        return SWITCH_STATUS_FALSE;
+    }
 
-	fnode->pool = 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");
+        return SWITCH_STATUS_MEMERR;
+    }
 
-	/* Queue the node */
-	switch_mutex_lock(conference->mutex);
-	for (nptr = conference->fnode; nptr && nptr->next; nptr = nptr->next);
+    /* 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;
+    }
 
-	if (nptr) {
-		nptr->next = fnode;
-	} else {
-		conference->fnode = fnode;
-	}
+    fnode->type = NODE_TYPE_SPEECH;
+    fnode->leadin = leadin;
 
-	/* Begin Generation */
-	switch_sleep(200000);
-	switch_core_speech_feed_tts(&fnode->sh, text, &flags);
-	switch_mutex_unlock(conference->mutex);
+    memset(&fnode->sh, 0, sizeof(fnode->sh));
+    if (switch_core_speech_open(&fnode->sh, 
+                                conference->tts_engine, 
+                                conference->tts_voice, 
+                                conference->rate, 
+                                &flags, 
+                                conference->pool) != SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine);
+        return SWITCH_STATUS_FALSE;
+    }
 
-	return SWITCH_STATUS_SUCCESS;
+    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;
+    }
+
+    /* 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;
 }
 
-static void conference_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, int (*pfncallback)(conference_obj_t*, conference_member_t*, int, switch_stream_handle_t*, void*), void *data)
+/* 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;
+    conference_member_t *member = NULL;
 
-	if(conference != NULL && stream != NULL && pfncallback != NULL) {
-		switch_mutex_lock(conference->member_mutex);
+    assert(conference != NULL);
+    assert(stream != NULL);
+    assert(pfncallback != NULL);
 
-		for (member = conference->members; member; member = member->next) {
-			pfncallback(conference,member,member->id,stream,data);
-		}
-		switch_mutex_unlock(conference->member_mutex);
-	}
+    switch_mutex_lock(conference->member_mutex);
+
+    for (member = conference->members; member; member = member->next) {
+        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;
+
+    assert(conference != NULL);
+    assert(stream != NULL);
+
+    switch_mutex_lock(conference->member_mutex);
+    //		stream->write_function(stream, "<pre>Current Callers:\n");
+
+    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;
+    conference_member_t *member = NULL;
 
-	switch_mutex_lock(conference->member_mutex);
+    assert(conference != NULL);
+    assert(stream != NULL);
+    assert(delim != NULL);
 
-	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;
-		}
+    switch_mutex_lock(conference->member_mutex);
 
-		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);
+    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)) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "continue\n");
+            continue;
+        }
 
-		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);
+        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);
 
-		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++;
-		}
+        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);
 
-        stream->write_function(stream, "%s%d%s%d%s%d\n",
-                               delim,
-                               member->volume_in_level, delim,
-                               member->volume_out_level, 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++;
+        }
+
+        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);
+
+    switch_mutex_unlock(conference->member_mutex);
+	
 }
 
-static void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream)
+static switch_status_t conf_api_sub_mute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
 {
-	conference_member_t *member = NULL;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	switch_mutex_lock(conference->member_mutex);
-	stream->write_function(stream, "<pre>Current Callers:\n");
+    if (member != NULL) {
+        switch_event_t *event;
 
-	for (member = conference->members; member; member = member->next) {
-		switch_channel_t *channel;
-		switch_caller_profile_t *profile;
+        switch_clear_flag_locked(member, MFLAG_CAN_SPEAK);
+        if (member->conference->muted_sound) {
+            conference_member_play_file(member, member->conference->muted_sound, 0);
+        } else {
+            char msg[512];
 
-		if (switch_test_flag(member, MFLAG_NOCHANNEL)) {
-			continue;
-		}
-		channel = switch_core_session_get_channel(member->session);
-		profile = switch_channel_get_caller_profile(channel);
+            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 (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
 
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "mute-member");
+            switch_event_fire(&event);
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
 
-		stream->write_function(stream, "*) %s (%s)\n", 
-							   profile->caller_id_name,
-							   profile->caller_id_number
-							   );
+    return ret_status;
+}
 
-	}
-	switch_mutex_unlock(conference->member_mutex);
+static switch_status_t conf_api_sub_unmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+{
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
+
+    if (member != NULL) {
+        switch_event_t *event;
+
+        switch_set_flag_locked(member, MFLAG_CAN_SPEAK);
+        if (stream != NULL) {
+            stream->write_function(stream, "OK unmute %u\n", member->id);
+        }
+        if (member->conference->unmuted_sound) {
+            conference_member_play_file(member, member->conference->unmuted_sound, 0);
+        } else {
+            char msg[512];
+
+            snprintf(msg, sizeof(msg), "Un-Muted");
+            conference_member_say(member, msg, 0);
+        }
+        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
+
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "unmute-member");
+            switch_event_fire(&event);
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
+
+    return ret_status;
 }
 
-static int conference_function_mute_member(conference_obj_t *conference, conference_member_t *member, int id, 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)
 {
-	int err = 0;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    if (member != NULL) {
+        switch_event_t *event;
 
-		switch_clear_flag_locked(member, MFLAG_CAN_SPEAK);
-		if (member->conference->muted_sound) {
-			conference_member_play_file(member, member->conference->muted_sound, 0);
-		}
-		stream->write_function(stream, "OK mute %u\n", id);
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        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) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "mute-member");
-			switch_event_fire(&event);
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "deaf-member");
+            switch_event_fire(&event);
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
 
-	return err;
+    return ret_status;
 }
 
-static int conference_function_unmute_member(conference_obj_t *conference, conference_member_t *member, int id, 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)
 {
-	int err = 0;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    if (member != NULL) {
+        switch_event_t *event;
 
-		switch_set_flag_locked(member, MFLAG_CAN_SPEAK);
-		stream->write_function(stream, "OK unmute %u\n", id);
-		if (member->conference->unmuted_sound) {
-			conference_member_play_file(member, member->conference->unmuted_sound, 0);
-		}
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        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) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "unmute-member");
-			switch_event_fire(&event);
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "undeaf-member");
+            switch_event_fire(&event);
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
 
-	return err;
+    return ret_status;
 }
 
-static int conference_function_deaf_member(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data)
+static switch_status_t conf_api_sub_kick(conference_member_t *member, switch_stream_handle_t *stream, void *data)
 {
-	int err = 0;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    if (member != NULL) {
+        switch_event_t *event;
 
-		switch_clear_flag_locked(member, MFLAG_CAN_HEAR);
-		stream->write_function(stream, "OK deaf %u\n", id);
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        switch_mutex_lock(member->flag_mutex);
+        switch_clear_flag(member, MFLAG_RUNNING);
+        switch_set_flag(member, MFLAG_KICKED);
+        switch_mutex_unlock(member->flag_mutex);
+        switch_core_session_kill_channel(member->session, SWITCH_SIG_BREAK);
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "deaf-member");
-			switch_event_fire(&event);
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+        if (stream != NULL) {
+            stream->write_function(stream, "OK kicked %u\n", member->id);
+        }
 
-	return err;
+        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_channel_t *channel = switch_core_session_get_channel(member->session);
+            switch_channel_event_set_data(channel, event);
+
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "kick-member");
+            switch_event_fire(&event);
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
+
+    return ret_status;
 }
 
-static int conference_function_undeaf_member(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data)
+static switch_status_t conf_api_sub_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data)
 {
-	int err = 0;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    if (member != NULL) {
+        switch_event_t *event;
 
-		switch_set_flag_locked(member, MFLAG_CAN_HEAR);
-		stream->write_function(stream, "OK undeaf %u\n", id);
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        if (data) {
+            switch_mutex_lock(member->flag_mutex);
+            member->energy_level = atoi((char *)data);
+            switch_mutex_unlock(member->flag_mutex);
+        }
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "undeaf-member");
-			switch_event_fire(&event);
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+        if (stream != NULL) {
+            stream->write_function(stream, "Energy %u = %d\n", member->id, member->energy_level);
+        }
 
-	return err;
+        if (data) {
+            if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+                switch_channel_t *channel = switch_core_session_get_channel(member->session);
+                switch_channel_event_set_data(channel, event);
+
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+                switch_event_add_header(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);
+            }
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
+
+    return ret_status;
 }
 
-static int conference_function_kick_member(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data)
+static switch_status_t conf_api_sub_volume_in(conference_member_t *member, switch_stream_handle_t *stream, void *data)
 {
-	int err = 0;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    if (member != NULL) {
+        switch_event_t *event;
 
-		switch_mutex_lock(member->flag_mutex);
-		switch_clear_flag(member, MFLAG_RUNNING);
-		switch_set_flag(member, MFLAG_KICKED);
-		switch_mutex_unlock(member->flag_mutex);
-        switch_core_session_kill_channel(member->session, SWITCH_SIG_BREAK);
-		stream->write_function(stream, "OK kicked %u\n", id);
-        
-		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-			switch_channel_t *channel = switch_core_session_get_channel(member->session);
-			switch_channel_event_set_data(channel, event);
+        if (data) {
+            switch_mutex_lock(member->flag_mutex);
+            member->volume_in_level = atoi((char *)data);
+            switch_normalize_volume(member->volume_in_level);
+            switch_mutex_unlock(member->flag_mutex);
+        }
 
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "kick-member");
-			switch_event_fire(&event);
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+        if (stream != NULL) {
+            stream->write_function(stream, "Volume IN %u = %d\n", member->id, member->volume_in_level);
+        }
+        if (data) {
+            if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+                switch_channel_t *channel = switch_core_session_get_channel(member->session);
+                switch_channel_event_set_data(channel, event);
 
-	return err;
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+                switch_event_add_header(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);
+            }
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
+
+    return ret_status;
 }
 
-static int conference_function_energy_member(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data)
+static switch_status_t conf_api_sub_volume_out(conference_member_t *member, switch_stream_handle_t *stream, void *data)
 {
-	int err = 0;
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    if (member != NULL) {
+        switch_event_t *event;
 
-		if (data) {
-			switch_mutex_lock(member->flag_mutex);
-			member->energy_level = atoi((char *)data);
-			switch_mutex_unlock(member->flag_mutex);
-		}
+        if (data) {
+            switch_mutex_lock(member->flag_mutex);
+            member->volume_out_level = atoi((char *)data);
+            switch_normalize_volume(member->volume_out_level);
+            switch_mutex_unlock(member->flag_mutex);
+        }
 
-		stream->write_function(stream, "Energy %u=%d\n", id, member->energy_level);
+        if (stream != NULL) {
+            stream->write_function(stream, "Volume OUT %u = %d\n", member->id, member->volume_out_level);
+        }
 
-		if (data) {
-			if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-				switch_channel_t *channel = switch_core_session_get_channel(member->session);
-				switch_channel_event_set_data(channel, event);
+        if (data) {
+            if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+                switch_channel_t *channel = switch_core_session_get_channel(member->session);
+                switch_channel_event_set_data(channel, event);
 
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "energy-level-member");
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Energy-Level", "%d", member->energy_level);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+                switch_event_add_header(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);
-			}
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+                switch_event_fire(&event);
+            }
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
 
-	return err;
+    return ret_status;
 }
 
-static int conference_function_volume_in_member(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data)
+static switch_status_t conf_api_sub_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv)
 {
-	int err = 0;
+    int ret_status = SWITCH_STATUS_GENERR;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    switch_hash_index_t *hi;
+    void *val;
+    char *d = ";";
+    int pretty = 0;
+    int argofs = (argc >= 2 && strcasecmp(argv[1], "list") == 0);	// detect being called from chat vs. api
 
-		if (data) {
-			switch_mutex_lock(member->flag_mutex);
-			member->volume_in_level = atoi((char *)data);
-			switch_normalize_volume(member->volume_in_level);
-			switch_mutex_unlock(member->flag_mutex);
-		}
+    if (argv[1+argofs]) {
+        if (argv[2+argofs] && !strcasecmp(argv[1+argofs], "delim")) {
+            d = argv[2+argofs];
 
-		stream->write_function(stream, "Volume IN %u=%d\n", id, member->volume_in_level);
-		if (data) {
-			if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-				switch_channel_t *channel = switch_core_session_get_channel(member->session);
-				switch_channel_event_set_data(channel, event);
+            if (*d == '"') {
+                if (++d) {
+                    char *p;
+                    if ((p = strchr(d, '"'))) {
+                        *p = '\0';
+                    }
+                } else {
+                    d = ";";
+                }
+            }
+        } else if (strcasecmp(argv[1+argofs], "pretty") == 0) {
+            pretty = 1;
+        }
+    }
 
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "volume-in-member");
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%u", member->volume_in_level);
+    if (conference == NULL) {
+        for (hi = switch_hash_first(globals.conference_pool, globals.conference_hash); hi; hi = switch_hash_next(hi)) {
+            switch_hash_this(hi, NULL, NULL, &val);
+            conference = (conference_obj_t *) val;
 
-				switch_event_fire(&event);
-			}
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+            stream->write_function(stream, "Conference %s (%u member%s)\n", 
+                                   conference->name, 
+                                   conference->count, 
+                                   conference->count == 1 ? "" : "");
+            if (pretty) {
+                conference_list_pretty(conference, stream);
+            } else {
+                conference_list(conference, stream, d);
+            }
+        }
+    } else {
+        if (pretty) {
+            conference_list_pretty(conference, stream);
+        } else {
+            conference_list(conference, stream, d);
+        }
+    }
 
-	return err;
+    ret_status = SWITCH_STATUS_SUCCESS;
+
+    return ret_status;
 }
 
-static int conference_function_volume_out_member(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data)
+static switch_status_t conf_api_sub_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv)
 {
-	int err = 0;
+    int ret_status = SWITCH_STATUS_GENERR;
+    switch_event_t *event;
 
-	if (member != NULL || (member = conference_member_get(conference, id))) {
-		switch_event_t *event;
+    assert(conference != NULL);
+    assert(stream != NULL);
 
-		if (data) {
-			switch_mutex_lock(member->flag_mutex);
-			member->volume_out_level = atoi((char *)data);
-			switch_normalize_volume(member->volume_out_level);
-			switch_mutex_unlock(member->flag_mutex);
-		}
+    
+    if (argc == 3) {
+        if (conference_play_file(conference, argv[2], 0, NULL) == SWITCH_STATUS_SUCCESS) {
+            stream->write_function(stream, "(play) Playing file %s\n", argv[2]);
+            if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "play-file");
+                switch_event_add_header(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 if (argc == 4) {
+        uint32_t id = atoi(argv[3]);
+        conference_member_t *member;
 
-		stream->write_function(stream, "Volume OUT %u=%d\n", id, member->volume_out_level);
+        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 (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+                    switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+                    switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
+                    switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "play-file-member");
+                    switch_event_add_header(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);
+        }
+    }
 
-		if (data) {
-			if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-				switch_channel_t *channel = switch_core_session_get_channel(member->session);
-				switch_channel_event_set_data(channel, event);
+    return ret_status;
+}
 
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "volume-out-member");
-				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%u", member->volume_out_level);
+static switch_status_t conf_api_sub_say(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text)
+{
+    int ret_status = SWITCH_STATUS_GENERR;
 
-				switch_event_fire(&event);
-			}
-		}
-	} else {
-		stream->write_function(stream, "Non-Existant ID %u\n", id);
-		err = 1;
-	}
+    if (switch_strlen_zero(text)) {
+        stream->write_function(stream, "(say) Error! No text.");
+        return ret_status;
+    }
 
-	return err;
+    if (conference_say(conference, text, 0) == SWITCH_STATUS_SUCCESS) {
+        switch_event_t *event;
+
+        stream->write_function(stream, "(say) OK\n");
+        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "speak-text");
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Text", "%s", text);
+            switch_event_fire(&event);
+        }
+        ret_status = SWITCH_STATUS_SUCCESS;
+    } else {
+        stream->write_function(stream, "(say) Error!");
+    }
+
+    return ret_status;
 }
 
-/* API Interface Function */
-static switch_status_t conf_function(char *buf, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t conf_api_sub_saymember(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text)
 {
-	char *lbuf = NULL;
-	switch_status_t status = SWITCH_STATUS_SUCCESS;
-	char *http = NULL;
-    switch_memory_pool_t *pool = NULL;
+    int ret_status = SWITCH_STATUS_GENERR;
+    char *expanded = NULL;
+    char *start_text = NULL;
+    char *workspace = NULL;
+    uint32_t id = 0;
+    conference_member_t *member;
 
-	if (session) {
-		return SWITCH_STATUS_FALSE;
-	}
+    if (switch_strlen_zero(text)) {
+        stream->write_function(stream, "(saymember) No Text!\n");
+        goto done;
+    }
 
-	if (stream->event) {
-		http = switch_event_get_header(stream->event, "http-host");
-	}
+    if (!(workspace = strdup(text))) {
+        stream->write_function(stream, "(saymember) Memory Error!\n");
+        goto done;
+    }
 
-	if (http) {
-		/* Output must be to a web browser */
-		stream->write_function(stream, "<pre>\n");
-	}
+    if ((start_text = strchr(workspace, ' '))) {
+        *start_text++ = '\0';
+        text = start_text;
+    }
 
-	if (!buf) {
-		stream->write_function(stream, "%s", conf_api_interface.syntax);
-		return status;
-	}
+    id = atoi(workspace);
 
-	if ((lbuf = strdup(buf))) {
-		conference_obj_t *conference = NULL;
-		int argc;
-		char *argv[25];
-		switch_event_t *event;
+    if (!id || switch_strlen_zero(text)) {
+        stream->write_function(stream, "(saymember) No Text!\n");
+        goto done;
+    }
 
-		argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+    if (!(member = conference_member_get(conference, id))) {
+        stream->write_function(stream, "(saymember) Unknown Member %u!", id);
+        goto done;
+    }
 
-		/* Figure out what conference */
-		if (argc) {
-			if (!strcasecmp(argv[0], "commands")) {
-				stream->write_function(stream, "%s", conf_api_interface.syntax);
-				goto done;
-			} else if (!strcasecmp(argv[0], "list")) {
-				switch_hash_index_t *hi;
-				void *val;
-				char *d = ";";
+    if ((expanded = switch_channel_expand_variables(switch_core_session_get_channel(member->session), (char *)text)) != text) {
+        text = expanded;
+    } else {
+        expanded = NULL;
+    }
 
-				if (argv[1]) {
-					if (argv[2] && !strcasecmp(argv[1], "delim")) {
-						d = argv[2];
+    if (text && conference_member_say(member, (char *)text, 0) == SWITCH_STATUS_SUCCESS) {
+        switch_event_t *event;
 
-						if (*d == '"') {
-							if (++d) {
-								char *p;
-								if ((p = strchr(d, '"'))) {
-									*p = '\0';
-								}
-							} else {
-								d = ";";
-							}
-						}
-					}
-				} 
+        stream->write_function(stream, "(saymember) OK\n");
+        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "speak-text-member");
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Text", "%s", text);
+            switch_event_fire(&event);
+        }
+        ret_status = SWITCH_STATUS_SUCCESS;
+    } else {
+        stream->write_function(stream, "(saymember) Error!");
+    }
 
-				for (hi = switch_hash_first(globals.conference_pool, globals.conference_hash); hi; hi = switch_hash_next(hi)) {
-					switch_hash_this(hi, NULL, NULL, &val);
-					conference = (conference_obj_t *) val;
+ done:    
+    switch_safe_free(workspace);
+    switch_safe_free(expanded);
+    return ret_status;
+}
 
-					stream->write_function(stream, "Conference %s (%u member%s)\n", conference->name, conference->count, conference->count == 1 ? "" : "s");
-					conference_list(conference, stream, d);
-					stream->write_function(stream, "\n");
-				}
-				goto done;
-			} else if (!(conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, argv[0]))) {
-				stream->write_function(stream, "No Conference called %s found.\n", argv[0]);
-				goto done;
-			}
+static switch_status_t conf_api_sub_stop(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv)
+{
+    int ret_status = SWITCH_STATUS_GENERR;
+    uint8_t current = 0, all = 0;
 
-			if (argc > 1) { 
-				if (!strcasecmp(argv[1], "lock")) {
-					switch_set_flag_locked(conference, CFLAG_LOCKED);
-					stream->write_function(stream, "OK %s locked\n", argv[0]);
-					if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-						switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-						switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "lock");
-						switch_event_fire(&event);
-					}
-					goto done;
-				} else if (!strcasecmp(argv[1], "unlock")) {
-					switch_clear_flag_locked(conference, CFLAG_LOCKED);
-					stream->write_function(stream, "OK %s unlocked\n", argv[0]);
-					if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-						switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-						switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
-						switch_event_fire(&event);
-					}
-					goto done;
-				} else if (!strcasecmp(argv[1], "dial")) {
-					if (argc > 2) {
-						conference_outcall(conference, NULL, argv[2], 60, argv[3], argv[4], argv[5]);
-						stream->write_function(stream, "OK\n");
-						goto done;
-					} else {
-						stream->write_function(stream, "Error!\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "play")) {
-					if (argc == 3) {
-						if (conference_play_file(conference, argv[2], 0, NULL) == SWITCH_STATUS_SUCCESS) {
-							stream->write_function(stream, "(play) Playing file %s\n", argv[2]);
-							if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-								switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-								switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "play-file");
-								switch_event_add_header(event, SWITCH_STACK_BOTTOM, "File", argv[2]);
-								switch_event_fire(&event);
-							}
-							goto done;
-						} else {
-							stream->write_function(stream, "(play) File: %s not found.\n", argv[2] ? argv[2] : "(unspecified)");
-							goto done;
-						}
-					} else if (argc == 4) {
-						uint32_t id = atoi(argv[3]);
-						conference_member_t *member;
+    assert(conference != NULL);
+    assert(stream != NULL);
 
-						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 (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "play-file-member");
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "File", argv[2]);
-									switch_event_fire(&event);
-								}
-								goto done;
-							} else {
-								stream->write_function(stream, "(play) File: %s not found.\n", argv[2] ? argv[2] : "(unspecified)");
-								goto done;
-							}
-						} else {
-							stream->write_function(stream, "Member: %u not found.\n", id);
-							goto done;
-						}
-					}
-				} else if (!strcasecmp(argv[1], "say")) {
-					char *tbuf = NULL;
-					char *text;
+    if (argc > 2) {
+        current = strcasecmp(argv[2], "current") ? 0 : 1;
+        all = strcasecmp(argv[2], "all") ? 0 : 1;
+    }
 
-					if (argc > 2 && (tbuf = strdup(buf))) {
-						if ((text = strstr(tbuf, "say"))) {
-							text += 4;
-							while(*text == ' ') {
-								text++;
-							}
-							if (!switch_strlen_zero(text) && conference_say(conference, text, 0) == SWITCH_STATUS_SUCCESS) {
-								stream->write_function(stream, "(say) OK\n");
-								if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "speak-text");
-									switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Text", text);
-									switch_event_fire(&event);
-								}
-								goto done;
-							} else {
-								stream->write_function(stream, "(say) Error!");
-								goto done;
-							}
-						}
+    if (current || all) {
+        if (argc == 4) {
+            uint32_t id = atoi(argv[3]);
+            conference_member_t *member;
 
-						free(tbuf);
-					} else {
-						stream->write_function(stream, "(say) Error! No text.");
-					}
-				} else if (!strcasecmp(argv[1], "saymember")) {
-					char *tbuf = NULL, *text, *name;
-					uint32_t id;
-					conference_member_t *member;
+            if ((member = conference_member_get(conference, id))) {
+                uint32_t stopped = conference_member_stop_file(member, 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);
+            }
+            ret_status = SWITCH_STATUS_SUCCESS;
+        } else {
+            uint32_t stopped = conference_stop_file(conference, current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
+            stream->write_function(stream, "Stopped %u files.\n", stopped);
+            ret_status = SWITCH_STATUS_SUCCESS;
+        }
+    }
 
-					if (argc > 3) {
-						id = atoi(argv[3]);
-					} else {
-						stream->write_function(stream, "(saymember) Syntax Error!");
-						goto done;
-					}
+    return ret_status;
+}
 
-					if ((tbuf = strdup(buf))) {
-						if ((name = strstr(tbuf, "saymember "))) {
-							name += 10;
+static switch_status_t conf_api_sub_relate(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv)
+{
+    int ret_status = SWITCH_STATUS_GENERR;
 
-							if (*name) {
-								text = strchr(name, ' ');
-								id = atoi(name);
-							} else {
-								stream->write_function(stream, "(saymember) Syntax Error!");
-								goto done;
-							}
+    assert(conference != NULL);
+    assert(stream != NULL);
 
+    if (argc > 4) {
+        uint8_t nospeak = 0, nohear = 0, clear = 0;
+        nospeak = strstr(argv[4], "nospeak") ? 1 : 0;
+        nohear = strstr(argv[4], "nohear") ? 1 : 0;
 
+        if (!strcasecmp(argv[4], "clear")) {
+            clear = 1;
+        }
 
-							if ((member = conference_member_get(conference, id))) {
-								if (text && conference_member_say(conference, member, text, 0) == SWITCH_STATUS_SUCCESS) {
-									stream->write_function(stream, "(saymember) OK\n");
-									if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-										switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
-										switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "speak-text-member");
-										switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id);
-										switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Text", text);
-										switch_event_fire(&event);
-									}
-								} else {
-									stream->write_function(stream, "(saymember) Error!");
-								}
-							} else {
-								stream->write_function(stream, "(saymember) Unknown Member %u!", id);
-							}
-						} else {
-							stream->write_function(stream, "(saymember) Syntax Error!");
-						}
+        if (!(clear || nospeak || nohear)) { 
+            ret_status = SWITCH_STATUS_GENERR;
+            goto done;
+        }
+        ret_status = SWITCH_STATUS_SUCCESS;
 
-						free(tbuf);
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "stop")) {
-					uint8_t current = 0, all = 0;
+        if (clear) {
+            conference_member_t *member = NULL;
+            uint32_t id = atoi(argv[2]);
+            uint32_t oid = atoi(argv[3]);
 
-					if (argc > 2) {
-						current = strcasecmp(argv[2], "current") ? 0 : 1;
-						all = strcasecmp(argv[2], "all") ? 0 : 1;
-					}
+            switch_mutex_lock(conference->mutex);
+            switch_mutex_lock(conference->member_mutex);
+            if ((member = conference_member_get(conference, id))) {
+                member_del_relationship(member, oid);
+                stream->write_function(stream, "relationship %u->%u cleared.", id, oid);
+            } else {
+                stream->write_function(stream, "relationship %u->%u not found", id, oid);
+            }
+            switch_mutex_unlock(conference->member_mutex);
+            switch_mutex_unlock(conference->mutex);
+        } else if (nospeak || nohear) {
+            conference_member_t *member = NULL, *other_member = NULL;
+            uint32_t id = atoi(argv[2]);
+            uint32_t oid = atoi(argv[3]);
 
-					if (current || all) {
-						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, 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);
-								goto done;
-							}
-						} else {
-							uint32_t stopped = conference_stop_file(conference, current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
-							stream->write_function(stream, "Stopped %u files.\n", stopped);
-						}
-					} else {
-						stream->write_function(stream, "Usage stop [current/all]\n");
-						goto done;
-					}
+            switch_mutex_lock(conference->mutex);
+            switch_mutex_lock(conference->member_mutex);
+            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);
+                }
 
-				} else if (!strcasecmp(argv[1], "energy")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+                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", id, oid);
+            }
+            switch_mutex_unlock(conference->member_mutex);
+            switch_mutex_unlock(conference->mutex);
+        }
+    }
 
-						if (!all) {
-							conference_function_energy_member(conference, NULL, id, stream, argv[3]);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_energy_member, argv[3]); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage energy <id|all> [<newval>]\n");
-						goto done;
-					}
+ done:
+    return ret_status;
+}
 
-				} else if (!strcasecmp(argv[1], "volume_in")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+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;
 
-						if (!all) {
-							conference_function_volume_in_member(conference, NULL, id, stream, argv[3]);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_volume_in_member, argv[3]); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage volume_in <[id|all]> [<newval>]\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "volume_out")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+    assert(conference != NULL);
+    assert(stream != NULL);
 
-						if (!all) {
-							conference_function_volume_out_member(conference, NULL, id, stream, argv[3]);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_volume_out_member, argv[3]); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage volume_out <[id|all> [<newval>]\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "mute")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+    switch_set_flag_locked(conference, CFLAG_LOCKED);
+    stream->write_function(stream, "OK %s locked\n", argv[0]);
+    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "lock");
+        switch_event_fire(&event);
+    }
 
-						if (!all) {
-							conference_function_mute_member(conference, NULL, id, stream, NULL);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_mute_member, NULL); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage mute <[id|all]>\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "unmute")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+    return 0;
+}
 
-						if (!all) {
-							conference_function_unmute_member(conference, NULL, id, stream, NULL);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_unmute_member, NULL); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage unmute <[id|all]>\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "deaf")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 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;
 
-						if (!all) {
-							conference_function_deaf_member(conference, NULL, id, stream, NULL);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_deaf_member, NULL); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage deaf <[id|all]>\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "undeaf")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+    assert(conference != NULL);
+    assert(stream != NULL);
 
-						if (!all) {
-							conference_function_undeaf_member(conference, NULL, id, stream, NULL);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_undeaf_member, NULL); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage undeaf <[id|all]>\n");
-						goto done;
-					}
+    switch_clear_flag_locked(conference, CFLAG_LOCKED);
+    stream->write_function(stream, "OK %s unlocked\n", argv[0]);
+    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
+        switch_event_fire(&event);
+    }
+	
 
-				} else if (!strcasecmp(argv[1], "record")) {
-					if (argc > 2) {
-						launch_conference_record_thread(conference, argv[2]);
-						goto done;
-					} else {
-						stream->write_function(stream, "usage record <filename>\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "norecord")) {
-					if (argc > 2) {
-						int all = (strcasecmp(argv[2], "all") == 0 );
+    return 0;
+}
 
-						if(!conference_record_stop(conference, all ? NULL : argv[2]) && !all) {
-							stream->write_function(stream, "non-existant recording '%s'\n", argv[2]);
-						}
-						goto done;
-					} else {
-						stream->write_function(stream, "usage norecord <[filename | all]>\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "kick")) {
-					if (argc > 2) {
-						uint32_t id = atoi(argv[2]);
-						int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 );
+static switch_status_t conf_api_sub_dial(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv)
+{
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
 
-						if (!all) {
-							conference_function_kick_member(conference, NULL, id, stream, NULL);
-							goto done;
-						} else {
-							conference_member_itterator(conference, stream, &conference_function_kick_member, NULL); 
-							goto done;
-						}
-					} else {
-						stream->write_function(stream, "usage kick <[id|all]>\n");
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "transfer")) {
-					char *transfer_usage = "Usage transfer <confname> <id> [..<idN>]\n";
-                    if (switch_strlen_zero(argv[2])) {
-                        stream->write_function(stream, transfer_usage);
+    assert(conference != NULL);
+    assert(stream != NULL);
+
+    if (argc > 2) {
+        conference_outcall(conference, NULL, argv[2], 60, NULL, argv[4], argv[3]);
+        stream->write_function(stream, "OK\n");
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
+
+    return ret_status;
+}
+
+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;
+
+    assert(conference != NULL);
+    assert(stream != NULL);
+
+    if (argc > 3 && !switch_strlen_zero(argv[2])) {
+        int x;
+
+        for (x = 3; x<argc; x++) {
+            conference_member_t *member = NULL;
+            uint32_t id = atoi(argv[x]);
+            conference_obj_t *new_conference = NULL;
+            switch_channel_t *channel;
+            switch_event_t *event;
+            char *profile_name;
+            switch_xml_t cxml = NULL, cfg = NULL, profiles = NULL;
+
+            if (!(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);
+
+            /* build a new conference if it doesn't exist */
+            if (!(new_conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, argv[2]))) {
+                switch_memory_pool_t *pool = NULL;
+                char *conf_name;
+                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;
+                }
+
+                conf_name = switch_core_strdup(pool, argv[2]);
+
+                if ((profile_name = strchr(conf_name, '@'))) {
+                    *profile_name++ = '\0';
+
+                    /* Open the config from the xml registry  */
+                    if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) {
+                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", global_cf_name);
                         goto done;
                     }
-					if (argc > 3) {
-                        int x = 0;
-                        for(x = 3; x < argc; x++) {
-                            conference_member_t *member = NULL;
-                            uint32_t id = atoi(argv[x]);
-                            conference_obj_t *new_conference = NULL;
-                            switch_channel_t *channel;
-                            switch_event_t *event;
-                            char *profile_name;
-                            switch_xml_t cxml = NULL, cfg = NULL, profile = NULL, profiles = NULL;
 
-                            if (!(member = conference_member_get(conference, id))) {								
-                                stream->write_function(stream, "No Member %u in conference %s.\n", id, conference->name);
-                                continue;
-                            }
+                    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");
+#ifdef OPTION_IVR_MENU_SUPPORT
+                    xml_cfg.menus = switch_xml_child(cfg, "menus");
+#endif
+                } 
 
-                            channel = switch_core_session_get_channel(member->session);
+                /* Release the config registry handle */
+                if (cxml) {
+                    switch_xml_free(cxml);
+                    cxml = NULL;
+                }
 
-                            if (!(new_conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, argv[2]))) {
-                                char *conf_name;
+                /* Create the conference object. */
+                new_conference = conference_new(conf_name, xml_cfg, 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");
-                                    goto done;
-                                }
+                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;
+                }
 
-                                conf_name = switch_core_strdup(pool, argv[2]);
+                /* Set the minimum number of members (once you go above it you cannot go below it) */
+                new_conference->min = 1;
 
-                                if ((profile_name = strchr(conf_name, '@'))) {
-                                    *profile_name++ = '\0';
+                /* Indicate the conference is dynamic */
+                switch_set_flag_locked(new_conference, CFLAG_DYNAMIC);
 
-                                    /* Open the config from the xml registry */
-                                    if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) {
-                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", global_cf_name);
-                                        goto done;
-                                    }
+                /* Start the conference thread for this conference */
+                launch_conference_thread(new_conference);
+            }
 
-                                    if ((profiles = switch_xml_child(cfg, "profiles"))) {
-                                        profile = switch_xml_find_child(profiles, "profile", "name", profile_name);
-                                    }
-                                } 
+            /* move the member from the old conference to the new one */
+            conference_del_member(member->last_conference, member);
+            conference_add_member(new_conference, member);
 
+            stream->write_function(stream, "OK Members sent to conference %s.\n", argv[2]);
 
-                                /* Release the config registry handle */
-                                if (cxml) {
-                                    switch_xml_free(cxml);
-                                    cxml = NULL;
-                                }
+            /* tell them what happened */
+            if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
+                switch_channel_event_set_data(channel, event);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Old-Conference-Name", conference->name);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Conference-Name", argv[3]);
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
+                switch_event_fire(&event);
+            }
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
 
-                                /* Create the conference object. */
-                                new_conference = conference_new(conf_name, profile, pool);
+ done:
+    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_status_t ret_status = SWITCH_STATUS_SUCCESS;
+    assert(conference != NULL);
+    assert(stream != NULL);
 
-                                if (!new_conference) {
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
-                                    goto done;
-                                }
+    if (argc > 2) {
+        launch_conference_record_thread(conference, argv[2]);
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
 
-                                /* 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);
+    return ret_status;
+}
 
-                                pool = NULL;
-                                /* Start the conference thread for this conference */
-                                launch_conference_thread(new_conference);
+static switch_status_t conf_api_sub_norecord(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv)
+{
+    switch_status_t ret_status = SWITCH_STATUS_SUCCESS;
+
+    assert(conference != NULL);
+    assert(stream != NULL);
+
+    if (argc > 2) {
+        int all = (strcasecmp(argv[2], "all") == 0 );
+
+        if (!conference_record_stop(conference, all ? NULL : argv[2]) && !all) {
+            stream->write_function(stream, "non-existant recording '%s'\n", argv[2]);
+        }
+    } else {
+        ret_status = SWITCH_STATUS_GENERR;
+    }
+	
+    return ret_status;
+}
+
+
+
+/* API Interface Function sub-commands */
+static api_command_t conf_api_sub_commands[] = {
+    {"list", 	&conf_api_sub_list, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> list [delim <string>]"}, 
+    {"energy", 	&conf_api_sub_energy, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> energy <member_id|all|last> [<newval>]"}, 
+    {"volume in", 	&conf_api_sub_volume_in, 	CONF_API_SUB_MEMBER_TARGET, 	"<confname> volume_in <member_id|all|last> [<newval>]"}, 
+    {"volume out", 	&conf_api_sub_volume_out, 	CONF_API_SUB_MEMBER_TARGET, 	"<confname> volume_out <member_id|all|last> [<newval>]"}, 
+    {"play", 	&conf_api_sub_play, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> play <file_path> [<member_id>]"}, 
+    {"say", 		&conf_api_sub_say, 		CONF_API_SUB_ARGS_AS_ONE, 	"<confname> say <text>"}, 
+    {"saymember", 	&conf_api_sub_saymember, 	CONF_API_SUB_ARGS_AS_ONE, 	"<confname> saymember <member_id> <text>"}, 
+    {"stop", 	&conf_api_sub_stop, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> stop <[current|all|last]> [<member_id>]"}, 
+    {"kick", 	&conf_api_sub_kick, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> kick <[member_id|all|last]>"}, 
+    {"mute", 	&conf_api_sub_mute, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> mute <[member_id|all]|last>"}, 
+    {"unmute", 	&conf_api_sub_unmute, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> unmute <[member_id|all]|last>"}, 
+    {"deaf", 	&conf_api_sub_deaf, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> deaf <[member_id|all]|last>"}, 
+    {"undeaf", 	&conf_api_sub_undeaf, 		CONF_API_SUB_MEMBER_TARGET, 	"<confname> undeaf <[member_id|all]|last>"}, 
+    {"relate", 	&conf_api_sub_relate, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> relate <member_id> <other_member_id> [nospeak|nohear|clear]"}, 
+    {"lock", 	&conf_api_sub_lock, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> lock"}, 
+    {"unlock", 	&conf_api_sub_unlock, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> unlock"}, 
+    {"dial", 	&conf_api_sub_dial, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> dial <endpoint_module_name>/<destination> <callerid number> <callerid name>"}, 
+    {"transfer", 	&conf_api_sub_transfer, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> transfer <conference_name> <member id> [...<member id>]"}, 
+    {"record", 	&conf_api_sub_record, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> record <filename>"}, 
+    {"norecord", 	&conf_api_sub_norecord, 		CONF_API_SUB_ARGS_SPLIT, 	"<confname> norecord <[filename|all]>"}, 
+};
+
+#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;
+    assert(conference != NULL);
+    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 = atoi(argv[argn+1]);
+                    int all = ( id == 0 && strcasecmp(argv[argn+1], "all") == 0 );
+                    int last = ( id == 0 && strcasecmp(argv[argn+1], "last") == 0 );
+
+                    if (all) {
+                        conference_member_itterator(conference, stream, 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;
+                        }
 
-                            conference_del_member(member->last_conference, member);
-                            conference_add_member(new_conference, member);
-                            stream->write_function(stream, "OK Members sent to conference %s.\n", argv[2]);
+                        /* exec functio on last (oldest) member */
+                        if (last_member != NULL) {
+                            conf_api_member_cmd_t pfn = (conf_api_member_cmd_t)conf_api_sub_commands[i].pfnapicmd;
+                            pfn(last_member, stream, argv[argn+2]);
+                        }
 
-                            if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-                                switch_channel_event_set_data(channel, event);
-                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Old-Conference-Name", conference->name);
-                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Conference-Name", argv[2]);
-                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
-                                switch_event_fire(&event);
+                        switch_mutex_unlock(conference->member_mutex);
+                    } else {
+                        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(conference_member_get(conference, id), stream, argv[argn+2]);
+                        } else {
+                            if (id == 0) {
+                                stream->write_function(stream, conf_api_sub_commands[i].psyntax);
+                            } else {
+                                stream->write_function(stream, "Non-Existant ID %u\n", id);
                             }
                         }
-					} else {
-						stream->write_function(stream, transfer_usage);
-						goto done;
-					}
-				} else if (!strcasecmp(argv[1], "relate")) {
-					char *relate_usage = "Usage relate <id> <id> [nospeak|nohear|clear]\n";
-					if (argc > 4) {
-						uint8_t nospeak = 0, nohear = 0, clear = 0;
-						nospeak = strstr(argv[4], "nospeak") ? 1 : 0;
-						nohear = strstr(argv[4], "nohear") ? 1 : 0;
+                    }
+                }
+                break;
 
-						if (!strcasecmp(argv[4], "clear")) {
-							clear = 1;
-						}
+                /* 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 (!(clear || nospeak || nohear)) { 
-							stream->write_function(stream, relate_usage);
-							goto done;
-						}
+                    if ((start_text = strstr(modified_cmdline, cmd))) {
+                        modified_cmdline = start_text + strlen(cmd);
+                        while(modified_cmdline && *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 (clear) {
-							conference_member_t *member = NULL;
-							uint32_t id = atoi(argv[2]);
-							uint32_t oid = atoi(argv[3]);
+    if (!found) {
+        stream->write_function(stream, "Confernece command '%s' not found.\n", argv[argn]);
+    } else {
+        status = SWITCH_STATUS_SUCCESS;
+    }
 
-							switch_mutex_lock(conference->mutex);
-							switch_mutex_lock(conference->member_mutex);
-							if ((member = conference_member_get(conference, id))) {
-								member_del_relationship(member, oid);
-								stream->write_function(stream, "relationship %u->%u cleared.", id, oid);
-							} else {
-								stream->write_function(stream, "relationship %u->%u not found", id, oid);
-							}
-							switch_mutex_unlock(conference->member_mutex);
-							switch_mutex_unlock(conference->mutex);
-						} else if (nospeak || nohear) {
-							conference_member_t *member = NULL, *other_member = NULL;
-							uint32_t id = atoi(argv[2]);
-							uint32_t oid = atoi(argv[3]);
+    return status;
+}
 
-							switch_mutex_lock(conference->mutex);
-							switch_mutex_lock(conference->member_mutex);
-							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);
-								}
+/* API Interface Function */
+static switch_status_t conf_api_main(char *buf, switch_core_session_t *session, switch_stream_handle_t *stream)
+{
+    char *lbuf = NULL;
+    switch_status_t status = SWITCH_STATUS_SUCCESS;
+    char *http = NULL;
+    int argc;
+    char *argv[25] = {0};
 
-								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");
-								}
+    if (!buf) {
+        buf = "help";
+    }
 
-							} else {
-								stream->write_function(stream, "relationship %u->%u not found", id, oid);
-							}
-							switch_mutex_unlock(conference->member_mutex);
-							switch_mutex_unlock(conference->mutex);
-						}
+    if (session) {
+        return SWITCH_STATUS_FALSE;
+    }
 
+    if (stream->event) {
+        http = switch_event_get_header(stream->event, "http-host");
+    }
 
-					} else {
-						stream->write_function(stream, relate_usage);
-					}
-				} else if (!strcasecmp(argv[1], "list")) {
-					char *d = ";";
+    if (http) {
+        /* Output must be to a web browser */
+        stream->write_function(stream, "<pre>\n");
+    }
 
-					if (argv[2]) {
-						if (argv[3] && !strcasecmp(argv[2], "delim")) {
-							d = argv[3];
+    if (!(lbuf = strdup(buf))) {
+        return status;
+    }
 
-							if (*d == '"') {
-								if (++d) {
-									char *p;
-									if ((p = strchr(d, '"'))) {
-										*p = '\0';
-									}
-								} else {
-									d = ";";
-								}
-							}
-						}
-					}
-					conference_list(conference, stream, d);
-				} else {
-					stream->write_function(stream, "Command: %s not found.\n", argv[1]);
-					goto done;
-				}
+    argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
 
-			} else {
-				stream->write_function(stream, "Command not specified.\n");
-				goto done;
-			}
-		} else {
-			stream->write_function(stream, "USAGE: %s\n", conf_api_interface.syntax);
-		}
-	} else {
-		stream->write_function(stream, "Memory Error!\n");
-	}
+    /* try to find a command to execute */
+    if (argc) {
+        conference_obj_t *conference = NULL;
 
- done:
+        if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, 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");
+            }
 
+            if (argc >= 2) {
+                status = conf_api_dispatch(conference, stream, argc, argv, (const char *)buf, 1);
+            } else {
+                stream->write_function(stream, "Conference command, not specified.\nTry 'help'\n");
+            }
+
+            switch_thread_rwlock_unlock(conference->rwlock);
+
+        } else {
+            /* 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], "help") == 0 || strcasecmp(argv[0], "commands") == 0) {
+                stream->write_function(stream, "%s\n", conf_api_interface.syntax);
+            } else {
+                stream->write_function(stream, "Conference %s not found\n", argv[0]);
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Conference %s not found\n", argv[0]);
+            }
+        }
+
+    } else {
+        stream->write_function(stream, "No parameters specified.\nTry 'help conference'\n");
+    }
+    
     switch_safe_free(lbuf);
-	if (pool) {
-		switch_core_destroy_memory_pool(&pool);
-	}
-	return status;
 
+    return status;
+
 }
 
 /* outbound call bridge progress call state callback handler */
 static switch_status_t audio_bridge_on_ring(switch_core_session_t *session)
 {
-	switch_channel_t *channel = NULL;
+    switch_channel_t *channel = NULL;
 
-	channel = switch_core_session_get_channel(session);
-	assert(channel != NULL);
+    channel = switch_core_session_get_channel(session);
+    assert(channel != NULL);
 
-	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CUSTOM RING\n");
+    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CUSTOM RING\n");
 
-	/* put the channel in a passive state so we can loop audio to it */
-	switch_channel_set_state(channel, CS_TRANSMIT);
-	return SWITCH_STATUS_FALSE;
+    /* put the channel in a passive state so we can loop audio to it */
+    switch_channel_set_state(channel, CS_TRANSMIT);
+    return SWITCH_STATUS_FALSE;
 }
 
 static const switch_state_handler_table_t audio_bridge_peer_state_handlers = {
-	/*.on_init */ NULL,
-	/*.on_ring */ audio_bridge_on_ring,
-	/*.on_execute */ NULL,
-	/*.on_hangup */ NULL,
-	/*.on_loopback */ NULL,
-	/*.on_transmit */ NULL,
-	/*.on_hold */ NULL,
+    /*.on_init */ NULL, 
+    /*.on_ring */ audio_bridge_on_ring, 
+    /*.on_execute */ NULL, 
+    /*.on_hangup */ NULL, 
+    /*.on_loopback */ NULL, 
+    /*.on_transmit */ NULL, 
+    /*.on_hold */ NULL, 
 };
 
 /* generate an outbound call from the conference */
-static switch_status_t conference_outcall(conference_obj_t *conference,
-										  switch_core_session_t *session,
-										  char *bridgeto,
-										  uint32_t timeout,
-										  char *flags,
-										  char *cid_name,
-										  char *cid_num)
+static switch_status_t conference_outcall(conference_obj_t *conference, 
+                                          switch_core_session_t *session, 
+                                          char *bridgeto, 
+                                          uint32_t timeout, 
+                                          char *flags, 
+                                          char *cid_name, 
+                                          char *cid_num)
 {
-	switch_core_session_t *peer_session;
-	switch_channel_t *peer_channel;
-	switch_status_t status = SWITCH_STATUS_SUCCESS;
-	switch_channel_t *caller_channel = NULL;
-	char appdata[512];
-	switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
+    switch_core_session_t *peer_session;
+    switch_channel_t *peer_channel;
+    switch_status_t status = SWITCH_STATUS_SUCCESS;
+    switch_channel_t *caller_channel = NULL;
+    char appdata[512];
+    switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
 
 
-	if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Read Lock Fail\n");
-		return SWITCH_STATUS_FALSE;
-	}
+    if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Read Lock Fail\n");
+        return SWITCH_STATUS_FALSE;
+    }
 
-	if (session) {
-		caller_channel = switch_core_session_get_channel(session);
+    if (session != NULL) {
+        caller_channel = switch_core_session_get_channel(session);
 	
-	}
+    }
 
-	/* establish an outbound call leg */
-	if (switch_ivr_originate(session,
-							 &peer_session,
-							 &cause,
-							 bridgeto,
-							 timeout,
-							 &audio_bridge_peer_state_handlers,
-							 cid_name,
-							 cid_num,
-							 NULL) != SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, 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;
-	} 
+    if (switch_strlen_zero(cid_name)) {
+        cid_name = conference->caller_id_name;
+    }
 
+    if (switch_strlen_zero(cid_num)) {
+        cid_num = conference->caller_id_number;
+    }
 
-	peer_channel = switch_core_session_get_channel(peer_session);
-	assert(peer_channel != NULL);
+    /* establish an outbound call leg */
+    if (switch_ivr_originate(session, 
+                             &peer_session, 
+                             &cause, 
+                             bridgeto, 
+                             timeout, 
+                             &audio_bridge_peer_state_handlers, 
+                             cid_name, 
+                             cid_num, 
+                             NULL) != SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, 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;
+    } 
 
-	/* make sure the conference still exists */
-	if (!switch_test_flag(conference, CFLAG_RUNNING)) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, 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);
-	}
+    peer_channel = switch_core_session_get_channel(peer_session);
+    assert(peer_channel != NULL);
 
-	/* 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;
+    /* make sure the conference still exists */
+    if (!switch_test_flag(conference, CFLAG_RUNNING)) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, 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;
+    }
 
-		/* build an extension name object */
-		if ((extension = switch_caller_extension_new(peer_session, conference->name, conference->name)) == 0) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "memory error!\n");
-			status = SWITCH_STATUS_MEMERR;
-			goto done;
-		}
-		/* add them to the conference */
-		if (flags && strcasecmp(flags, "none")) {
-			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);
-		}
+    if (caller_channel && switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
+        switch_channel_answer(caller_channel);
+    }
 
-		switch_channel_set_caller_extension(peer_channel, extension);
-		switch_channel_set_state(peer_channel, CS_EXECUTE);
+    /* 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;
 
-	} else {
-		switch_channel_hangup(peer_channel, SWITCH_CAUSE_NO_ANSWER);
-		status = SWITCH_STATUS_FALSE;
-		goto done;
-	}
+        /* build an extension name object */
+        if ((extension = switch_caller_extension_new(peer_session, conference->name, conference->name)) == 0) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "memory error!\n");
+            status = SWITCH_STATUS_MEMERR;
+            goto done;
+        }
+        /* add them to the conference */
+        if (flags && strcasecmp(flags, "none")) {
+            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);
+        }
 
-done:
-	switch_thread_rwlock_unlock(conference->rwlock);
-	return status;
+        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:
+    switch_thread_rwlock_unlock(conference->rwlock);
+    return status;
 }
 
 /* Play a file */
 static switch_status_t conference_local_play_file(switch_core_session_t *session, char *path, uint32_t leadin, char *buf, switch_size_t len)
 {
-	uint32_t x = 0;
-	switch_status_t status = SWITCH_STATUS_SUCCESS;
+    uint32_t x = 0;
+    switch_status_t status = SWITCH_STATUS_SUCCESS;
 
-	/* generate some space infront of the file to be played */
-	for (x = 0; x < leadin; x++) {
-		switch_frame_t *read_frame;
-		switch_status_t status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+    /* generate some space infront of the file to be played */
+    for (x = 0; x < leadin; x++) {
+        switch_frame_t *read_frame;
+        switch_status_t status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
 
-		if (!SWITCH_READ_ACCEPTABLE(status)) {
-			break;
-		}
-	}
+        if (!SWITCH_READ_ACCEPTABLE(status)) {
+            break;
+        }
+    }
 
-	/* if all is well, really play the file */
-	if (status == SWITCH_STATUS_SUCCESS) {
-		status = switch_ivr_play_file(session, NULL, path, NULL, NULL, NULL, 0);
-	}
+    /* if all is well, really play the file */
+    if (status == SWITCH_STATUS_SUCCESS) {
+        status = switch_ivr_play_file(session, NULL, path, NULL, NULL, NULL, 0);
+    }
 
-	return status;
+    return status;
 }
 
 /* Application interface function that is called from the dialplan to join the channel to a conference */
 static void conference_function(switch_core_session_t *session, char *data)
 {
-	switch_codec_t *read_codec = NULL;
-	switch_memory_pool_t *pool = NULL, *freepool = NULL;
-	uint32_t flags = 0;
-	conference_member_t member = {0};
-	conference_obj_t *conference = NULL;
-	switch_channel_t *channel = NULL;
-	char *mydata = switch_core_session_strdup(session, data);
-	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, profile = NULL, profiles = NULL;
-	char *flags_str;
-	member_flag_t uflags = MFLAG_CAN_SPEAK | MFLAG_CAN_HEAR;
-	switch_core_session_message_t msg = {0};
-	uint8_t rl = 0, isbr = 0;
-	char *dpin = NULL;
+    switch_codec_t *read_codec = NULL;
+    switch_memory_pool_t *pool = NULL, *freepool = NULL;
+    uint32_t flags = 0;
+    conference_member_t member = {0};
+    conference_obj_t *conference = NULL;
+    switch_channel_t *channel = NULL;
+    char *mydata = switch_core_session_strdup(session, data);
+    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;
+    char *flags_str;
+    member_flag_t uflags = MFLAG_CAN_SPEAK | MFLAG_CAN_HEAR;
+    switch_core_session_message_t msg = {0};
+    uint8_t rl = 0, isbr = 0;
+    char *dpin = NULL;
+    conf_xml_cfg_t xml_cfg = {0};
 
-	channel = switch_core_session_get_channel(session);
-	assert(channel != NULL);
+    channel = switch_core_session_get_channel(session);
+    assert(channel != NULL);
 
-	if (!mydata) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
-		return;
-	}
+    if (!mydata) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
+        return;
+    }
 
-	/* 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;
-	}
+    /* 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;
+    }
 
-	/* Start the conference muted or deaf ? */
-	if ((flags_str=strstr(mydata, flags_prefix))) {
-		char *p;
+    /* Start the conference muted or deaf ? */
+    if ((flags_str = strstr(mydata, flags_prefix))) {
+        char *p;
 
-		*flags_str = '\0';
-		flags_str += strlen(flags_prefix);
-		if ((p = strchr(flags_str, '}'))) {
-			*p = '\0';
-		}
+        *flags_str = '\0';
+        flags_str += strlen(flags_prefix);
+        if ((p = strchr(flags_str, '}'))) {
+            *p = '\0';
+        }
 
-		if (strstr(flags_str, "mute")) {
-			uflags &= ~MFLAG_CAN_SPEAK;
-		} else if (strstr(flags_str, "deaf")) {
-			uflags &= ~MFLAG_CAN_HEAR;
-		}
-	}
+        if (strstr(flags_str, "mute")) {
+            uflags &= ~MFLAG_CAN_SPEAK;
+        } else if (strstr(flags_str, "deaf")) {
+            uflags &= ~MFLAG_CAN_HEAR;
+        }
+    }
 
-	/* 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_LOG, SWITCH_LOG_CRIT, "Config Error!\n");
-			goto done;
-		}
-	}
+    /* 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_LOG, SWITCH_LOG_CRIT, "Config Error!\n");
+            goto done;
+        }
+    }
 
-	conf_name = mydata;
+    conf_name = mydata;
 
-	/* is there a conference pin ? */
-	if ((dpin = strchr(conf_name, '+'))) {
-		*dpin++ = '\0';
-	}
+    /* 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';
+    /* is there profile specification ? */
+    if ((profile_name = strchr(conf_name, '@'))) {
+        *profile_name++ = '\0';
 
-		/* Open the config from the xml registry */
-		if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", global_cf_name);
-			goto done;
-		}
+        /* Open the config from the xml registry */
+        if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) {
+            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"))) {
-			profile = switch_xml_find_child(profiles, "profile", "name", profile_name);
-		}
-	} 
+        if ((profiles = switch_xml_child(cfg, "profiles"))) {
+            xml_cfg.profile = switch_xml_find_child(profiles, "profile", "name", profile_name);
+        }
 
-	/* if this is a bridging call, and it's not a duplicate, build a */
-	/* conference object, and skip pin handling, and locked checking */
-	if (isbr) {
-		char *uuid = switch_core_session_get_uuid(session);
+        xml_cfg.controls = switch_xml_child(cfg, "caller-controls");
+#ifdef OPTION_IVR_MENU_SUPPORT
+        xml_cfg.menus = switch_xml_child(cfg, "menus");
+#endif
+    } 
 
-		if (!strcmp(conf_name, "_uuid_")) {
-			conf_name = uuid;
-		}
+    /* if this is a bridging call, and it's not a duplicate, build a */
+    /* conference object, and skip pin handling, and locked checking */
+    if (isbr) {
+        char *uuid = switch_core_session_get_uuid(session);
 
-		if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Conference %s already exists!\n", conf_name);
-			goto done;
-		}
+        if (!strcmp(conf_name, "_uuid_")) {
+            conf_name = uuid;
+        }
 
-		/* Create the conference object. */
-		conference = conference_new(conf_name, profile, pool);
+        if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Conference %s already exists!\n", conf_name);
+            goto done;
+        }
 
-		if (!conference) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
-			goto done;
-		}
+        /* Create the conference object. */
+        conference = conference_new(conf_name, xml_cfg, pool);
 
-		/* Set the minimum number of members (once you go above it you cannot go below it) */
-		conference->min = 2;
+        if (!conference) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
+            goto done;
+        }
 
-		/* if the dialplan specified a pin, override the profile's value */
-		if (dpin) {
-			conference->pin = switch_core_strdup(conference->pool, dpin);
-		}
+        /* 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);	
+        /* if the dialplan specified a pin, override the profile's value */
+        if (dpin) {
+            conference->pin = switch_core_strdup(conference->pool, dpin);
+        }
 
-		/* Start the conference thread for this conference */
-		launch_conference_thread(conference);
+        /* Indicate the conference is dynamic */
+        switch_set_flag_locked(conference, CFLAG_DYNAMIC);	
 
-	} else {
-		/* if the conference exists, get the pointer to it */
-		if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) {
-			freepool = pool;
-		/* couldn't find the conference, create one */
-		} else {
-			conference = conference_new(conf_name, profile, pool);
+        /* Start the conference thread for this conference */
+        launch_conference_thread(conference);
 
-			if (!conference) {
-				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
-				goto done;
-			}
+    } else {
+        /* if the conference exists, get the pointer to it */
+        if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) {
+            freepool = pool;
+            /* couldn't find the conference, create one */
+        } else {
+            conference = conference_new(conf_name, xml_cfg, pool);
 
-			/* if the dialplan specified a pin, override the profile's value */
-			if (dpin) {
-				conference->pin = switch_core_strdup(conference->pool, dpin);
-			}
+            if (!conference) {
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
+                goto done;
+            }
 
-			/* Set the minimum number of members (once you go above it you cannot go below it) */
-			conference->min = 1;
+            /* if the dialplan specified a pin, override the profile's value */
+            if (dpin) {
+                conference->pin = switch_core_strdup(conference->pool, dpin);
+            }
 
-			/* Indicate the conference is dynamic */
-			switch_set_flag_locked(conference, CFLAG_DYNAMIC);
+            /* Set the minimum number of members (once you go above it you cannot go below it) */
+            conference->min = 1;
 
-			/* Start the conference thread for this conference */
-			launch_conference_thread(conference);
-		}
+            /* Indicate the conference is dynamic */
+            switch_set_flag_locked(conference, CFLAG_DYNAMIC);
 
+            /* Start the conference thread for this conference */
+            launch_conference_thread(conference);
+        }
+
         /* 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_LOG, SWITCH_LOG_CRIT, "Read Lock Fail\n");
@@ -2955,216 +3501,215 @@
         }
         rl++;
         
-		/* if this is not an outbound call, deal with conference pins */
-		if (!switch_channel_test_flag(channel, CF_OUTBOUND) && conference->pin) {
-			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;
+        /* if this is not an outbound call, deal with conference pins */
+        if (!switch_channel_test_flag(channel, CF_OUTBOUND) && conference->pin) {
+            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;
 
-			/* Answer the channel */
-			switch_channel_answer(channel);
+            /* Answer the channel */
+            switch_channel_answer(channel);
 
-			while(!pin_valid && pin_retries && status == SWITCH_STATUS_SUCCESS) {
+            while(!pin_valid && pin_retries && status == SWITCH_STATUS_SUCCESS) {
 
-				/* be friendly */
-				if (conference->pin_sound) {
-					conference_local_play_file(session, conference->pin_sound, 20, pin_buf, sizeof(pin_buf));
-				} 
-				/* wait for them if neccessary */
-				if (strlen(pin_buf) < strlen(conference->pin)) {
-					char *buf = pin_buf + strlen(pin_buf);
-					char term = '\0';
+                /* be friendly */
+                if (conference->pin_sound) {
+                    conference_local_play_file(session, conference->pin_sound, 20, pin_buf, sizeof(pin_buf));
+                } 
+                /* wait for them if neccessary */
+                if (strlen(pin_buf) < strlen(conference->pin)) {
+                    char *buf = pin_buf + strlen(pin_buf);
+                    char term = '\0';
 
-					status = switch_ivr_collect_digits_count(session,
-												buf,
-												sizeof(pin_buf) - (unsigned int)strlen(pin_buf),
-												(unsigned int)strlen(conference->pin) - (unsigned int)strlen(pin_buf),
-												"#", &term, 10000);
-				}
+                    status = switch_ivr_collect_digits_count(session, 
+                                                             buf, 
+                                                             sizeof(pin_buf) - (unsigned int)strlen(pin_buf), 
+                                                             (unsigned int)strlen(conference->pin) - (unsigned int)strlen(pin_buf), 
+                                                             "#", &term, 10000);
+                }
 
-				pin_valid = (status == SWITCH_STATUS_SUCCESS && strcmp(pin_buf, conference->pin) == 0);
-				if (!pin_valid) {
-					/* zero the collected pin */
-					memset(pin_buf,0,sizeof(pin_buf));
+                pin_valid = (status == SWITCH_STATUS_SUCCESS && strcmp(pin_buf, conference->pin) == 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(session, conference->bad_pin_sound, 20, pin_buf, sizeof(pin_buf));
-					}
-				}
-				pin_retries --;
-			}
+                    /* more friendliness */
+                    if (conference->bad_pin_sound) {
+                        conference_local_play_file(session, conference->bad_pin_sound, 20, pin_buf, sizeof(pin_buf));
+                    }
+                }
+                pin_retries --;
+            }
 
-			if (!pin_valid) {
-				goto done;
-			}
-		}
+            if (!pin_valid) {
+                goto done;
+            }
+        }
 
-		/* don't allow more callers if the conference is locked, unless we invited them */
-		if (switch_test_flag(conference, CFLAG_LOCKED) && !switch_channel_test_flag(channel, CF_OUTBOUND)) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, 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(session, conference->locked_sound, 20, NULL, 0);
-			}
-			goto done;
-		}
-	}
+        /* don't allow more callers if the conference is locked, unless we invited them */
+        if (switch_test_flag(conference, CFLAG_LOCKED) && !switch_channel_test_flag(channel, CF_OUTBOUND)) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, 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(session, conference->locked_sound, 20, NULL, 0);
+            }
+            goto done;
+        }
+    }
 
-	/* Release the config registry handle */
-	if (cxml) {
-		switch_xml_free(cxml);
-		cxml = NULL;
-	}
+    /* 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 (!switch_strlen_zero(bridgeto) && strcasecmp(bridgeto, "none")) {
-		if (conference_outcall(conference, session, bridgeto, 60, NULL, NULL, NULL) != 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);
-	}
+    /* if we're using "bridge:" make an outbound call and bridge it in */
+    if (!switch_strlen_zero(bridgeto) && strcasecmp(bridgeto, "none")) {
+        if (conference_outcall(conference, session, bridgeto, 60, NULL, NULL, NULL) != 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);
+    }
 
-	/* Save the original read codec. */
-	read_codec = switch_core_session_get_read_codec(session);
-	member.native_rate = read_codec->implementation->samples_per_second;
+    /* Save the original read codec. */
+    read_codec = switch_core_session_get_read_codec(session);
+    member.native_rate = read_codec->implementation->samples_per_second;
 
-	/* Setup a Signed Linear codec for reading audio. */
-	if (switch_core_codec_init(&member.read_codec,
-							   "L16",
-							   NULL,
-							   read_codec->implementation->samples_per_second,
-							   read_codec->implementation->microseconds_per_frame / 1000,
-							   1,
-							   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
-							   NULL,
-							   pool) == SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
-						  conference->rate, conference->interval);
-	} else {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n",
-						  conference->rate, conference->interval);
-		flags = 0;
-		goto done;
-	}
+    /* Setup a Signed Linear codec for reading audio. */
+    if (switch_core_codec_init(&member.read_codec, 
+                               "L16", 
+                               NULL, 
+                               read_codec->implementation->samples_per_second, 
+                               read_codec->implementation->microseconds_per_frame / 1000, 
+                               1, 
+                               SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, 
+                               NULL, 
+                               pool) == SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Success L16@%uhz 1 channel %dms\n", 
+                          conference->rate, conference->interval);
+    } else {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n", 
+                          conference->rate, conference->interval);
+        flags = 0;
+        goto done;
+    }
 
-	if (read_codec->implementation->samples_per_second != conference->rate) {
-		switch_audio_resampler_t **resampler = read_codec->implementation->samples_per_second > conference->rate ? 
-			&member.read_resampler : &member.mux_resampler;
+    if (read_codec->implementation->samples_per_second != conference->rate) {
+        switch_audio_resampler_t **resampler = read_codec->implementation->samples_per_second > conference->rate ? 
+            &member.read_resampler : &member.mux_resampler;
 
-		switch_resample_create(resampler,
-							   read_codec->implementation->samples_per_second,
-							   read_codec->implementation->samples_per_second * 20,
-							   conference->rate,
-							   conference->rate * 20,
-							   switch_core_session_get_pool(session));
+        switch_resample_create(resampler, 
+                               read_codec->implementation->samples_per_second, 
+                               read_codec->implementation->samples_per_second * 20, 
+                               conference->rate, 
+                               conference->rate * 20, 
+                               switch_core_session_get_pool(session));
 
-		/* 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_LOG, 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,
-							   conference->interval,
-							   1,
-							   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
-							   NULL,
-							   pool) == SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
-						  conference->rate, conference->interval);
-	} else {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n",
-						  conference->rate, conference->interval);
-		flags = 0;
-		goto codec_done2;
-	}
+        /* 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_LOG, 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, 
+                               conference->interval, 
+                               1, 
+                               SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, 
+                               NULL, 
+                               pool) == SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Success L16@%uhz 1 channel %dms\n", 
+                          conference->rate, conference->interval);
+    } else {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n", 
+                          conference->rate, conference->interval);
+        flags = 0;
+        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_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
-		goto codec_done1;
-	}
+    /* 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_LOG, 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_LOG, 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_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n");
+        goto codec_done1;
+    }
 
+    /* Prepare MUTEXS */
+    member.id = next_member_id();
+    member.pool = pool;
+    member.session = session;
+    switch_mutex_init(&member.flag_mutex, SWITCH_MUTEX_NESTED, pool);
+    switch_mutex_init(&member.audio_in_mutex, SWITCH_MUTEX_NESTED, pool);
+    switch_mutex_init(&member.audio_out_mutex, SWITCH_MUTEX_NESTED, pool);
 
-	/* Prepare MUTEXS */
-	member.id = next_member_id();
-	member.pool = pool;
-	member.session = session;
-	switch_mutex_init(&member.flag_mutex, SWITCH_MUTEX_NESTED, pool);
-	switch_mutex_init(&member.audio_in_mutex, SWITCH_MUTEX_NESTED, pool);
-	switch_mutex_init(&member.audio_out_mutex, SWITCH_MUTEX_NESTED, 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);
 
-	/* Install our Signed Linear codec so we get the audio in that format */
-	switch_core_session_set_read_codec(member.session, &member.read_codec);
+    /* Add the caller to the conference */
+    if (conference_add_member(conference, &member) != SWITCH_STATUS_SUCCESS) {
+        goto codec_done1;
+    }
+    switch_set_flag_locked((&member), MFLAG_RUNNING | uflags);
 
-	/* Add the caller to the conference */
-	if (conference_add_member(conference, &member) != SWITCH_STATUS_SUCCESS) {
-		goto codec_done1;
-	}
-	switch_set_flag_locked((&member), MFLAG_RUNNING | uflags);
+    msg.from = __FILE__;
 
-	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);
 
-	/* 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);
 
-	/* Run the confernece loop */
-	conference_loop(&member);
+    /* 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);
 
-	/* 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.last_conference, &member);
 
-	/* Remove the caller from the conference */
-	conference_del_member(member.last_conference, &member);
+    /* Put the original codec back */
+    switch_core_session_set_read_codec(member.session, read_codec);
 
-	/* Put the original codec back */
-	switch_core_session_set_read_codec(member.session, read_codec);
+    /* Clean Up.  codec_done(X): is for error situations after the codecs were setup and done: is for situations before */
+ codec_done1:
+    switch_core_codec_destroy(&member.read_codec);
+ codec_done2:
+    switch_core_codec_destroy(&member.write_codec);
+ done:
 
-	/* Clean Up.  codec_done(X): is for error situations after the codecs were setup and done: is for situations before */
-codec_done1:
-	switch_core_codec_destroy(&member.read_codec);
-codec_done2:
-	switch_core_codec_destroy(&member.write_codec);
-done:
+    switch_buffer_destroy(&member.resample_buffer);
+    switch_buffer_destroy(&member.audio_buffer);
+    switch_buffer_destroy(&member.mux_buffer);
 
-	switch_buffer_destroy(&member.resample_buffer);
-	switch_buffer_destroy(&member.audio_buffer);
-	switch_buffer_destroy(&member.mux_buffer);
+    /* Release the config registry handle */
+    if (cxml) {
+        switch_xml_free(cxml);
+    }
 
-	/* Release the config registry handle */
-	if (cxml) {
-		switch_xml_free(cxml);
-	}
+    if (freepool) {
+        switch_core_destroy_memory_pool(&freepool);
+    }
 
-	if (freepool) {
-		switch_core_destroy_memory_pool(&freepool);
-	}
+    if (switch_test_flag(&member, MFLAG_KICKED) && conference->kicked_sound) {
+        switch_ivr_play_file(session, NULL, conference->kicked_sound, NULL, NULL, NULL, 0);
+    }
 
-	if (switch_test_flag(&member, MFLAG_KICKED) && conference->kicked_sound) {
-		switch_ivr_play_file(session, NULL, conference->kicked_sound, NULL, NULL, NULL, 0);
-	}
+    switch_core_session_reset(session);
 
-	switch_core_session_reset(session);
-
     /* release the readlock */
     if (rl) {
         switch_thread_rwlock_unlock(conference->rwlock);
@@ -3174,655 +3719,815 @@
 /* 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_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_core_hash_insert(globals.conference_hash, conference->name, conference);
-	switch_mutex_unlock(globals.hash_mutex);
-	switch_thread_create(&thread, thd_attr, conference_thread_run, conference, conference->pool);
+    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_core_hash_insert(globals.conference_hash, conference->name, conference);
+    switch_mutex_unlock(globals.hash_mutex);
+    switch_thread_create(&thread, thd_attr, conference_thread_run, conference, conference->pool);
 }
 
 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;
+    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");
-	}
+    /* 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);
-	}
+    /* 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);
+    }
 
-	rec->conference = conference;
-	rec->path = switch_core_strdup(pool, path);
-	rec->pool = pool;
+    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);
+    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 void *SWITCH_THREAD_FUNC input_thread_run(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;
-	switch_codec_t *read_codec;
-	uint32_t hangover = 40,
-		hangunder = 15,
-		hangover_hits = 0,
-		hangunder_hits = 0,
-		energy_level = 0,
-		diff_level = 400;
-	uint8_t talking = 0;
+static const switch_application_interface_t conference_application_interface = {
+    /*.interface_name */ global_app_name, 
+    /*.application_function */ conference_function, 
+    NULL, NULL, NULL, 
+    /*.next*/ NULL
+};
 
-	assert(member != NULL);
+static switch_api_interface_t conf_api_interface = {
+    /*.interface_name */	"conference", 
+    /*.desc */				"Conference module commands", 
+    /*.function */			conf_api_main, 
+    /*.syntax */		/* see switch_module_load, this is built on the fly */
+    /*.next */ 
+};
 
-	channel = switch_core_session_get_channel(member->session);
-	assert(channel != NULL);
+static switch_status_t chat_send(char *proto, char *from, char *to, char *subject, char *body, char *hint)
+{
+    char name[512] = "", *p, *lbuf;
+    switch_chat_interface_t *ci;
+    conference_obj_t *conference = NULL;
+    switch_stream_handle_t stream = {0};
 
-	read_codec = switch_core_session_get_read_codec(member->session);
-	assert(read_codec != NULL);
+    if ((p = strchr(to, '+'))) {
+        to = ++p;
+    }
 
-	/* 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. */
+    if (!body) {
+        return SWITCH_STATUS_SUCCESS;
+    }
 
-	while(switch_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {
-		/* Read a frame. */
-		status = switch_core_session_read_frame(member->session, &read_frame, -1, 0);
+    if (!(ci = switch_loadable_module_get_chat_interface(proto))) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invaid Chat Interface [%s]!\n", proto);
+    }
 
-		/* end the loop, if appropriate */
-		if (!SWITCH_READ_ACCEPTABLE(status) || !switch_test_flag(member, MFLAG_RUNNING)) {
-			break;
-		}
 
-		if (switch_test_flag(read_frame, SFF_CNG)) {
-			continue;
-		}
+    if ((p = strchr(to, '@'))) {
+        switch_copy_string(name, to, ++p-to);
+    } else {
+        switch_copy_string(name, to, sizeof(name));
+    }
 
-		energy_level = member->energy_level;
+    if (!(conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, name))) {
+        ci->chat_send(CONF_CHAT_PROTO, to, hint && strchr(hint, '/') ? hint : from, "", "Conference not active.", NULL);
+        return SWITCH_STATUS_FALSE;
+    }
 
-		if (switch_test_flag(member, MFLAG_CAN_SPEAK) && energy_level) {
-			uint32_t energy = 0, i = 0, samples = 0, j = 0, score = 0;
-			int16_t *data;
+    SWITCH_STANDARD_STREAM(stream);
 
-			data = read_frame->data;
-			if ((samples = read_frame->datalen / sizeof(*data))) {
+    if (body != NULL && (lbuf = strdup(body))) {
+        int argc;
+        char *argv[25];
 
-                for (i = 0; i < samples; i++) {
-                    energy += abs(data[j]);
-                    j += read_codec->implementation->number_of_channels;
-                }
+        memset(argv, 0, sizeof(argv));
+        argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
 
-                score = energy / samples;
+        /* try to find a command to execute */
+        if (argc) {
+            /* special case list */
+            if (strcasecmp(argv[0], "list") == 0) {
+                conference_list_pretty(conference, &stream);
+                /* provide help */
+            } else if (strcasecmp(argv[0], "help") == 0 || strcasecmp(argv[0], "commands") == 0) {
+                stream.write_function(&stream, "%s\n", conf_api_interface.syntax);
+                /* find a normal command */
+            } else {
+                conf_api_dispatch(conference, &stream, argc, argv, (const char *)body, 0);
             }
+        } else {
+            stream.write_function(&stream, "No parameters specified.\nTry 'help'\n");
+        }
+    }
+    switch_safe_free(lbuf);
 
-			if (score > energy_level) {
-				uint32_t diff = score - energy_level;
-				if (hangover_hits) {
-					hangover_hits--;
-				}
+    ci->chat_send(CONF_CHAT_PROTO, to, from, "", stream.data, NULL);
+    switch_safe_free(stream.data);
 
-				if (diff >= diff_level || ++hangunder_hits >= hangunder) {
-					hangover_hits = hangunder_hits = 0;
+    return SWITCH_STATUS_SUCCESS;
+}
 
-					if (!talking) {
-						switch_event_t *event;
-						talking = 1;		
-						if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-							switch_channel_event_set_data(channel, event);
-							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "start-talking");
-							switch_event_fire(&event);
-						}
-					}
-				} 
-			} else {
-				if (hangunder_hits) {
-					hangunder_hits--;
-				}
-				if (talking) {
-					switch_event_t *event;
-					if (++hangover_hits >= hangover) {
-						hangover_hits = hangunder_hits = 0;
-						talking = 0;
+static const switch_chat_interface_t conference_chat_interface = {
+    /*.name */ CONF_CHAT_PROTO, 
+    /*.chat_send */ chat_send, 
 
-						if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
-							switch_channel_event_set_data(channel, event);
-							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name);
-							switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
-							switch_event_add_header(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 ((talking || energy_level == 0) && switch_test_flag(member, MFLAG_CAN_SPEAK)) {
-			if (member->read_resampler) {
-				int16_t *bptr = (int16_t *) read_frame->data;
-				int len = (int) read_frame->datalen;;
+static switch_loadable_module_interface_t conference_module_interface = {
+    /*.module_name */ modname, 
+    /*.endpoint_interface */ NULL, 
+    /*.timer_interface */ NULL, 
+    /*.dialplan_interface */ NULL, 
+    /*.codec_interface */ NULL, 
+    /*.application_interface */ &conference_application_interface, 
+    /*.api_interface */ &conf_api_interface, 
+    /*.file_interface */ NULL, 
+    /*.speech_interface */ NULL, 
+    /*.directory_interface */ NULL, 
+    /*.chat_interface */ &conference_chat_interface
+};
 
-				member->read_resampler->from_len = switch_short_to_float(bptr, member->read_resampler->from, (int) len / 2);
-				member->read_resampler->to_len = switch_resample_process(member->read_resampler, member->read_resampler->from,
-																		 member->read_resampler->from_len, member->read_resampler->to,
-																		 member->read_resampler->to_size, 0);
-				switch_float_to_short(member->read_resampler->to, read_frame->data, len);
-				len = member->read_resampler->to_len * 2;
-				read_frame->datalen = len;
-				read_frame->samples = len / 2;
-			}
-			/* Check for input volume adjustments */
-			if (member->volume_in_level) {
-				switch_change_sln_volume(read_frame->data, read_frame->datalen / 2, member->volume_in_level);
-			}
+#ifdef OPTION_IVR_MENU_SUPPORT
+static switch_ivr_action_t conference_caller_control_menu_handler(switch_ivr_menu_t *menu, char *param, char *buf, size_t buflen, void *obj)
+{
+    switch_ivr_action_t action = SWITCH_IVR_ACTION_NOOP;
 
-			/* Write the audio into the input buffer */
-			switch_mutex_lock(member->audio_in_mutex);
-			switch_buffer_write(member->audio_buffer, read_frame->data, read_frame->datalen);
-			switch_mutex_unlock(member->audio_in_mutex);
-		}
-	}
+    if (!switch_strlen_zero(param)) {
+        if (obj != NULL) {
+            int i, found;
+            char *action_name = strdup(param);
 
-	switch_clear_flag_locked(member, MFLAG_ITHREAD);
+            if (action_name != NULL) {
+                char *sep = (action_name != NULL ? strchr(action_name, ' ') : NULL);
 
-	return NULL;
-}
+                /* split the action from any parameters */
+                if (sep != NULL) {
+                    *sep  = '\0';
+                }
 
-/* Create a thread for the conference and launch it */
-static void launch_input_thread(conference_member_t *member, switch_memory_pool_t *pool)
-{
-	switch_thread_t *thread;
-	switch_threadattr_t *thd_attr = NULL;
+                /* find and execute the caller control handler */
+                for(i = 0, found = 0; !found && i<CCFNTBL_QTY; i++) {
+                    found = (ccfntbl[i].action != CALLER_CONTROL_MENU && strcasecmp(ccfntbl[i].key, action_name) == 0);
+                    if (found) {
+                        if (obj != NULL) {
+                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "invoking caller control menu action '%s'\n", ccfntbl[i].key);
+                            ccfntbl[i].handler((conference_member_t *)obj, (sep != NULL ? sep+1 : NULL));
+                            if (ccfntbl[i].action == CALLER_CONTROL_HANGUP) {
+                                action = SWITCH_IVR_ACTION_DIE;
+                            }
+                        }
+                    }
+                }
 
-	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, input_thread_run, member, pool);
+                free(action_name);
+            }
+
+            if (!found) {
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unknown caller control menu action '%s'\n", param);
+            }
+        } else {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unable to invoke caller control menu action '%s', NULL member!\n", param);
+        }
+    } else {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "NULL or empty param!\n");
+    }
+
+    return action;
 }
 
-static const switch_application_interface_t conference_application_interface = {
-	/*.interface_name */ global_app_name,
-	/*.application_function */ conference_function,
-	NULL, NULL, NULL,
-	/*.next*/ NULL
-};
+/*
+  static switch_status_t ivr_menu_callback_play_file(char *file, uint32_t leadin, void *member)
+  {
+  switch_status_t status;
 
-static switch_api_interface_t conf_api_interface = {
-	/*.interface_name */ "conference",
-	/*.desc */ "Conference",
-	/*.function */ conf_function,
-	/*.syntax */ 
-		"list [delim <string>]\n"
-		"\t<confname> list [delim <string>]\n"
-		"\t<confname> energy <member_id|all> [<newval>]\n"
-		"\t<confname> volume_in <member_id|all> [<newval>]\n"
-		"\t<confname> volume_out <member_id|all> [<newval>]\n"
-		"\t<confname> play <file_path> [<member_id>]\n"
-		"\t<confname> say <text>\n"
-		"\t<confname> saymember <member_id> <text>\n"
-		"\t<confname> stop <[current|all]> [<member_id>]\n"
-		"\t<confname> kick <[member_id|all]>\n"
-		"\t<confname> mute <[member_id|all]>\n"
-		"\t<confname> unmute <[member_id|all]>\n"
-		"\t<confname> deaf <[member_id|all]>\n"
-		"\t<confname> undeaf <[member_id|all]>\n"
-		"\t<confname> relate <member_id> <other_member_id> [nospeak|nohear]\n"
-		"\t<confname> lock\n"
-		"\t<confname> unlock\n"
-		"\t<confname> dial <endpoint_module_name>/<destination>\n"
-		"\t<confname> transfer <conference_name> <member_id_1> [...<member_id_N>]\n"
-		"\t<confname> record <filename>\n"
-		"\t<confname> norecord <[filename|all]>\n",
-	/*.next */ 
-};
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "ivr_menu_callback_play_file\n");
+  status = conference_member_play_file((conference_member_t *)member, file, leadin);
+  if (status != SWITCH_STATUS_SUCCESS) {
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ivr_menu_callback_play_file ERROR\n");
+  }
 
-static switch_status_t chat_send(char *proto, char *from, char *to, char *subject, char *body, char *hint)
-{
-	char name[512] = "", *p;
-	switch_chat_interface_t *ci;
-	conference_obj_t *conference = NULL;
-	switch_stream_handle_t stream = {0};
+  return status;
+  }
 
-	if ((p = strchr(to, '+'))) {
-		to = ++p;
-	}
+  static switch_status_t ivr_menu_callback_say(char *file, uint32_t leadin, void *member)
+  {
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "ivr_menu_callback_say\n");
+  return conference_member_say((conference_member_t *)member, file, leadin);
+  }
+*/
 
-	if (!body) {
-		return SWITCH_STATUS_SUCCESS;
-	}
+static switch_status_t conference_caller_control_menu_build(caller_control_menu_ctx_t **ctx, 
+                                                            conference_obj_t *conference, 
+                                                            switch_xml_t menu_group, 
+                                                            char *menu_name)
+{
+    switch_status_t status = SWITCH_STATUS_FALSE;
+    switch_xml_t xml_menus;
+    switch_xml_t xml_menu;
 
-	if (!(ci = switch_loadable_module_get_chat_interface(proto))) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invaid Chat Interface [%s]!\n", proto);
-	}
+    assert(conference != NULL);
+    assert(ctx != NULL);
+    assert(menu_group != NULL);
+    assert(menu_name != NULL);
+    assert(xml_menus != NULL);
 
+    xml_menus = switch_xml_child(menu_group, "menus");
+    xml_menu = (xml_menus != NULL ? switch_xml_find_child(xml_menus, "menu", "name", menu_name) : NULL);
 
-	if ((p = strchr(to, '@'))) {
-		switch_copy_string(name, to, ++p-to);
-	} else {
-		switch_copy_string(name, to, sizeof(name));
-	}
 
-	if (!(conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, name))) {
-		ci->chat_send(CONF_CHAT_PROTO, to, hint && strchr(hint, '/') ? hint : from, "", "Sorry, We're Closed", NULL);
-		return SWITCH_STATUS_FALSE;
-	}
 
-	SWITCH_STANDARD_STREAM(stream);
+    /* if we found the requested menu in our menu_group */
+    if (xml_menu != NULL && xml_menu != NULL) {
+        *ctx = (caller_control_menu_ctx_t *)switch_core_alloc(conference->pool, sizeof(caller_control_menu_ctx_t));
 
-	if (strstr(body, "list")) {
-		conference_list_pretty(conference, &stream);
-	} else {
-		stream.write_function(&stream, "The only command we have so far is 'list'.\nGet coding or go press PayPal!!\n");
-	}
+        if (*ctx != NULL) {
+            memset(*ctx, 0, sizeof(caller_control_menu_ctx_t));
 
-	ci->chat_send(CONF_CHAT_PROTO, to, from, "", stream.data, NULL);
-	switch_safe_free(stream.data);
+            /* setup an xml parser context, and a menu stack context for the specified menu in our memory pool */
+            status = switch_ivr_menu_stack_xml_init(&(*ctx)->xml_ctx, conference->pool);
+            if (status == SWITCH_STATUS_SUCCESS) {
+                (*ctx)->name = switch_core_strdup(conference->pool, menu_name);
 
+                /* add our xml menu handler to the xml stack parser */
+                status = switch_ivr_menu_stack_xml_add_custom((*ctx)->xml_ctx, "control", &conference_caller_control_menu_handler);
+                if (status != SWITCH_STATUS_SUCCESS)
+                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unable to add custom xml handler\n");
 
+                /* parse the xml stack to build the menu stack */
+                status = switch_ivr_menu_stack_xml_build((*ctx)->xml_ctx, &(*ctx)->menu_stack, xml_menus, xml_menu, conference->timer_name);
+                if (status != SWITCH_STATUS_SUCCESS)
+                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unable to build xml menu stack\n");
 
-	return SWITCH_STATUS_SUCCESS;
+                /*
+                // instruct ivr menu to use our file play and tts routines
+                status = switch_ivr_menu_set_fileplay_callback((*ctx)->menu_stack, &ivr_menu_callback_play_file);
+                if (status != SWITCH_STATUS_SUCCESS)
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unable to set file play calback\n");
+                status = switch_ivr_menu_set_tts_callback((*ctx)->menu_stack, &ivr_menu_callback_say);
+                if (status != SWITCH_STATUS_SUCCESS)
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unable to set tts calback\n");
+                */
+            } else {
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unable to init xml menu context\n");
+            }
+            if (status != SWITCH_STATUS_SUCCESS)
+                *ctx = NULL;
+        }
+    } else {
+        if (xml_menus == NULL)
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "caller control menu unable to find xml menus\n");
+        if (xml_menu == NULL)
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "caller control menu unable to find xml menu '%s'\n", menu_name);
+    }
+
+    return status;
 }
+#endif
 
-static const switch_chat_interface_t conference_chat_interface = {
-	/*.name */ CONF_CHAT_PROTO,
-	/*.chat_send */ chat_send,
+static switch_status_t conference_new_install_caller_controls_default(conference_obj_t *conference)
+{
+    switch_status_t status = SWITCH_STATUS_FALSE;
+    uint32_t i;
+    caller_control_action_t *action;
 
-};
+    assert(conference != NULL);
 
-static switch_loadable_module_interface_t conference_module_interface = {
-	/*.module_name */ modname,
-	/*.endpoint_interface */ NULL,
-	/*.timer_interface */ NULL,
-	/*.dialplan_interface */ NULL,
-	/*.codec_interface */ NULL,
-	/*.application_interface */ &conference_application_interface,
-	/*.api_interface */ &conf_api_interface,
-	/*.file_interface */ NULL,
-	/*.speech_interface */ NULL,
-	/*.directory_interface */ NULL,
-	/*.chat_interface */ &conference_chat_interface
-};
+    for(i = 0, status = SWITCH_STATUS_SUCCESS; status == SWITCH_STATUS_SUCCESS && i<CCFNTBL_QTY; i++) {
+        if (!switch_strlen_zero(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;
+            }
+        }
+    }
+	
 
-/* create a new conferene with a specific profile */
-static conference_obj_t *conference_new(char *name, switch_xml_t profile, switch_memory_pool_t *pool)
+    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)
 {
-	conference_obj_t *conference;
-	switch_xml_t param;
-	char *rate_name = NULL;
-	char *interval_name = NULL;
-	char *timer_name = NULL;
-	char *domain = NULL;
-	char *tts_engine = NULL;
-	char *tts_voice = NULL;
-	char *enter_sound = NULL;
-	char *exit_sound = NULL;
-	char *alone_sound = NULL;
-	char *ack_sound = NULL;
-	char *nack_sound = NULL;
-	char *muted_sound = NULL;
-	char *unmuted_sound = NULL;
-	char *locked_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;
-	uint32_t rate = 8000, interval = 20;
-	switch_status_t status;
+    switch_status_t status = SWITCH_STATUS_FALSE;
+    switch_xml_t xml_kvp;
 
-	/* Validate the conference name */
-	if (switch_strlen_zero(name)) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Record! no name.\n");
-		return NULL;
-	}
+    assert(conference != NULL);
+    assert(xml_controls != NULL);
 
-	for (param = switch_xml_child(profile, "param"); param; param = param->next) {
-		char *var = (char *) switch_xml_attr_soft(param, "name");
-		char *val = (char *) switch_xml_attr_soft(param, "value");
-		char buf[128] = "";
-		char *p;
+    /* 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 ((p = strchr(var, '_'))) {
-			switch_copy_string(buf, var, sizeof(buf));
-			for(p = buf; *p; p++) {
-				if (*p == '_') {
-					*p = '-';
-				}
-			}
-			var = buf;
-		}
+        if (!switch_strlen_zero(key) && !switch_strlen_zero(val)) {
+            uint32_t i;
 
-		if (!strcasecmp(var, "rate")) {
-			rate_name = val;
-		} else if (!strcasecmp(var, "domain")) {
-			domain = val;
-		} else if (!strcasecmp(var, "interval")) {
-			interval_name= val;
-		} else if (!strcasecmp(var, "timer-name")) {
-			timer_name= val;
-		} else if (!strcasecmp(var, "tts-engine")) {
-			tts_engine= val;
-		} else if (!strcasecmp(var, "tts-voice")) {
-			tts_voice= val;
-		} else if (!strcasecmp(var, "enter-sound")) {
-			enter_sound = val;
-		} else if (!strcasecmp(var, "exit-sound")) {
-			exit_sound = val;
-		} else if (!strcasecmp(var, "alone-sound")) {
-			alone_sound = val;
-		} else if (!strcasecmp(var, "ack-sound")) {
-			ack_sound = val;
-		} else if (!strcasecmp(var, "nack-sound")) {
-			nack_sound = val;
-		} else if (!strcasecmp(var, "muted-sound")) {
-			muted_sound = val;
-		} else if (!strcasecmp(var, "unmuted-sound")) {
-			unmuted_sound = val;
-		} else if (!strcasecmp(var, "locked-sound")) {
-			locked_sound= val;
-		} else if (!strcasecmp(var, "kicked-sound")) {
-			kicked_sound = val;
-		} else if (!strcasecmp(var, "pin")) {
-			pin = val;
-		} else if (!strcasecmp(var, "pin-sound")) {
-			pin_sound = val;
-		} else if (!strcasecmp(var, "bad-pin-sound")) {
-			bad_pin_sound = val;
-		} else if (!strcasecmp(var, "energy-level")) {
-			energy_level = val;
-		} else if (!strcasecmp(var, "caller-id-name")) {
-			caller_id_name = val;
-		} else if (!strcasecmp(var, "caller-id-number")) {
-			caller_id_number = val;
-		}
-	}
+            /* 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++) {
 
-	/* Set defaults and various paramaters */
+                if (strcasecmp(ccfntbl[i].key, key) == 0) {
+                    status = SWITCH_STATUS_SUCCESS;
+#ifdef OPTION_IVR_MENU_SUPPORT
+                    if (xml_menus != NULL && ccfntbl[i].action == CALLER_CONTROL_MENU) {
+                        char *menu_group_name = strdup(data);
+                        char *menu_name = (menu_group_name != NULL ? strchr(menu_group_name, '/') : NULL);
 
-	/* Speed in hertz */
-	if (!switch_strlen_zero(rate_name)) {
-		uint32_t r = atoi(rate_name);
-		if (r) {
-			rate = r;
-		}
-	}
+                        /* format: "menu_group_name/menu_name" */
+                        /* separate the menu name from the menu group */
+                        if (menu_name != NULL) {
+                            *(menu_name++) = '\0';
+                        }
+                        /* if there is a menu name, build the menu */
+                        if (menu_name != NULL) {
+                            caller_control_menu_ctx_t *menu_ctx = NULL;
+                            switch_xml_t menu_group = switch_xml_find_child(xml_menus, "group", "name", menu_group_name);
 
-	/* Packet Interval in milliseconds */
-	if (!switch_strlen_zero(interval_name)) {
-		uint32_t i = atoi(interval_name);
-		if (i) {
-			interval = i;
-		}
-	}
+                            status = conference_caller_control_menu_build(&menu_ctx, conference, menu_group, menu_name);
+                            data = (char *)menu_ctx;
+                        } else {
+                            status = SWITCH_STATUS_FALSE;
+                        }
 
-	/* Timer module to use */
-	if (switch_strlen_zero(timer_name)) {
-		timer_name = "soft";
-	}
+                        if (status != SWITCH_STATUS_SUCCESS) {
+                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unable to build menu '%s' bound to '%s'\n", data, val);
+                        }
 
-	/* Caller ID Name */
-	if (switch_strlen_zero(caller_id_name)) {
-		caller_id_name = (char *) global_app_name;
-	}
+                        /* clean up */
+                        if (menu_group_name != NULL) {
+                            free(menu_group_name);
+                        }
+                    }
+#endif
 
-	/* Caller ID Number */
-	if (switch_strlen_zero(caller_id_number)) {
-		caller_id_number = "0000000000";
-	}
+                    if (status == SWITCH_STATUS_SUCCESS) {
+                        caller_control_action_t *action;
 
-	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;
-			return NULL;
-		}
-	}
+                        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 *)data;
+                            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);
+        }
+    }
 
-	/* 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;
-		return NULL;
-	}
+    return status;
+}
 
-	/* initialize the conference object with settings from the specified profile */
-	conference->pool = pool;
-	conference->timer_name = switch_core_strdup(conference->pool, timer_name);
-	conference->tts_engine = switch_core_strdup(conference->pool, tts_engine);
-	conference->tts_voice = switch_core_strdup(conference->pool, tts_voice);
+/* 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 *rate_name = NULL;
+    char *interval_name = NULL;
+    char *timer_name = NULL;
+    char *domain = NULL;
+    char *tts_engine = NULL;
+    char *tts_voice = NULL;
+    char *enter_sound = NULL;
+    char *exit_sound = NULL;
+    char *alone_sound = NULL;
+    char *ack_sound = NULL;
+    char *nack_sound = NULL;
+    char *muted_sound = NULL;
+    char *unmuted_sound = NULL;
+    char *locked_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;
+    uint32_t rate = 8000, interval = 20;
+    switch_status_t status;
 
-	conference->caller_id_name = switch_core_strdup(conference->pool, caller_id_name);
-	conference->caller_id_number = switch_core_strdup(conference->pool, caller_id_number);
+    /* Validate the conference name */
+    if (switch_strlen_zero(name)) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Record! no name.\n");
+        return NULL;
+    }
 
-	if (!switch_strlen_zero(enter_sound)) {
-		conference->enter_sound = switch_core_strdup(conference->pool, enter_sound);
-	}
+    /* parse the profile tree for param values */
+    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 (!switch_strlen_zero(exit_sound)) {
-		conference->exit_sound = switch_core_strdup(conference->pool, exit_sound);
-	}
+        if ((p = strchr(var, '_'))) {
+            switch_copy_string(buf, var, sizeof(buf));
+            for(p = buf; *p; p++) {
+                if (*p == '_') {
+                    *p = '-';
+                }
+            }
+            var = buf;
+        }
 
-	if (!switch_strlen_zero(ack_sound)) {
-		conference->ack_sound = switch_core_strdup(conference->pool, ack_sound);
-	}
+        if (!strcasecmp(var, "rate")) {
+            rate_name = val;
+        } else if (!strcasecmp(var, "domain")) {
+            domain = val;
+        } else if (!strcasecmp(var, "interval")) {
+            interval_name = val;
+        } else if (!strcasecmp(var, "timer-name")) {
+            timer_name = val;
+        } else if (!strcasecmp(var, "tts-engine")) {
+            tts_engine = val;
+        } else if (!strcasecmp(var, "tts-voice")) {
+            tts_voice = val;
+        } else if (!strcasecmp(var, "enter-sound")) {
+            enter_sound = val;
+        } else if (!strcasecmp(var, "exit-sound")) {
+            exit_sound = val;
+        } else if (!strcasecmp(var, "alone-sound")) {
+            alone_sound = val;
+        } else if (!strcasecmp(var, "ack-sound")) {
+            ack_sound = val;
+        } else if (!strcasecmp(var, "nack-sound")) {
+            nack_sound = val;
+        } else if (!strcasecmp(var, "muted-sound")) {
+            muted_sound = val;
+        } else if (!strcasecmp(var, "unmuted-sound")) {
+            unmuted_sound = val;
+        } else if (!strcasecmp(var, "locked-sound")) {
+            locked_sound = val;
+        } else if (!strcasecmp(var, "kicked-sound")) {
+            kicked_sound = val;
+        } else if (!strcasecmp(var, "pin")) {
+            pin = val;
+        } else if (!strcasecmp(var, "pin-sound")) {
+            pin_sound = val;
+        } else if (!strcasecmp(var, "bad-pin-sound")) {
+            bad_pin_sound = val;
+        } else if (!strcasecmp(var, "energy-level")) {
+            energy_level = val;
+        } else if (!strcasecmp(var, "caller-id-name")) {
+            caller_id_name = val;
+        } else if (!strcasecmp(var, "caller-id-number")) {
+            caller_id_number = val;
+        } else if (!strcasecmp(var, "caller-controls")) {
+            caller_controls = val;
+        }
+    }
 
-	if (!switch_strlen_zero(nack_sound)) {
-		conference->nack_sound = switch_core_strdup(conference->pool, nack_sound);
-	}
+    /* Set defaults and various paramaters */
 
-	if (!switch_strlen_zero(muted_sound)) {
-		conference->muted_sound = switch_core_strdup(conference->pool, muted_sound);
-	}
+    /* Speed in hertz */
+    if (!switch_strlen_zero(rate_name)) {
+        uint32_t r = atoi(rate_name);
+        if (r) {
+            rate = r;
+        }
+    }
 
-	if (!switch_strlen_zero(unmuted_sound)) {
-		conference->unmuted_sound = switch_core_strdup(conference->pool, unmuted_sound);
-	}
+    /* Packet Interval in milliseconds */
+    if (!switch_strlen_zero(interval_name)) {
+        uint32_t i = atoi(interval_name);
+        if (i) {
+            interval = i;
+        }
+    }
 
-	if (!switch_strlen_zero(kicked_sound)) {
-		conference->kicked_sound = switch_core_strdup(conference->pool, kicked_sound);
-	}
+    /* Timer module to use */
+    if (switch_strlen_zero(timer_name)) {
+        timer_name = "soft";
+    }
 
-	if (!switch_strlen_zero(pin_sound)) {
-		conference->pin_sound = switch_core_strdup(conference->pool, pin_sound);
-	}
+    /* Caller ID Name */
+    if (switch_strlen_zero(caller_id_name)) {
+        caller_id_name = (char *) global_app_name;
+    }
 
-	if (!switch_strlen_zero(bad_pin_sound)) {
-		conference->bad_pin_sound = switch_core_strdup(conference->pool, bad_pin_sound);
-	}
+    /* Caller ID Number */
+    if (switch_strlen_zero(caller_id_number)) {
+        caller_id_number = "0000000000";
+    }
 
-	if (!switch_strlen_zero(pin)) {
-		conference->pin = switch_core_strdup(conference->pool, pin);
-	}
+    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;
+            return NULL;
+        }
+    }
 
-	if (!switch_strlen_zero(alone_sound)) {
-		conference->alone_sound = switch_core_strdup(conference->pool, alone_sound);
-	} 
+    /* 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;
+        return NULL;
+    }
 
-	if (!switch_strlen_zero(locked_sound)) {
-		conference->locked_sound = switch_core_strdup(conference->pool, locked_sound);
-	}
+    /* initialize the conference object with settings from the specified profile */
+    conference->pool = pool;
+    conference->timer_name = switch_core_strdup(conference->pool, timer_name);
+    conference->tts_engine = switch_core_strdup(conference->pool, tts_engine);
+    conference->tts_voice = switch_core_strdup(conference->pool, tts_voice);
 
-	if (!switch_strlen_zero(energy_level)) {
-		conference->energy_level = atoi(energy_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);
 
-	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;
+    if (!switch_strlen_zero(enter_sound)) {
+        conference->enter_sound = switch_core_strdup(conference->pool, enter_sound);
+    }
 
+    if (!switch_strlen_zero(exit_sound)) {
+        conference->exit_sound = switch_core_strdup(conference->pool, exit_sound);
+    }
 
-	/* Activate the conference mutex for exclusivity */
-	switch_mutex_init(&conference->mutex, SWITCH_MUTEX_NESTED, conference->pool);
-	switch_mutex_init(&conference->member_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);
+    if (!switch_strlen_zero(ack_sound)) {
+        conference->ack_sound = switch_core_strdup(conference->pool, ack_sound);
+    }
 
-	return conference;
-}
+    if (!switch_strlen_zero(nack_sound)) {
+        conference->nack_sound = switch_core_strdup(conference->pool, nack_sound);
+    }
 
-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 (!switch_strlen_zero(muted_sound)) {
+        conference->muted_sound = switch_core_strdup(conference->pool, muted_sound);
+    }
 
-    if (!to || strncasecmp(to, "conf+", 5)) {
-        return;
+    if (!switch_strlen_zero(unmuted_sound)) {
+        conference->unmuted_sound = switch_core_strdup(conference->pool, unmuted_sound);
     }
-    
-    if (!(dup_to = strdup(to))) {
-        return;
+
+    if (!switch_strlen_zero(kicked_sound)) {
+        conference->kicked_sound = switch_core_strdup(conference->pool, kicked_sound);
     }
-    
-    conf_name = dup_to + 5;
 
-    if ((e = strchr(conf_name, '@'))) {
-        *e = '\0';
+    if (!switch_strlen_zero(pin_sound)) {
+        conference->pin_sound = switch_core_strdup(conference->pool, pin_sound);
     }
-    
-    if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) {
-        switch_event_t *event;
 
-        if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
-            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
-            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", 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(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
-            switch_event_fire(&event);
-        }
-    } else if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
-        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
-        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", conf_name);
-        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s", to);
-        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "Idle");
-        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rpid", "idle");
-        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
-        switch_event_fire(&event);
+    if (!switch_strlen_zero(bad_pin_sound)) {
+        conference->bad_pin_sound = switch_core_strdup(conference->pool, bad_pin_sound);
     }
 
-    switch_safe_free(dup_to);
-}
+    if (!switch_strlen_zero(pin)) {
+        conference->pin = switch_core_strdup(conference->pool, pin);
+    }
 
-static void send_presence(switch_event_types_t id)
-{
-    switch_xml_t cxml, cfg, advertise, room;
+    if (!switch_strlen_zero(alone_sound)) {
+        conference->alone_sound = switch_core_strdup(conference->pool, alone_sound);
+    } 
 
-    /* Open the config from the xml registry */
-    if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) {
-        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", global_cf_name);
-        goto done;
+    if (!switch_strlen_zero(locked_sound)) {
+        conference->locked_sound = switch_core_strdup(conference->pool, locked_sound);
     }
 
-    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 (!switch_strlen_zero(energy_level)) {
+        conference->energy_level = atoi(energy_level);
+    }
 
-            if (name && switch_event_create(&event, id) == SWITCH_STATUS_SUCCESS) {
-                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
-                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", name);
-                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s", name);
-                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "%s", status ? status : "Available");
-                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rpid", "idle");
-                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
-                switch_event_fire(&event);
+    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;
+
+    /* 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 = conference_new_install_caller_controls_default(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);
+#ifdef OPTION_IVR_MENU_SUPPORT
+            status = conference_new_install_caller_controls_custom(conference, xml_controls, cfg.menus);
+#else
+            status = conference_new_install_caller_controls_custom(conference, xml_controls, NULL);
+#endif
+            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 intalled.\n");
         }
+    } else {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to allocate caller control digit parser.\n");
     }
-    
- done:
-    /* Release the config registry handle */
-    if (cxml) {
-        switch_xml_free(cxml);
-        cxml = NULL;
-    }
+
+    /* Activate the conference mutex for exclusivity */
+    switch_mutex_init(&conference->mutex, SWITCH_MUTEX_NESTED, conference->pool);
+    switch_mutex_init(&conference->member_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);
+
+    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_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) { 
+        switch_event_t *event; 
+
+        if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) { 
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO); 
+            switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", 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(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); 
+            switch_event_fire(&event); 
+        } 
+    } else if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) { 
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO); 
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", conf_name); 
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s", to); 
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "Idle"); 
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rpid", "idle"); 
+        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); 
+        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; 
+
+    /* Open the config from the xml registry */ 
+    if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) { 
+        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(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO); 
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", name); 
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s", name); 
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "%s", status ? status : "Available"); 
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rpid", "idle"); 
+                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); 
+                switch_event_fire(&event); 
+            } 
+        } 
+    } 
+
+ done: 
+    /* Release the config registry handle */ 
+    if (cxml) { 
+        switch_xml_free(cxml); 
+        cxml = NULL; 
+    } 
+} 
+
 /* Called by FreeSWITCH when the module loads */
 SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename)
 {
-	switch_status_t status = SWITCH_STATUS_SUCCESS;
+    uint32_t i;
+    size_t nl, ol = 0;
+    char *p = NULL;
+    switch_status_t status = SWITCH_STATUS_SUCCESS;
 
-	memset(&globals, 0, sizeof(globals));
+    memset(&globals, 0, sizeof(globals));
 
-	/* Connect my internal structure to the blank pointer passed to me */
-	*module_interface = &conference_module_interface;
+    /* 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);
+        }
+        p = realloc(p, ol+nl);
+        if (p != NULL) {
+            strcat(p, "\t\t");
+            strcat(p, conf_api_sub_commands[i].psyntax);
+            if (i < CONFFUNCAPISIZE-1) {
+                strcat(p, "\n");
+            }
+        }
+		
+    }
+    /* install api interface help ".syntax" field string */
+    if (p != NULL) {
+        conf_api_interface.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!", CONF_EVENT_MAINT);
-		return SWITCH_STATUS_TERM;
-	}
+    /* Connect my internal structure to the blank pointer passed to me */
+    *module_interface = &conference_module_interface;
 
-	/* Setup the pool */
-	if (switch_core_new_memory_pool(&globals.conference_pool) != SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no conference pool\n");
-		return SWITCH_STATUS_TERM;
-	}
+    /* 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!", CONF_EVENT_MAINT);
+        return SWITCH_STATUS_TERM;
+    }
 
-	/* 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);
-    
-    /* Get presence request events */
-	if (switch_event_bind((char *) modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, pres_event_handler, NULL) != SWITCH_STATUS_SUCCESS) {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind!\n");
-		return SWITCH_STATUS_GENERR;
+    /* Setup the pool */
+    if (switch_core_new_memory_pool(&globals.conference_pool) != SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no conference pool\n");
+        return SWITCH_STATUS_TERM;
+    }
 
-	}
+    /* 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);
+
+    /* Subscribe to presence request events */
+    if (switch_event_bind((char *) modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, pres_event_handler, NULL) != SWITCH_STATUS_SUCCESS) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't subscribe to presence request events!\n");
+        return SWITCH_STATUS_GENERR;
+    }
+
     send_presence(SWITCH_EVENT_PRESENCE_IN);
 
-	globals.running = 1;
-	/* indicate that the module should continue to be loaded */
-	return status;
+    globals.running = 1;
+    /* indicate that the module should continue to be loaded */
+    return status;
 }
 
 SWITCH_MOD_DECLARE(switch_status_t) switch_module_shutdown(void)
 {
+    if (globals.running) {
 
+        /* signal all threads to shutdown */
+        globals.running = 0;
 
-	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);
-		}
-	}
+        /* 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);
+        }
 
-	return SWITCH_STATUS_SUCCESS;
+        /* free api interface help ".syntax" field string */
+        if (conf_api_interface.syntax != NULL) {
+            free((char *)conf_api_interface.syntax);
+        }
+    }
+
+    return SWITCH_STATUS_SUCCESS;
 }
 
 /* For Emacs:
@@ -3833,5 +4538,5 @@
  * c-basic-offset:4
  * End:
  * For VIM:
- * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ * vim:set softtabstop = 4 shiftwidth = 4 tabstop = 4 expandtab:
  */



More information about the Freeswitch-trunk mailing list