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: */