October 2006 - Freeswitch-branches - FreeSWITCH Mailing Lists

[commit] r3243 - freeswitch/branches/kevinboca
by Freeswitch SVN 31 Oct '06

31 Oct '06

Author: sphere Date: Tue Oct 31 15:21:14 2006 New Revision: 3243 Added: freeswitch/branches/kevinboca/ Log: Creating empty folder for kevinboca

1 0

[commit] r3242 - freeswitch/branches/rmckrill
by Freeswitch SVN 31 Oct '06

31 Oct '06

Author: sphere Date: Tue Oct 31 13:46:19 2006 New Revision: 3242 Added: freeswitch/branches/rmckrill/ Log: Creating empty folder for rmckrill

1 0

[commit] r3238 - freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands
by Freeswitch SVN 31 Oct '06

31 Oct '06

Author: knhor Date: Mon Oct 30 23:39:01 2006 New Revision: 3238 Modified: freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c Log: make the new formatting callback work for all use caes Modified: freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c ============================================================================== --- freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c (original) +++ freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c Mon Oct 30 23:39:01 2006 @@ -58,8 +58,8 @@ switch_core_measure_time(switch_core_uptime(), &duration); if (stream->event) { - http = switch_event_get_header(stream->event, "http-host"); - } + http = switch_event_get_header(stream->event, "http-host"); + } if (http || (cmd && strstr(cmd, "html"))) { html = 1; @@ -139,23 +139,24 @@ } - static switch_status_t load_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream) { if (session) { return SWITCH_STATUS_FALSE; } + if (switch_strlen_zero(mod)) { stream->write_function(stream, "USAGE: %s\n", load_api_interface.syntax); return SWITCH_STATUS_SUCCESS; } + switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) mod); stream->write_function(stream, "OK\n"); + return SWITCH_STATUS_SUCCESS; } - static switch_status_t reload_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream) { const char *err; @@ -170,6 +171,7 @@ } stream->write_function(stream, "OK [%s]\n", err); + return SWITCH_STATUS_SUCCESS; } @@ -195,7 +197,6 @@ return SWITCH_STATUS_SUCCESS; } - static switch_status_t transfer_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream) { switch_core_session_t *session = NULL; @@ -234,8 +235,6 @@ return SWITCH_STATUS_SUCCESS; } - - static switch_status_t uuid_bridge_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream) { char *argv[4] = {0}; @@ -258,8 +257,6 @@ return SWITCH_STATUS_SUCCESS; } - - static switch_status_t pause_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream) { switch_core_session_t *session = NULL; @@ -385,13 +382,29 @@ char *http; uint32_t count; int print_title; + int format; }; +static void show_callback_format_help(switch_stream_handle_t *stream, int column, char *coldata) +{ + if(stream != NULL && coldata != NULL) { + switch(column) { + case 0: + case 2: + stream->write_function(stream, "%s\n", coldata); + break; + case 1: + stream->write_function(stream, "\t%s ", coldata); + break; + } + } +} + static int show_callback(void *pArg, int argc, char **argv, char **columnNames){ struct holder *holder = (struct holder *) pArg; int x; - + // column headers if (holder->print_title && holder->count == 0) { if (holder->http) { holder->stream->write_function(holder->stream, "\n<tr>"); @@ -402,19 +415,20 @@ holder->stream->write_function(holder->stream, "<td>"); holder->stream->write_function(holder->stream, "<b>%s</b>%s", columnNames[x], x == (argc - 1) ? "</td></tr>\n" : "</td><td>"); } else { - switch(x) { - case 0: // column 0 - case 2: // column 2 - holder->stream->write_function(holder->stream, "%s\n", argv[x]); + switch(holder->format) + { + case 1: // help command formatting + show_callback_format_help(holder->stream,x,argv[x]); break; - case 1: // column 1 - holder->stream->write_function(holder->stream, "\t%s ", argv[x]); + default: // generic formatting + holder->stream->write_function(holder->stream, "%s%s", columnNames[x], x == (argc - 1) ? "\n" : ","); break; } } } } + // column rows if (holder->http) { holder->stream->write_function(holder->stream, "<tr bgcolor=%s>", holder->count % 2 == 0 ? "eeeeee" : "ffffff"); } @@ -424,21 +438,18 @@ holder->stream->write_function(holder->stream, "<td>"); holder->stream->write_function(holder->stream, "%s%s", argv[x], x == (argc - 1) ? "</td></tr>\n" : "</td><td>"); } else { - switch(x) { - case 0: // column 0 - case 2: // column 2 - holder->stream->write_function(holder->stream, "%s\n", argv[x]); + switch(holder->format) + { + case 1: // help command formatting + show_callback_format_help(holder->stream,x,argv[x]); break; - case 1: // column 1 - holder->stream->write_function(holder->stream, "\t%s ", argv[x]); + default: // generic formatting + holder->stream->write_function(holder->stream, "%s%s", argv[x], x == (argc - 1) ? "\n" : ","); break; } } } - - - holder->count++; return 0; } @@ -456,43 +467,41 @@ } if (stream->event) { - holder.http = switch_event_get_header(stream->event, "http-host"); - } + holder.http = switch_event_get_header(stream->event, "http-host"); + } holder.print_title = 1; - if (!cmd) { - sprintf (sql, "select * from interfaces"); - } - else if ( !strcmp(cmd,"codec") || !strcmp(cmd,"dialplan") || - !strcmp(cmd,"file") || !strcmp(cmd,"timer") - ) { - sprintf (sql, "select type, name from interfaces where type = '%s'", cmd); - } - else if (!strcmp(cmd,"application") || !strcmp(cmd,"api")) { - sprintf (sql, "select name, description, syntax from interfaces where type = '%s'", cmd); - } - else if ( !strcmp(cmd,"calls")) { - sprintf (sql, "select * from calls"); - } - else if ( !strcmp(cmd,"channels")) { - sprintf (sql, "select * from channels"); - } - else if (!strncasecmp(cmd, "help", 4)) { + // If you changes the field qty or order of any of these select + // statmements, you must also change show_callback and friends to match! + if (!cmd) { + sprintf (sql, "select * from interfaces"); + } else if ( !strcmp(cmd,"codec") || !strcmp(cmd,"dialplan") || !strcmp(cmd,"file") || !strcmp(cmd,"timer")) { + sprintf (sql, "select type, name from interfaces where type = '%s'", cmd); + } else if (!strcmp(cmd,"application") || !strcmp(cmd,"api")) { + sprintf (sql, "select name, description, syntax from interfaces where type = '%s'", cmd); + } else if ( !strcmp(cmd,"calls")) { + sprintf (sql, "select * from calls"); + } else if ( !strcmp(cmd,"channels")) { + sprintf (sql, "select * from channels"); + } else if (!strncasecmp(cmd, "help", 4)) { char *cmdname = NULL; + help = 1; holder.print_title = 0; + holder.format = 1; + + // If you change one, you must change the other! if ((cmdname = strchr(cmd, ' ')) != 0) { *cmdname++ = '\0'; - sprintf (sql, "select name, syntax, description from interfaces where type = 'api' and name = '%s'", cmdname); + sprintf (sql, "select description, name, syntax from interfaces where type = 'api' and name = '%s'", cmdname); } else { sprintf (sql, "select description, name, syntax from interfaces where type = 'api'"); } - } - else { + } else { stream->write_function(stream, "USAGE: %s\n", show_api_interface.syntax); - return SWITCH_STATUS_SUCCESS; - } + return SWITCH_STATUS_SUCCESS; + } holder.stream = stream; holder.count = 0; @@ -533,11 +542,16 @@ sprintf (showcmd, "help %s", cmd); } - if (all) + if (all) { stream->write_function(stream, "\nValid Commands:\n\n"); + } + show_function(showcmd, session, stream); - if (all) + + if (all) { stream->write_function(stream, "version\n" "shutdown - stop the program\n"); + } + return SWITCH_STATUS_SUCCESS; } @@ -630,7 +644,6 @@ /*.next */ &kill_api_interface }; - static const switch_loadable_module_interface_t mod_commands_module_interface = { /*.module_name */ modname, /*.endpoint_interface */ NULL, @@ -641,15 +654,11 @@ /*.api_interface */ &originate_api_interface }; - SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename) { - /* connect my internal structure to the blank pointer passed to me */ *module_interface = &mod_commands_module_interface; - /* indicate that the module should continue to be loaded */ return SWITCH_STATUS_SUCCESS; } -

1 0

[commit] r3235 - freeswitch/branches/eportel77
by Freeswitch SVN 30 Oct '06

30 Oct '06

Author: sphere Date: Mon Oct 30 03:52:04 2006 New Revision: 3235 Added: freeswitch/branches/eportel77/ Log: Creating empty folder for eportel77

1 0

[commit] r3234 - freeswitch/branches/evelio
by Freeswitch SVN 30 Oct '06

30 Oct '06

Author: sphere Date: Sun Oct 29 22:19:06 2006 New Revision: 3234 Added: freeswitch/branches/evelio/ Log: Creating empty folder for evelio

1 0

[commit] r3232 - freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands
by Freeswitch SVN 30 Oct '06

30 Oct '06

Author: knhor Date: Sun Oct 29 20:15:38 2006 New Revision: 3232 Modified: freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c Log: make the non-http help response more human readable Modified: freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c ============================================================================== --- freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c (original) +++ freeswitch/branches/knhor/trunk/src/mod/applications/mod_commands/mod_commands.c Sun Oct 29 20:15:38 2006 @@ -402,7 +402,15 @@ holder->stream->write_function(holder->stream, "<td>"); holder->stream->write_function(holder->stream, "<b>%s</b>%s", columnNames[x], x == (argc - 1) ? "</td></tr>\n" : "</td><td>"); } else { - holder->stream->write_function(holder->stream, "%s%s", columnNames[x], x == (argc - 1) ? "\n" : ","); + switch(x) { + case 0: // column 0 + case 2: // column 2 + holder->stream->write_function(holder->stream, "%s\n", argv[x]); + break; + case 1: // column 1 + holder->stream->write_function(holder->stream, "\t%s ", argv[x]); + break; + } } } } @@ -416,7 +424,15 @@ holder->stream->write_function(holder->stream, "<td>"); holder->stream->write_function(holder->stream, "%s%s", argv[x], x == (argc - 1) ? "</td></tr>\n" : "</td><td>"); } else { - holder->stream->write_function(holder->stream, "%s%s", argv[x], x == (argc - 1) ? "\n" : ","); + switch(x) { + case 0: // column 0 + case 2: // column 2 + holder->stream->write_function(holder->stream, "%s\n", argv[x]); + break; + case 1: // column 1 + holder->stream->write_function(holder->stream, "\t%s ", argv[x]); + break; + } } } @@ -468,9 +484,9 @@ holder.print_title = 0; if ((cmdname = strchr(cmd, ' ')) != 0) { *cmdname++ = '\0'; - sprintf (sql, "select name, syntax, description from interfaces where type = 'api' and name = '%s'", cmdname); + sprintf (sql, "select name, syntax, description from interfaces where type = 'api' and name = '%s'", cmdname); } else { - sprintf (sql, "select name, syntax, description from interfaces where type = 'api'"); + sprintf (sql, "select description, name, syntax from interfaces where type = 'api'"); } } else {

1 0

[commit] r3231 - freeswitch/branches/knhor/wip/mod_conference
by Freeswitch SVN 30 Oct '06

30 Oct '06

Author: knhor Date: Sun Oct 29 19:59:08 2006 New Revision: 3231 Added: freeswitch/branches/knhor/wip/mod_conference/Makefile freeswitch/branches/knhor/wip/mod_conference/mod_conference.c Log: refactor to use sub-command lookup table instead of inline switch statment. Added: freeswitch/branches/knhor/wip/mod_conference/Makefile ============================================================================== --- (empty file) +++ freeswitch/branches/knhor/wip/mod_conference/Makefile Sun Oct 29 19:59:08 2006 @@ -0,0 +1,29 @@ +MODULENAME= mod_conference +SRCS= ${MODULENAME}.c +OBJS= ${SRCS:.c=.o} + +DEBUG= -ggdb -g3 +CFLAGS= -Wall $(DEBUG) $(INCLUDES) + +BASEDIR= /usr/local/fsw/fs-knhor +BASEINC= $(BASEDIR)/include +INCLUDES= -I$(BASEINC) -I$(BASEINC)/apr-1 +LIBS= -L$(BASDIR)/lib -ldl -lpthread -lm +MODDIR= $(BASEDIR)/mod + +CC= gcc +INSTALL= install + +all: ${MODULENAME}.so + +install: all + $(INSTALL) -m 755 ${MODULENAME}.so $(MODDIR) + +clean: + rm -f *.so *.o + +${MODULENAME}.so: Makefile $(SRCS) $(OBJS) + $(CC) -shared -Xlinker -x -o $@ $(OBJS) + +%.so : %.o Makefile + $(CC) -shared -Xlinker -x -o $@ $< Added: freeswitch/branches/knhor/wip/mod_conference/mod_conference.c ============================================================================== --- (empty file) +++ freeswitch/branches/knhor/wip/mod_conference/mod_conference.c Sun Oct 29 19:59:08 2006 @@ -0,0 +1,3330 @@ +/* + * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application + * Copyright (C) 2005/2006, Anthony Minessale II <anthmct(a)yahoo.com> + * + * Version: MPL 1.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application + * + * The Initial Developer of the Original Code is + * Anthony Minessale II <anthmct(a)yahoo.com> + * Portions created by the Initial Developer are Copyright (C) + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Anthony Minessale II <anthmct(a)yahoo.com> + * Neal Horman <neal at wanlink dot com> + * + * + * mod_conference.c -- Software Conference Bridge + * + */ +#include <switch.h> +#define normalize_volume(x) if(x > 4) x = 4; if (x < -4) x = -4; +static const char modname[] = "mod_conference"; +static const char global_app_name[] = "conference"; +static char *global_cf_name = "conference.conf"; +static switch_api_interface_t conf_api_interface; + +/* Size to allocate for audio buffers */ +#define CONF_BUFFER_SIZE 1024 * 128 +#define CONF_EVENT_MAINT "conference::maintenence" +#define CONF_DEFAULT_LEADIN 20 + +#define CONF_DBLOCK_SIZE CONF_BUFFER_SIZE +#define CONF_DBUFFER_SIZE CONF_BUFFER_SIZE +#define CONF_DBUFFER_MAX 0 +#define CONF_CHAT_PROTO "conf" + +typedef enum { + FILE_STOP_CURRENT, + FILE_STOP_ALL +} file_stop_t; + +/* Global Values */ +static struct { + switch_memory_pool_t *conference_pool; + switch_mutex_t *conference_mutex; + switch_hash_t *conference_hash; + switch_mutex_t *id_mutex; + switch_mutex_t *hash_mutex; + uint32_t id_pool; + int32_t running; + uint32_t threads; +} globals; + +// forward declaration for conference_obj structure +struct conference_member; +typedef struct conference_member conference_member_t; + +typedef enum { + MFLAG_RUNNING = (1 << 0), + MFLAG_CAN_SPEAK = (1 << 1), + MFLAG_CAN_HEAR = (1 << 2), + MFLAG_KICKED = (1 << 3), + MFLAG_ITHREAD = (1 << 4), + MFLAG_NOCHANNEL = (1 << 5) +} member_flag_t; + + +typedef enum { + CFLAG_RUNNING = (1 << 0), + CFLAG_DYNAMIC = (1 << 1), + CFLAG_ENFORCE_MIN = (1 << 2), + CFLAG_DESTRUCT = (1 << 3), + CFLAG_LOCKED = (1 << 4), + CFLAG_ANSWERED = (1 << 5) +} conf_flag_t; + +typedef enum { + RFLAG_CAN_SPEAK = (1 << 0), + RFLAG_CAN_HEAR = (1 << 1) +} relation_flag_t; + +typedef enum { + NODE_TYPE_FILE, + NODE_TYPE_SPEECH +} node_type_t; + +struct confernce_file_node { + switch_file_handle_t fh; + switch_speech_handle_t sh; + node_type_t type; + uint8_t done; + switch_memory_pool_t *pool; + uint32_t leadin; + struct confernce_file_node *next; +}; + +typedef struct confernce_file_node confernce_file_node_t; + +/* Conference Object */ +struct conference_obj { + char *name; + char *timer_name; + char *tts_engine; + char *tts_voice; + char *enter_sound; + char *exit_sound; + char *alone_sound; + char *ack_sound; + char *nack_sound; + char *muted_sound; + char *unmuted_sound; + char *locked_sound; + char *kicked_sound; + char *caller_id_name; + char *caller_id_number; + char *pin; + char *pin_sound; + char *bad_pin_sound; + char *profile_name; + char *domain; + uint32_t flags; + switch_call_cause_t bridge_hangup_cause; + switch_mutex_t *flag_mutex; + uint32_t rate; + uint32_t interval; + switch_mutex_t *mutex; + conference_member_t *members; + switch_mutex_t *member_mutex; + confernce_file_node_t *fnode; + switch_memory_pool_t *pool; + switch_thread_rwlock_t *rwlock; + uint32_t count; + int32_t energy_level; + uint8_t min; +}; +typedef struct conference_obj conference_obj_t; + +/* Relationship with another member */ +struct conference_relationship { + uint32_t id; + uint32_t flags; + struct conference_relationship *next; +}; +typedef struct conference_relationship conference_relationship_t; + +/* Conference Member Object */ +struct conference_member { + uint32_t id; + switch_core_session_t *session; + conference_obj_t *conference; + conference_obj_t *last_conference; + switch_memory_pool_t *pool; + switch_buffer_t *audio_buffer; + switch_buffer_t *mux_buffer; + switch_buffer_t *resample_buffer; + uint32_t flags; + switch_mutex_t *flag_mutex; + switch_mutex_t *audio_in_mutex; + switch_mutex_t *audio_out_mutex; + switch_codec_t read_codec; + switch_codec_t write_codec; + char *rec_path; + uint8_t *frame; + uint8_t *mux_frame; + uint32_t buflen; + uint32_t read; + uint32_t len; + int32_t energy_level; + int32_t volume_in_level; + int32_t volume_out_level; + uint32_t native_rate; + switch_audio_resampler_t *mux_resampler; + switch_audio_resampler_t *read_resampler; + confernce_file_node_t *fnode; + conference_relationship_t *relationships; + struct conference_member *next; +}; + +/* Record Node */ +struct conference_record { + conference_obj_t *conference; + char *path; + switch_memory_pool_t *pool; +}; +typedef struct conference_record conference_record_t; + +// API command parser +typedef struct api_command { + char *pname; + void *pfnapicmd; +// int (*pfnapicmd)(); + int 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 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 void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj); +static void conference_loop(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); +static switch_status_t conference_say(conference_obj_t *conference, 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 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, + 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 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 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 void switch_change_sln_volume(int16_t *data, uint32_t samples, int32_t vol); +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_member_cmd_t)(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); + +/* Return a Distinct ID # */ +static uint32_t next_member_id(void) +{ + uint32_t id; + + switch_mutex_lock(globals.id_mutex); + id = ++globals.id_pool; + switch_mutex_unlock(globals.id_mutex); + + return id; +} + +static void switch_change_sln_volume(int16_t *data, uint32_t samples, int32_t vol) +{ + int16_t *p = data; + uint32_t x = 0; + int32_t v = vol * 10; + double mult = (((double)abs(v)) / 100) * 2; + int32_t b; + + if (v > 0) { + mult += (.2 * abs(v)); + mult = 4; + } else { + mult -= 1; + } + + for (x = 0; x < samples; x++) { + b = (int32_t)((double)p[x] * mult); + switch_normalize_to_16bit(b); + p[x] = (int16_t) b; + } +} + +/* 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; + + switch_mutex_lock(member->flag_mutex); + switch_mutex_lock(other_member->flag_mutex); + + if (member->relationships) { + for (rel = member->relationships; rel; rel = rel->next) { + if (rel->id == other_member->id) { + break; + } + + /* 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); + + if (!rel && global) { + rel = global; + } + + return rel; +} + +static conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id) +{ + conference_member_t *member = NULL; + + for(member = conference->members; member; member = member->next) { + + if (switch_test_flag(member, MFLAG_NOCHANNEL)) { + continue; + } + + if (member->id == id) { + break; + } + } + + return member; +} + +static int 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++; + } + } + + return count; +} + +/* Add a custom relationship to a member */ +static conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id) +{ + conference_relationship_t *rel = NULL; + + if ((rel = switch_core_alloc(member->pool, sizeof(*rel)))) { + rel->id = id; + + switch_mutex_lock(member->flag_mutex); + rel->next = member->relationships; + member->relationships = rel; + switch_mutex_unlock(member->flag_mutex); + } + + return rel; +} + +/* Remove a custom relationship from a member */ +static void member_del_relationship(conference_member_t *member, uint32_t id) +{ + 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; + } + } + last = rel; + } + switch_mutex_unlock(member->flag_mutex); +} + +/* 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; + + 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; + } + + 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 (conference->enter_sound) { + conference_play_file(conference, conference->enter_sound, CONF_DEFAULT_LEADIN); + } + + if (conference->count == 1 && conference->alone_sound) { + conference_play_file(conference, conference->alone_sound, 0); + } + + if (conference->min && conference->count >= conference->min) { + switch_set_flag(conference, CFLAG_ENFORCE_MIN); + } + + 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, "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); + + return SWITCH_STATUS_SUCCESS; +} + +/* Gain exclusive access and remove the member from the list */ +static void conference_del_member(conference_obj_t *conference, conference_member_t *member) +{ + 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); + + 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; + } + + + 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 ((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); + } + if (conference->count == 1 && conference->alone_sound) { + conference_play_file(conference, conference->alone_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_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + 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_thread_rwlock_unlock(conference->rwlock); + +} + +/* Main monitor thread (1 per distinct conference room) */ +static void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj) +{ + conference_obj_t *conference = (conference_obj_t *) obj; + conference_member_t *imember, *omember; + uint32_t divider = 1000 / conference->interval; + uint32_t samples = (conference->rate / divider); + uint32_t bytes = samples * 2; + uint8_t ready = 0; + switch_timer_t timer = {0}; + switch_event_t *event; + + if (switch_core_timer_init(&timer, conference->timer_name, conference->interval, samples, conference->pool) == SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "setup timer success interval: %u samples: %u\n", conference->interval, samples); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Setup Failed. Conference Cannot Start\n"); + return NULL; + } + + switch_mutex_lock(globals.hash_mutex); + globals.threads++; + switch_mutex_unlock(globals.hash_mutex); + + while(globals.running && !switch_test_flag(conference, CFLAG_DESTRUCT)) { + uint8_t file_frame[CONF_BUFFER_SIZE] = {0}; + switch_size_t file_sample_len = samples; + switch_size_t file_data_len = samples * 2; + + /* Sync the conference to a single timing source */ + switch_core_timer_next(&timer); + + switch_mutex_lock(conference->mutex); + ready = 0; + + /* Read one frame of audio from each member channel and save it for redistribution */ + for (imember = conference->members; imember; imember = imember->next) { + if (imember->buflen) { + memset(imember->frame, 255, imember->buflen); + } else { + imember->frame = switch_core_alloc(imember->pool, bytes); + imember->mux_frame = switch_core_alloc(imember->pool, bytes); + imember->buflen = bytes; + } + + switch_mutex_lock(imember->audio_in_mutex); + /* if there is audio in the resample buffer it takes precedence over the other data */ + if (imember->mux_resampler && switch_buffer_inuse(imember->resample_buffer) >= bytes) { + imember->read = (uint32_t)switch_buffer_read(imember->resample_buffer, imember->frame, bytes); + ready++; + } else if ((imember->read = (uint32_t)switch_buffer_read(imember->audio_buffer, imember->frame, imember->buflen))) { + /* If the caller is not at the right sample rate resample him to suit and buffer accordingly */ + if (imember->mux_resampler) { + int16_t *bptr = (int16_t *) imember->frame; + int16_t out[1024]; + 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); + 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); + if (switch_buffer_inuse(imember->resample_buffer) >= bytes) { + imember->read = (uint32_t)switch_buffer_read(imember->resample_buffer, imember->frame, bytes); + ready++; + } + } else { + ready++; /* Tally of how many channels had data */ + } + } + switch_mutex_unlock(imember->audio_in_mutex); + } + + /* If a file or speech event is being played */ + if (conference->fnode) { + /* Lead in time */ + if (conference->fnode->leadin) { + conference->fnode->leadin--; + } else { + ready++; + if (conference->fnode->type == NODE_TYPE_SPEECH) { + 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, + &flags) == SWITCH_STATUS_SUCCESS) { + file_sample_len = file_data_len / 2; + } else { + file_sample_len = file_data_len = 0; + } + } else if (conference->fnode->type == NODE_TYPE_FILE) { + switch_core_file_read(&conference->fnode->fh, file_frame, &file_sample_len); + } + + if (file_sample_len <= 0) { + conference->fnode->done++; + } + } + } + + if (ready) { + /* Build a muxed frame for every member that contains the mixed audio of everyone else */ + for (omember = conference->members; omember; omember = omember->next) { + omember->len = bytes; + if (conference->fnode) { + memcpy(omember->mux_frame, file_frame, file_sample_len * 2); + } else { + memset(omember->mux_frame, 255, bytes); + } + for (imember = conference->members; imember; imember = imember->next) { + + if (imember == omember) { + /* Don't add audio from yourself */ + continue; + } + + if (imember->read) { /* mux the frame with the collective */ + uint32_t x; + int16_t *bptr, *muxed; + + /* If they are not supposed to talk to us then don't let them */ + if (omember->relationships) { + conference_relationship_t *rel; + + if ((rel = member_get_relationship(omember, imember))) { + if (! switch_test_flag(rel, RFLAG_CAN_HEAR)) { + continue; + } + } + } + + /* If we are not supposed to hear them then don't let it happen */ + if (imember->relationships) { + conference_relationship_t *rel; + + if ((rel = member_get_relationship(imember, omember))) { + if (! switch_test_flag(rel, RFLAG_CAN_SPEAK)) { + continue; + } + } + } + + if (imember->read > imember->len) { + imember->len = imember->read; + } + + bptr = (int16_t *) imember->frame; + muxed = (int16_t *) omember->mux_frame; + + + for (x = 0; x < imember->read / 2; x++) { + int32_t z = muxed[x] + bptr[x]; + switch_normalize_to_16bit(z); + muxed[x] = (int16_t)z; + } + + ready++; + } + } + } + + /* Go back and write each member his dedicated copy of the audio frame that does not contain his own audio. */ + for (imember = conference->members; imember; imember = imember->next) { + switch_mutex_lock(imember->audio_out_mutex); + switch_buffer_write(imember->mux_buffer, imember->mux_frame, imember->len); + switch_mutex_unlock(imember->audio_out_mutex); + } + } + + if (conference->fnode && conference->fnode->done) { + confernce_file_node_t *fnode; + switch_memory_pool_t *pool; + + if (conference->fnode->type == NODE_TYPE_SPEECH) { + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + switch_core_speech_close(&conference->fnode->sh, &flags); + } else { + switch_core_file_close(&conference->fnode->fh); + } + + fnode = conference->fnode; + conference->fnode = conference->fnode->next; + + pool = fnode->pool; + fnode = NULL; + switch_core_destroy_memory_pool(&pool); + + } + + switch_mutex_unlock(conference->mutex); + } /* Rinse ... Repeat */ + + switch_core_timer_destroy(&timer); + + if (switch_test_flag(conference, CFLAG_DESTRUCT)) { + + switch_mutex_lock(conference->mutex); + + for(imember = conference->members; imember; imember = imember->next) { + switch_channel_t *channel; + + if (!switch_test_flag(imember, MFLAG_NOCHANNEL)) { + channel = switch_core_session_get_channel(imember->session); + + // add this little bit to preserve the bridge cause code in case of an early media call that + // never answers + if (switch_test_flag(conference, CFLAG_ANSWERED)) { + switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING); + } else { + // put actual cause code from outbound channel hangup here + switch_channel_hangup(channel, conference->bridge_hangup_cause); + } + } + + switch_clear_flag_locked(imember, MFLAG_RUNNING); + } + + switch_mutex_unlock(conference->mutex); + + /* Wait till everybody is out */ + switch_clear_flag_locked(conference, CFLAG_RUNNING); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Lock ON\n"); + switch_thread_rwlock_wrlock(conference->rwlock); + switch_thread_rwlock_unlock(conference->rwlock); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Lock OFF\n"); + + switch_mutex_lock(globals.hash_mutex); + switch_core_hash_delete(globals.conference_hash, conference->name); + switch_mutex_unlock(globals.hash_mutex); + + if (conference->pool) { + switch_memory_pool_t *pool = conference->pool; + switch_core_destroy_memory_pool(&pool); + } + } + + 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", "Inactive"); + 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_mutex_lock(globals.hash_mutex); + globals.threads--; + switch_mutex_unlock(globals.hash_mutex); + + return NULL; +} + +/* Sub-Routine called by a channel inside a conference */ +static void conference_loop(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}; + uint32_t divider = 1000 / member->conference->interval; + uint32_t samples = (member->conference->rate / divider); + uint32_t bytes = samples * 2; + + channel = switch_core_session_get_channel(member->session); + + assert(channel != NULL); + assert(member->conference != NULL); + + 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); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Setup Failed. Conference Cannot Start\n"); + return; + } + + write_frame.data = data; + write_frame.buflen = sizeof(data); + write_frame.codec = &member->write_codec; + + if (switch_test_flag(member->conference, CFLAG_ANSWERED)) { + 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)); + + while(switch_test_flag(member, MFLAG_RUNNING) && switch_test_flag(member, MFLAG_ITHREAD) && switch_channel_ready(channel)) { + char dtmf[128] = ""; + uint8_t file_frame[CONF_BUFFER_SIZE] = {0}; + switch_size_t file_data_len = samples * 2; + switch_size_t file_sample_len = samples; + char *digit; + char msg[512]; + switch_event_t *event; + + if (switch_core_session_dequeue_event(member->session, &event) == SWITCH_STATUS_SUCCESS) { + char *p; + char *from = switch_event_get_header(event, "from"); + char *to = switch_event_get_header(event, "to"); + char *proto = switch_event_get_header(event, "proto"); + char *subject = switch_event_get_header(event, "subject"); + char *body = switch_event_get_body(event); + if ((p = strchr(to, '+'))) { + to = ++p; + } + chat_send(proto, from, to, subject, body, ""); + switch_event_destroy(&event); + } + + if (switch_channel_test_flag(channel, CF_OUTBOUND)) { + // test to see if outbound channel has answered + if (switch_channel_test_flag(channel, CF_ANSWERED) && !switch_test_flag(member->conference, CFLAG_ANSWERED)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Outbound conference channel answered, setting CFLAG_ANSWERED"); + switch_set_flag(member->conference, CFLAG_ANSWERED); + } + } else { + if (switch_test_flag(member->conference, CFLAG_ANSWERED) && !switch_channel_test_flag(channel, CF_ANSWERED)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CLFAG_ANSWERED set, answering inbound channel\n"); + switch_channel_answer(channel); + } + } + + if (switch_channel_has_dtmf(channel)) { + switch_channel_dequeue_dtmf(channel, dtmf, sizeof(dtmf)); + + for (digit = dtmf; *digit; digit++) { + switch(*digit) { + case '0': + 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 { + 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); + } + } + break; + case '*': + 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 { + 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); + } + } + break; + case '9': + switch_mutex_lock(member->flag_mutex); + member->energy_level += 100; + if (member->energy_level > 1200) { + member->energy_level = 1200; + } + switch_mutex_unlock(member->flag_mutex); + snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level); + conference_member_say(member->conference, member, msg, 0); + 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); + 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); + break; + case '3': + switch_mutex_lock(member->flag_mutex); + member->volume_out_level++; + 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); + 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); + break; + case '1': + switch_mutex_lock(member->flag_mutex); + member->volume_out_level--; + 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); + break; + case '6': + switch_mutex_lock(member->flag_mutex); + member->volume_in_level++; + 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); + 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); + break; + case '4': + switch_mutex_lock(member->flag_mutex); + member->volume_in_level--; + 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); + break; + case '#': + switch_clear_flag_locked(member, MFLAG_RUNNING); + break; + default: + break; + } + } + } + + if (member->fnode) { + if (member->fnode->done) { + confernce_file_node_t *fnode; + switch_memory_pool_t *pool; + + if (member->fnode->type == NODE_TYPE_SPEECH) { + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + switch_core_speech_close(&member->fnode->sh, &flags); + } else { + switch_core_file_close(&member->fnode->fh); + } + + switch_mutex_lock(member->flag_mutex); + fnode = member->fnode; + member->fnode = member->fnode->next; + switch_mutex_unlock(member->flag_mutex); + + pool = fnode->pool; + fnode = NULL; + switch_core_destroy_memory_pool(&pool); + + } else { + if (member->fnode->leadin) { + member->fnode->leadin--; + } else { + if (member->fnode->type == NODE_TYPE_SPEECH) { + 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, + &flags) == SWITCH_STATUS_SUCCESS) { + file_sample_len = file_data_len / 2; + } else { + file_sample_len = file_data_len = 0; + } + } else if (member->fnode->type == NODE_TYPE_FILE) { + switch_core_file_read(&member->fnode->fh, file_frame, &file_sample_len); + file_data_len = file_sample_len * 2; + } + + if (file_sample_len <= 0) { + member->fnode->done++; + } else { /* there is file node data to deliver */ + write_frame.data = file_frame; + write_frame.datalen = (uint32_t)file_data_len; + write_frame.samples = (uint32_t)file_sample_len; + /* Check for output volume adjustments */ + if (member->volume_out_level) { + switch_change_sln_volume(write_frame.data, write_frame.samples, member->volume_out_level); + } + switch_core_session_write_frame(member->session, &write_frame, -1, 0); + + /* forget the conference data we played file node data instead */ + switch_mutex_lock(member->audio_out_mutex); + switch_buffer_zero(member->mux_buffer); + switch_mutex_unlock(member->audio_out_mutex); + } + switch_core_timer_next(&timer); + } + } + } else { + switch_buffer_t *use_buffer = NULL; + uint32_t mux_used = (uint32_t)switch_buffer_inuse(member->mux_buffer); + //uint32_t res_used = member->mux_resampler ? switch_buffer_inuse(member->resample_buffer) : 0; + + if (mux_used) { + /* Flush the output buffer and write all the data (presumably muxed) back to the channel */ + switch_mutex_lock(member->audio_out_mutex); + write_frame.data = data; + use_buffer = member->mux_buffer; + + while ((write_frame.datalen = (uint32_t)switch_buffer_read(use_buffer, write_frame.data, bytes))) { + if (write_frame.datalen && switch_test_flag(member, MFLAG_CAN_HEAR)) { + write_frame.samples = write_frame.datalen / 2; + + /* Check for output volume adjustments */ + if (member->volume_out_level) { + switch_change_sln_volume(write_frame.data, write_frame.samples, member->volume_out_level); + } + + switch_core_session_write_frame(member->session, &write_frame, -1, 0); + } + } + + switch_mutex_unlock(member->audio_out_mutex); + } else { + switch_core_timer_next(&timer); + } + } + } /* Rinse ... Repeat */ + + 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))); + + // if it's an outbound channel, store the release cause in the conference struct, we might need it + if (switch_channel_test_flag(channel, CF_OUTBOUND)) { + member->conference->bridge_hangup_cause = switch_channel_get_cause(channel); + } + + /* Wait for the input thead to end */ + while(switch_test_flag(member, MFLAG_ITHREAD)) { + switch_yield(1000); + } +} + +/* Sub-Routine called by a record entity inside a conference */ +static void *SWITCH_THREAD_FUNC conference_record_thread_run(switch_thread_t *thread, void *obj) +{ + switch_frame_t write_frame = {0}; + uint8_t data[SWITCH_RECCOMMENDED_BUFFER_SIZE]; + switch_file_handle_t fh = {0}; + conference_member_t smember = {0}, *member; + conference_record_t *rec = (conference_record_t *) obj; + uint32_t divider = 1000 / rec->conference->interval; + uint32_t samples = (rec->conference->rate / divider); + uint32_t bytes = samples * 2; + uint32_t mux_used; + char *vval; + + switch_mutex_lock(globals.hash_mutex); + globals.threads++; + switch_mutex_unlock(globals.hash_mutex); + + member = &smember; + + member->flags = MFLAG_CAN_HEAR | MFLAG_NOCHANNEL | MFLAG_RUNNING; + + write_frame.data = data; + write_frame.buflen = sizeof(data); + assert(rec->conference != NULL); + + member->conference = rec->conference; + member->native_rate = rec->conference->rate; + member->rec_path = rec->path; + fh.channels = 1; + fh.samplerate = rec->conference->rate; + member->id = next_member_id(); + member->pool = rec->pool; + + switch_mutex_init(&member->flag_mutex, SWITCH_MUTEX_NESTED, rec->pool); + switch_mutex_init(&member->audio_in_mutex, SWITCH_MUTEX_NESTED, rec->pool); + switch_mutex_init(&member->audio_out_mutex, SWITCH_MUTEX_NESTED, rec->pool); + + /* Setup an audio buffer for the incoming audio */ + if (switch_buffer_create_dynamic(&member->audio_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, 0) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n"); + goto end; + } + + /* Setup an audio buffer for the outgoing audio */ + if (switch_buffer_create_dynamic(&member->mux_buffer, CONF_DBLOCK_SIZE, CONF_DBUFFER_SIZE, 0) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n"); + goto end; + } + + if (conference_add_member(rec->conference, member) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Joining Conference\n"); + goto end; + } + + 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; + } + + if ((vval = switch_mprintf("Conference %s", rec->conference->name))) { + switch_core_file_set_string(&fh, SWITCH_AUDIO_COL_STR_TITLE, vval); + switch_safe_free(vval); + } + + while(switch_test_flag(member, MFLAG_RUNNING) && switch_test_flag(rec->conference, CFLAG_RUNNING) && rec->conference->count) { + if ((mux_used = (uint32_t) switch_buffer_inuse(member->mux_buffer)) >= bytes) { + /* Flush the output buffer and write all the data (presumably muxed) to the file */ + switch_mutex_lock(member->audio_out_mutex); + write_frame.data = data; + while ((write_frame.datalen = (uint32_t)switch_buffer_read(member->mux_buffer, write_frame.data, mux_used))) { + if (!switch_test_flag((&fh), SWITCH_FILE_PAUSE)) { + switch_size_t len = (switch_size_t) mux_used / 2; + switch_core_file_write(&fh, write_frame.data, &len); + } + } + switch_mutex_unlock(member->audio_out_mutex); + } else { + switch_yield(20000); + } + } /* Rinse ... Repeat */ + + conference_del_member(rec->conference, member); + switch_buffer_destroy(&member->audio_buffer); + switch_buffer_destroy(&member->mux_buffer); + switch_clear_flag_locked(member, MFLAG_RUNNING); + switch_core_file_close(&fh); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Recording Stopped\n"); + +end: + + if (rec->pool) { + switch_memory_pool_t *pool = rec->pool; + rec = NULL; + switch_core_destroy_memory_pool(&pool); + } + + switch_mutex_lock(globals.hash_mutex); + globals.threads--; + switch_mutex_unlock(globals.hash_mutex); + + return NULL; +} + +/* Make files stop playing in a conference either the current one or all of them */ +static uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop) +{ + confernce_file_node_t *nptr; + uint32_t count = 0; + + switch_mutex_lock(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; +} + +static uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop) +{ + confernce_file_node_t *nptr; + uint32_t count = 0; + + 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++; + } + } + + switch_mutex_unlock(member->flag_mutex); + + return count; +} + +/* Play a file in the conference rooom */ +static switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + uint32_t count; + + switch_mutex_lock(conference->mutex); + switch_mutex_lock(conference->member_mutex); + count = conference->count; + switch_mutex_unlock(conference->member_mutex); + switch_mutex_unlock(conference->mutex); + + if (!count) { + return SWITCH_STATUS_FALSE; + } + +#ifdef WIN32 + if (*(file +1) != ':' && *file != '/') { +#else + if (*file != '/') { +#endif + return conference_say(conference, file, leadin); + } + + /* 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_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); + return SWITCH_STATUS_NOTFOUND; + } + + 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; + } + switch_mutex_unlock(conference->mutex); + + return SWITCH_STATUS_SUCCESS; +} + +/* Play a file in the conference rooom to a member */ +static switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + + if (*file != '/') { + return conference_member_say(member->conference, member, file, leadin); + } + + /* 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_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); + return SWITCH_STATUS_NOTFOUND; + } + + fnode->pool = pool; + + /* 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; + } + switch_mutex_unlock(member->flag_mutex); + + return SWITCH_STATUS_SUCCESS; +} + +/* Say some thing with TTS in the conference rooom */ +static switch_status_t conference_member_say(conference_obj_t *conference, conference_member_t *member, char *text, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + + if (!(conference->tts_engine && conference->tts_voice)) { + return SWITCH_STATUS_SUCCESS; + } + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_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; + + 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; + + /* 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; + } + switch_mutex_unlock(member->flag_mutex); + + /* Begin Generation */ + switch_sleep(200000); + switch_core_speech_feed_tts(&fnode->sh, text, &flags); + + return SWITCH_STATUS_SUCCESS; +} + +/* Say some thing with TTS in the conference rooom */ +static switch_status_t conference_say(conference_obj_t *conference, char *text, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + 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); + + if (!count) { + return SWITCH_STATUS_FALSE; + } + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return SWITCH_STATUS_MEMERR; + } + + /* Create a node object*/ + if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n"); + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_MEMERR; + } + + fnode->type = NODE_TYPE_SPEECH; + fnode->leadin = leadin; + + 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; + + /* 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); + + /* Begin Generation */ + switch_sleep(200000); + switch_core_speech_feed_tts(&fnode->sh, text, &flags); + + return SWITCH_STATUS_SUCCESS; +} + +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) +{ + conference_member_t *member = NULL; + + if(conference != NULL && stream != NULL && pfncallback != NULL) { + switch_mutex_lock(conference->member_mutex); + + for (member = conference->members; member; member = member->next) { + pfncallback(conference,member,member->id,stream,data); + } + switch_mutex_unlock(conference->member_mutex); + } +} + +static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim) +{ + conference_member_t *member = NULL; + + switch_mutex_lock(conference->member_mutex); + + for (member = conference->members; member; member = member->next) { + switch_channel_t *channel; + switch_caller_profile_t *profile; + char *uuid; + char *name; + uint32_t count = 0; + + if (switch_test_flag(member, MFLAG_NOCHANNEL)) { + continue; + } + + uuid = switch_core_session_get_uuid(member->session); + channel = switch_core_session_get_channel(member->session); + profile = switch_channel_get_caller_profile(channel); + name = switch_channel_get_name(channel); + + + stream->write_function(stream, "%u%s%s%s%s%s%s%s%s%s", + member->id,delim, + name,delim, + uuid,delim, + profile->caller_id_name,delim, + profile->caller_id_number, delim); + + if (switch_test_flag(member, MFLAG_CAN_HEAR)) { + stream->write_function(stream, "hear"); + count++; + } + + if (switch_test_flag(member, MFLAG_CAN_SPEAK)) { + stream->write_function(stream, "%s%s", count ? "|" : "", "speak"); + count++; + } + + stream->write_function(stream, "\n"); + } + switch_mutex_unlock(conference->member_mutex); +} + +static void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream) +{ + conference_member_t *member = NULL; + + switch_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, "*) %s (%s)\n", + profile->caller_id_name, + profile->caller_id_number + ); + + } + switch_mutex_unlock(conference->member_mutex); +} + +static int conference_function_api_mute(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + 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_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; + } + + return err; +} + +static int conference_function_api_unmute(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + 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_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; + } + + return err; +} + +static int conference_function_api_deaf(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + 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_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; + } + + return err; +} + +static int conference_function_api_undeaf(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + 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); + + 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; + } + + return err; +} + +static int conference_function_api_kick(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + 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); + + 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); + + 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; + } + + return err; +} + +static int conference_function_api_energy(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + switch_event_t *event; + + if (data) { + switch_mutex_lock(member->flag_mutex); + member->energy_level = atoi((char *)data); + switch_mutex_unlock(member->flag_mutex); + } + + stream->write_function(stream, "Energy %u=%d\n", id, member->energy_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); + + 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_fire(&event); + } + } + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + err = 1; + } + + return err; +} + +static int conference_function_api_volume_in(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + switch_event_t *event; + + if (data) { + switch_mutex_lock(member->flag_mutex); + member->volume_in_level = atoi((char *)data); + normalize_volume(member->volume_in_level); + switch_mutex_unlock(member->flag_mutex); + } + + 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); + + 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); + + switch_event_fire(&event); + } + } + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + err = 1; + } + + return err; +} + +static int conference_function_api_volume_out(conference_obj_t *conference, conference_member_t *member, int id, switch_stream_handle_t *stream, void *data) +{ + int err = 0; + + if (member != NULL || (member = conference_member_get(conference, id))) { + switch_event_t *event; + + if (data) { + switch_mutex_lock(member->flag_mutex); + member->volume_out_level = atoi((char *)data); + normalize_volume(member->volume_out_level); + switch_mutex_unlock(member->flag_mutex); + } + + stream->write_function(stream, "Volume OUT %u=%d\n", 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); + + 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); + + switch_event_fire(&event); + } + } + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + err = 1; + } + + return err; +} +static void conference_function_api_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ +// switch_event_t *event; + +} +static void conference_function_api_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + switch_event_t *event; + + if (argc == 3) { + if (conference_play_file(conference, argv[2], 0) == 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)"); + } + } else if (argc == 4) { + uint32_t id = atoi(argv[3]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + if (conference_member_play_file(member, argv[2], 0) == SWITCH_STATUS_SUCCESS) { + stream->write_function(stream, "(play) Playing file %s to member %u\n", argv[2], id); + if (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)"); + } + } else { + stream->write_function(stream, "Member: %u not found.\n", id); + } + } +} + +static void conference_function_api_say(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + /* + switch_event_t *event; + char *tbuf = NULL; + char *text; + + 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); + } + } else { + stream->write_function(stream, "(say) Error!"); + } + } + free(tbuf); + } else { + stream->write_function(stream, "(say) Error! No text."); + } + */ +} + +static void conference_function_api_saymember(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + /* + switch_event_t *event; + char *tbuf = NULL, *text, *name; + uint32_t id; + conference_member_t *member; + + if (argc > 3) { + id = atoi(argv[3]); + } else { + stream->write_function(stream, "(saymember) Syntax Error!"); + goto done; + } + + if ((tbuf = strdup(buf))) { + if ((name = strstr(tbuf, "saymember "))) { + name += 10; + + if (*name) { + text = strchr(name, ' '); + id = atoi(name); + } else { + stream->write_function(stream, "(saymember) Syntax Error!"); + goto done; + } + + 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!"); + } + + free(tbuf); + } + */ +} + +static void conference_function_api_stop(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + /* + switch_event_t *event; + uint8_t current = 0, all = 0; + + if (argc > 2) { + current = strcasecmp(argv[2], "current") ? 0 : 1; + all = strcasecmp(argv[2], "all") ? 0 : 1; + } + + 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); + } + } 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"); + } + */ +} + +static void conference_function_api_relate(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + /* + switch_event_t *event; + + 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; + + if (!strcasecmp(argv[4], "clear")) { + clear = 1; + } + + if (!(clear || nospeak || nohear)) { + stream->write_function(stream, relate_usage); + goto done; + } + + if (clear) { + conference_member_t *member = NULL; + uint32_t id = atoi(argv[2]); + uint32_t oid = atoi(argv[3]); + + 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]); + + 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); + } + + 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); + } + + + } else { + stream->write_function(stream, relate_usage); + } + */ +} + +static void conference_function_api_lock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + switch_event_t *event; + + 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); + } +} + +static void conference_function_api_unlock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + switch_event_t *event; + + 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); + } +} + +static void conference_function_api_dial(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + if (argc > 2) { + conference_outcall(conference, NULL, argv[2], 60, argv[3], argv[4], argv[5]); + stream->write_function(stream, "OK\n"); + } else { + stream->write_function(stream, "Error!\n"); + } +} + +static void conference_function_api_transfer(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + char *transfer_usage = "Usage transfer <id> <confname>\n"; + + if (argc > 3) { + conference_member_t *member = NULL; + uint32_t id = atoi(argv[2]); + 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); + goto done; + } + + channel = switch_core_session_get_channel(member->session); + + if (!(new_conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, argv[3]))) { + switch_memory_pool_t *pool; + char *conf_name; + + // 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[3]); + + 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 ((profiles = switch_xml_child(cfg, "profiles"))) { + profile = switch_xml_find_child(profiles, "profile", "name", profile_name); + } + } + + + // Release the config registry handle + if (cxml) { + switch_xml_free(cxml); + cxml = NULL; + } + + // Create the conference object. + new_conference = conference_new(conf_name, profile, pool); + + + if (!new_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) + new_conference->min = 1; + + // Indicate the conference is dynamic + switch_set_flag_locked(new_conference, CFLAG_DYNAMIC); + + // Start the conference thread for this conference + launch_conference_thread(new_conference); + } + + conference_del_member(member->last_conference, member); + conference_add_member(new_conference, member); + stream->write_function(stream, "OK Member %u sent to conference %s.\n", id, argv[3]); + + 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 { + stream->write_function(stream, transfer_usage); + } +done: + { + } +} + +static void conference_function_api_record(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + if (argc > 2) { + launch_conference_record_thread(conference, argv[2]); + } else { + stream->write_function(stream, "usage record <filename>\n"); + } +} + +static void conference_function_api_norecord(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char**argv) +{ + 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 { + stream->write_function(stream, "usage norecord <[filename | all]>\n"); + } +} + +/* API Interface Function sub-commands */ +static api_command_t conf_function_api_commands[] = { + {"list", &conference_function_api_list, 0, "<confname> list [delim <string>]"}, + {"energy", &conference_function_api_energy, 1, "<confname> energy <member_id|all> [<newval>]"}, + {"volume in", &conference_function_api_volume_in, 1, "<confname> volume_in <member_id|all> [<newval>]"}, + {"volume out", &conference_function_api_volume_out, 1, "<confname> volume_out <member_id|all> [<newval>]"}, + {"play", &conference_function_api_play, 0, "<confname> play <file_path> [<member_id>]"}, + {"say", &conference_function_api_say, 0, "<confname> say <text>"}, + {"saymember", &conference_function_api_saymember, 0, "<confname> saymember <member_id><text>"}, + {"stop", &conference_function_api_stop, 1, "<confname> stop <[current|all]> [<member_id>]"}, + {"kick", &conference_function_api_kick, 1, "<confname> kick <[member_id|all]>"}, + {"mute", &conference_function_api_mute, 1, "<confname> mute <[member_id|all]>"}, + {"unmute", &conference_function_api_unmute, 1, "<confname> unmute <[member_id|all]>"}, + {"deaf", &conference_function_api_deaf, 1, "<confname> deaf <[member_id|all]>"}, + {"undeaf", &conference_function_api_undeaf, 1, "<confname> undef <[member_id|all]>"}, + {"relate", &conference_function_api_relate, 0, "<confname> relate <member_id> <other_member_id> [nospeak|nohear]"}, + {"lock", &conference_function_api_lock, 0, "<confname> lock"}, + {"unlock", &conference_function_api_unlock, 0, "<confname> unlock"}, + {"dial", &conference_function_api_transfer, 0, "<confname> dial <endpoint_module_name>/<destination>"}, + {"transfer", &conference_function_api_transfer, 0, "<confname> transfer <member_id> <conference_name>"}, + {"record", &conference_function_api_record, 0, "<confname> record <filename>"}, + {"norecord", &conference_function_api_norecord, 0, "<confname> norecord <[filename|all]>"}, +}; + +#define CONFFUNCAPISIZE (sizeof(conf_function_api_commands)/sizeof(conf_function_api_commands[0])) + +/* API Interface Function */ +static switch_status_t conf_function(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; + + if (session) { + return SWITCH_STATUS_FALSE; + } + + if (stream->event) { + http = switch_event_get_header(stream->event, "http-host"); + } + + if (http) { + /* Output must be to a web browser */ + stream->write_function(stream, "<pre>\n"); + } + + if (buf != NULL && (lbuf = strdup(buf))) { + conference_obj_t *conference = NULL; + int argc,i; + char *argv[25]; + + argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); + + // find a command to execute + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Conference argc: %u\n",argc); + for (i=0; i<argc; i++) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Conference argv[%u]: '%u'\n",i,argv[i]); + } + if (argc) { + int i,found; + + for (i=0; i<CONFFUNCAPISIZE && !found; i++) { + if (strcasecmp(argv[i],conf_function_api_commands[i].pname) == 0) { + found = 1; + switch(conf_function_api_commands[i].fntype) { + case 0: // generic command type + break; + case 1: // member specific command that can be itteratted + { + uint32_t id = atoi(argv[2]); + int all = ( id == 0 && strcasecmp(argv[2], "all") == 0 ); + + if(all) { + conference_member_itterator(conference, stream, conf_function_api_commands[i].pfnapicmd, argv[3]); + } else { + conf_api_member_cmd_t pfn = (conf_api_member_cmd_t)conf_function_api_commands[i].pfnapicmd; + + if (pfn(conference, NULL, id, stream, argv[3])) { + stream->write_function(stream,conf_function_api_commands[i].psyntax); + } + } + + } + break; + } + } + } + } else { + stream->write_function(stream,conf_api_interface.syntax); + } + } + + if (lbuf) { + free(lbuf); + } + + return status; + +} + +static switch_status_t audio_bridge_on_ring(switch_core_session_t *session) +{ + switch_channel_t *channel = NULL; + + channel = switch_core_session_get_channel(session); + assert(channel != NULL); + + 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; +} + +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, +}; + +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; + + 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 (session) { + caller_channel = switch_core_session_get_channel(session); + switch_channel_hangup(caller_channel, cause); + } + goto done; + } + + + peer_channel = switch_core_session_get_channel(peer_session); + assert(peer_channel != NULL); + + if (caller_channel && switch_channel_test_flag(peer_channel, CF_ANSWERED)) { + switch_channel_answer(caller_channel); + } + + if (switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) { + switch_caller_extension_t *extension = NULL; + 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) { + snprintf(appdata, sizeof(appdata), "%s +flags{%s}", conference->name, flags); + switch_caller_extension_add_application(peer_session, extension, (char *) global_app_name, appdata); + } else { + switch_caller_extension_add_application(peer_session, extension, (char *) global_app_name, conference->name); + } + + switch_channel_set_caller_extension(peer_channel, extension); + switch_channel_set_state(peer_channel, CS_EXECUTE); + + } else { + switch_channel_hangup(peer_channel, SWITCH_CAUSE_NO_ANSWER); + status = SWITCH_STATUS_FALSE; + goto done; + } + +done: + 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; + + 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 (status == SWITCH_STATUS_SUCCESS) { + status = switch_ivr_play_file(session, NULL, path, NULL, NULL, NULL, 0); + } + + 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 isbr = 0; + char *dpin = 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; + } + + /* 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; + } + + + if ((flags_str=strstr(mydata, flags_prefix))) { + char *p; + + *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 (!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; + + if ((dpin = strchr(conf_name, '+'))) { + *dpin++ = '\0'; + } + + 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 ((profiles = switch_xml_child(cfg, "profiles"))) { + profile = switch_xml_find_child(profiles, "profile", "name", profile_name); + } + } + + if (isbr) { + char *uuid = switch_core_session_get_uuid(session); + + if (!strcmp(conf_name, "_uuid_")) { + conf_name = uuid; + } + + 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; + } + + /* Create the conference object. */ + conference = conference_new(conf_name, profile, pool); + + 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 = 2; + + if (dpin) { + conference->pin = switch_core_strdup(conference->pool, dpin); + } + + /* Indicate the conference is dynamic */ + switch_set_flag_locked(conference, CFLAG_DYNAMIC); + + /* Start the conference thread for this conference */ + launch_conference_thread(conference); + + } else { + /* Figure out what conference to call. */ + if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) { + freepool = pool; + } else { + /* Create the conference object. */ + conference = conference_new(conf_name, profile, pool); + + + if (!conference) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n"); + goto done; + } + + 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 = 1; + + /* Indicate the conference is dynamic */ + switch_set_flag_locked(conference, CFLAG_DYNAMIC); + + /* Start the conference thread for this conference */ + launch_conference_thread(conference); + + } + + if (conference->pin) { + char term = '\0'; + char pin[80] = ""; + char *buf; + + /* Answer the channel */ + switch_channel_answer(channel); + + if (conference->pin_sound) { + conference_local_play_file(session, conference->pin_sound, 20, pin, sizeof(pin)); + } + + if (strlen(pin) < strlen(conference->pin)) { + buf = pin + strlen(pin); + switch_ivr_collect_digits_count(session, + buf, + sizeof(pin) - (unsigned int)strlen(pin), + (unsigned int)strlen(conference->pin) - (unsigned int)strlen(pin), + "#", &term, 10000); + } + + if (strcmp(pin, conference->pin)) { + if (conference->bad_pin_sound) { + conference_local_play_file(session, conference->bad_pin_sound, 20, NULL, 0); + } + goto done; + } + } + + if (switch_test_flag(conference, CFLAG_LOCKED)) { + 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; + } + + 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; + + /* Setup a Signed Linear codec for reading audio. */ + if (switch_core_codec_init(&member.read_codec, + "L16", + NULL, + //conference->rate, + read_codec->implementation->samples_per_second, + //conference->interval, + 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; + + 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, + //read_codec->implementation->samples_per_second, + conference->interval, + //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 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 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); + + /* 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); + + msg.from = __FILE__; + + /* Tell the channel we are going to be in a bridge */ + msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE; + switch_core_session_receive_message(session, &msg); + + /* Run the confernece loop */ + conference_loop(&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); + + /* 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); + + /* 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); + + /* Release the config registry handle */ + if (cxml) { + switch_xml_free(cxml); + } + + 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); + } + + switch_core_session_reset(session); + +} + +/* Create a thread for the conference and launch it */ +static void launch_conference_thread(conference_obj_t *conference) +{ + switch_thread_t *thread; + switch_threadattr_t *thd_attr = NULL; + + switch_set_flag_locked(conference, CFLAG_RUNNING); + switch_threadattr_create(&thd_attr, conference->pool); + switch_threadattr_detach_set(thd_attr, 1); + switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); + switch_mutex_lock(globals.hash_mutex); + switch_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; + + /* 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); + } + + rec->conference = conference; + rec->path = switch_core_strdup(pool, path); + rec->pool = pool; + + switch_threadattr_create(&thd_attr, rec->pool); + switch_threadattr_detach_set(thd_attr, 1); + switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); + switch_thread_create(&thread, thd_attr, conference_record_thread_run, rec, rec->pool); +} + +static 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; + + 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 (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; + 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; +} + +/* 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; + + 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); +} + +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_api_interface_t conf_api_interface = { + /*.interface_name */ "conference", + /*.desc */ "Conference module commands", + /*.function */ conf_function, + /*.syntax */ // see switch_module_load + /*.next */ +}; + +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}; + + if (!body) { + return SWITCH_STATUS_SUCCESS; + } + + if (!(ci = switch_loadable_module_get_chat_interface(proto))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invaid Chat Interface [%s]!\n", proto); + } + + 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, from, "", "Sorry, We're Closed", ""); + return SWITCH_STATUS_FALSE; + } + + SWITCH_STANDARD_STREAM(stream); + + if (strstr(body, "list")) { + conference_list_pretty(conference, &stream); + } else { + stream.write_function(&stream, "The only command we have is so far is 'list' Get coding or go press PayPal!!\n"); + } + + ci->chat_send(CONF_CHAT_PROTO, to, from, "", stream.data, ""); + switch_safe_free(stream.data); + + + return SWITCH_STATUS_SUCCESS; +} + +static const switch_chat_interface_t conference_chat_interface = { + /*.name */ CONF_CHAT_PROTO, + /*.chat_send */ chat_send, + +}; + +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 +}; + +/* 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) +{ + 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; + + /* Conference Name */ + if (switch_strlen_zero(name)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Record! no name.\n"); + return 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; + + if ((p = strchr(var, '_'))) { + switch_copy_string(buf, var, sizeof(buf)); + for(p = buf; *p; p++) { + if (*p == '_') { + *p = '-'; + } + } + var = buf; + } + + if (!strcasecmp(var, "rate")) { + 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; + } + } + + /* Set defaults and various paramaters */ + + /* Speed in hertz */ + if (!switch_strlen_zero(rate_name)) { + uint32_t r = atoi(rate_name); + if (r) { + rate = r; + } + } + + /* Packet Interval in milliseconds */ + if (!switch_strlen_zero(interval_name)) { + uint32_t i = atoi(interval_name); + if (i) { + interval = i; + } + } + + /* Timer module to use */ + if (switch_strlen_zero(timer_name)) { + timer_name = "soft"; + } + + /* Caller ID Name */ + if (switch_strlen_zero(caller_id_name)) { + caller_id_name = (char *) global_app_name; + } + + /* Caller ID Number */ + if (switch_strlen_zero(caller_id_number)) { + caller_id_number = "0000000000"; + } + + if (!pool) { + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + status = SWITCH_STATUS_TERM; + return NULL; + } + } + + /* 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; + } + + /* Initilize the object with some settings */ + 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); + + conference->caller_id_name = switch_core_strdup(conference->pool, caller_id_name); + conference->caller_id_number = switch_core_strdup(conference->pool, caller_id_number); + + if (!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); + } + + if (!switch_strlen_zero(ack_sound)) { + conference->ack_sound = switch_core_strdup(conference->pool, ack_sound); + } + + if (!switch_strlen_zero(nack_sound)) { + conference->nack_sound = switch_core_strdup(conference->pool, nack_sound); + } + + if (!switch_strlen_zero(muted_sound)) { + conference->muted_sound = switch_core_strdup(conference->pool, muted_sound); + } + + if (!switch_strlen_zero(unmuted_sound)) { + conference->unmuted_sound = switch_core_strdup(conference->pool, unmuted_sound); + } + + if (!switch_strlen_zero(kicked_sound)) { + conference->kicked_sound = switch_core_strdup(conference->pool, kicked_sound); + } + + if (!switch_strlen_zero(pin_sound)) { + conference->pin_sound = switch_core_strdup(conference->pool, pin_sound); + } + + if (!switch_strlen_zero(bad_pin_sound)) { + conference->bad_pin_sound = switch_core_strdup(conference->pool, bad_pin_sound); + } + + if (!switch_strlen_zero(pin)) { + conference->pin = switch_core_strdup(conference->pool, pin); + } + + if (!switch_strlen_zero(alone_sound)) { + conference->alone_sound = switch_core_strdup(conference->pool, alone_sound); + } + + if (!switch_strlen_zero(locked_sound)) { + conference->locked_sound = switch_core_strdup(conference->pool, locked_sound); + } + + if (!switch_strlen_zero(energy_level)) { + conference->energy_level = atoi(energy_level); + } + + 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; + + + /* 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; +} + +/* 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) +{ + int i,nl,ol=0; + char *p = NULL; + + switch_status_t status = SWITCH_STATUS_SUCCESS; + + memset(&globals, 0, sizeof(globals)); + + // build api interface help ".syntax" field string + p=strdup("list\n"); + for (i=0; i<CONFFUNCAPISIZE; i++) { + nl=strlen(conf_function_api_commands[i].psyntax)+2; + if(p != NULL) + ol = strlen(p); + p = realloc(p,ol+nl); + if(p != NULL) { + strcat(p,"\t\t"); + strcat(p,conf_function_api_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; + + /* Connect my internal structure to the blank pointer passed to me */ + *module_interface = &conference_module_interface; + + 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 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); + + 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) { + globals.running = 0; + while (globals.threads) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Waiting for %d threads\n", globals.threads); + switch_yield(100000); + } + + // free api interface help ".syntax" field string + if (conf_api_interface.syntax != NULL) + free(conf_api_interface.syntax); + } + + return SWITCH_STATUS_SUCCESS; +}

1 0

[commit] r3230 - freeswitch/branches/knhor/wip/mod_conference
by Freeswitch SVN 30 Oct '06

30 Oct '06

Author: knhor Date: Sun Oct 29 19:52:47 2006 New Revision: 3230 Added: freeswitch/branches/knhor/wip/mod_conference/ Log: add mod_conference

1 0

[commit] r3229 - freeswitch/branches/knhor/wip
by Freeswitch SVN 30 Oct '06

30 Oct '06

Author: knhor Date: Sun Oct 29 19:52:30 2006 New Revision: 3229 Added: freeswitch/branches/knhor/wip/ Log: create the Work In Progress dir

1 0

[commit] r3224 - freeswitch/branches/ken
by Freeswitch SVN 28 Oct '06

28 Oct '06

Author: sphere Date: Sat Oct 28 15:54:05 2006 New Revision: 3224 Added: freeswitch/branches/ken/ Log: Creating empty folder for ken

1 0