void conference_loop_energy_dn(conference_member_t *member, caller_control_action_t *action)
{
char msg[512], str[30] = "", *p;
switch_event_t *event;
if (member == NULL)
return;
member->energy_level -= 200;
if (member->energy_level < 0) {
member->energy_level = 0;
}
if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
//conference_member_say(member, msg, 0);
switch_snprintf(str, sizeof(str), "%d", abs(member->energy_level) / 200);
for (p = str; p && *p; p++) {
switch_snprintf(msg, sizeof(msg), "digits/%c.wav", *p);
conference_member_play_file(member, msg, 0, SWITCH_TRUE);
}
}
static void send_report(switch_event_t *event, const char * Status) {
switch_event_t *report = NULL;
switch_event_header_t *header;
if (switch_event_create_subclass(&report, SWITCH_EVENT_CUSTOM, MY_EVENT_DELIVERY_REPORT) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(report, SWITCH_STACK_BOTTOM, "Status", Status);
for (header = event->headers; header; header = header->next) {
if (!strcmp(header->name, "Event-Subclass")) {
continue;
}
if (!strcmp(header->name, "Event-Name")) {
continue;
}
if (header->idx) {
int i;
for (i = 0; i < header->idx; i++) {
switch_event_add_header_string(report, SWITCH_STACK_PUSH, header->name, header->array[i]);
}
} else {
switch_event_add_header_string(report, SWITCH_STACK_BOTTOM, header->name, header->value);
}
}
switch_event_fire(&report);
}
}
void conference_loop_volume_listen_dn(conference_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (member == NULL)
return;
member->volume_in_level--;
switch_normalize_volume(member->volume_in_level);
if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
//conference_member_say(member, msg, 0);
if (member->volume_in_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_in_level);
conference_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_in_level));
conference_member_play_file(member, msg, 0, SWITCH_TRUE);
}
static switch_status_t http_sendfile_test_file_open(http_sendfile_data_t *http_data, switch_event_t *event)
{
switch_status_t retval = switch_file_open(&http_data->file_handle, http_data->filename_element, SWITCH_FOPEN_READ, SWITCH_FPROT_UREAD,http_data->pool);
if(retval != SWITCH_STATUS_SUCCESS)
{
if(switch_test_flag(http_data, CSO_EVENT))
{
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, HTTP_SENDFILE_ACK_EVENT) == SWITCH_STATUS_SUCCESS)
{
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Command-Execution-Identifier", http_data->identifier_str);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Filename", http_data->filename_element);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File-Access", "Failure");
switch_event_fire(&event);
switch_event_destroy(&event);
}
else
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to create event to notify of failure to open file %s\n", http_data->filename_element);
}
if((switch_test_flag(http_data, CSO_STREAM) || switch_test_flag(http_data, CSO_NONE)) && http_data->stream)
http_data->stream->write_function(http_data->stream, "-Err Unable to open file %s\n", http_data->filename_element);
if(switch_test_flag(http_data, CSO_NONE) && !http_data->stream)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "curl_sendfile: Unable to open file %s\n", http_data->filename_element);
}
return retval;
}
SWITCH_DECLARE_CONSTRUCTOR Event::Event(const char *type, const char *subclass_name)
{
switch_event_types_t event_id;
if (!strcasecmp(type, "json") && !zstr(subclass_name)) {
if (switch_event_create_json(&event, subclass_name) != SWITCH_STATUS_SUCCESS) {
return;
}
event_id = event->event_id;
} else {
if (switch_name_event(type, &event_id) != SWITCH_STATUS_SUCCESS) {
event_id = SWITCH_EVENT_MESSAGE;
}
if (!zstr(subclass_name) && event_id != SWITCH_EVENT_CUSTOM) {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_WARNING, "Changing event type to custom because you specified a subclass name!\n");
event_id = SWITCH_EVENT_CUSTOM;
}
if (switch_event_create_subclass(&event, event_id, subclass_name) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Failed to create event!\n");
event = NULL;
}
}
serialized_string = NULL;
mine = 1;
}
bool WSClientParser::ws_disconnect() {
switch_status_t status = SWITCH_STATUS_FALSE;
switch_event_t *event;
if ( (status = switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, WS_EVENT_MAINT)) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "User", mpUser);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Domain", mpDomain);
status = switch_event_fire(&event);
}
if( status != SWITCH_STATUS_SUCCESS ) {
switch_log_printf(
SWITCH_CHANNEL_UUID_LOG(this->uuid),
SWITCH_LOG_ERROR,
"WSClientParser::ws_disconnect( "
"[Send event Fail], "
"this : %p, "
"user : '******', "
"domain : '%s' "
") \n",
this,
mpUser,
mpDomain
);
}
return status == SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(switch_status_t) switch_core_hash_delete_multi(switch_hash_t *hash, switch_hash_delete_callback_t callback, void *pData) {
switch_hash_index_t *hi = NULL;
switch_event_t *event = NULL;
switch_event_header_t *header = NULL;
switch_status_t status = SWITCH_STATUS_GENERR;
switch_event_create_subclass(&event, SWITCH_EVENT_CLONE, NULL);
switch_assert(event);
/* iterate through the hash, call callback, if callback returns NULL or true, put the key on the list (event)
When done, iterate through the list deleting hash entries
*/
for (hi = switch_hash_first(NULL, hash); hi; hi = switch_hash_next(hi)) {
const void *key;
void *val;
switch_hash_this(hi, &key, NULL, &val);
if (!callback || callback(key, val, pData)) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "delete", (const char *) key);
}
}
/* now delete them */
for (header = event->headers; header; header = header->next) {
if (switch_core_hash_delete(hash, header->value) == SWITCH_STATUS_SUCCESS) {
status = SWITCH_STATUS_SUCCESS;
}
}
switch_event_destroy(&event);
return status;
}
/**
* Execute function for each subscriber
*/
static void subscriber_execute(const char *uuid, const char *signal_type, subscriber_execute_fn callback, void *user_data)
{
switch_event_t *subscriber_list = NULL;
switch_event_header_t *subscriber = NULL;
/* fetch list of subscribers */
char *key = switch_mprintf("%s:%s", uuid, signal_type);
switch_event_create_subclass(&subscriber_list, SWITCH_EVENT_CLONE, NULL);
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(uuid), SWITCH_LOG_DEBUG, "Subscriber execute %s\n", signal_type);
switch_mutex_lock(globals.subscribers_mutex);
{
switch_hash_index_t *hi = NULL;
switch_hash_t *signal_subscribers = switch_core_hash_find(globals.subscribers, key);
if (signal_subscribers) {
for (hi = switch_core_hash_first(signal_subscribers); hi; hi = switch_core_hash_next(hi)) {
const void *jid;
void *dont_care;
switch_core_hash_this(hi, &jid, NULL, &dont_care);
switch_event_add_header_string(subscriber_list, SWITCH_STACK_BOTTOM, "execute", (const char *)jid);
}
} else {
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(uuid), SWITCH_LOG_DEBUG, "No subscribers for %s\n", signal_type);
}
}
switch_mutex_unlock(globals.subscribers_mutex);
switch_safe_free(key);
/* execute function for each subscriber */
for (subscriber = subscriber_list->headers; subscriber; subscriber = subscriber->next) {
callback(subscriber->value, user_data);
}
switch_event_destroy(&subscriber_list);
}
static void *torture_thread(switch_thread_t *thread, void *obj)
{
int y = 0;
int z = 0;
switch_core_thread_session_t *ts = obj;
switch_event_t *event;
z = THREADS++;
while (THREADS > 0) {
int x;
for (x = 0; x < 1; x++) {
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, MY_EVENT_COOL) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, "event_info", "hello world %d %d", z, y++);
switch_event_fire(&event);
}
}
switch_yield(100000);
}
if (ts->pool) {
switch_memory_pool_t *pool = ts->pool;
switch_core_destroy_memory_pool(&pool);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Thread Ended\n");
}
void conference_loop_exec_app(conference_member_t *member, caller_control_action_t *action)
{
char *app = NULL;
char *arg = "";
char *argv[2] = { 0 };
int argc;
char *mydata = NULL;
switch_event_t *event = NULL;
switch_channel_t *channel = NULL;
if (!action->expanded_data) return;
if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "execute_app");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", action->expanded_data);
switch_event_fire(&event);
}
mydata = strdup(action->expanded_data);
switch_assert(mydata);
if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
if (argc > 0) {
app = argv[0];
}
if (argc > 1) {
arg = argv[1];
}
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Empty execute app string [%s]\n",
(char *) action->expanded_data);
goto done;
}
if (!app) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to find application.\n");
goto done;
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_INFO, "Execute app: %s, %s\n", app, arg);
channel = switch_core_session_get_channel(member->session);
switch_channel_set_app_flag(channel, CF_APP_TAGGED);
switch_core_session_set_read_codec(member->session, NULL);
switch_core_session_execute_application(member->session, app, arg);
switch_core_session_set_read_codec(member->session, &member->read_codec);
switch_channel_clear_app_flag(channel, CF_APP_TAGGED);
done:
switch_safe_free(mydata);
return;
}
void conference_loop_event(conference_member_t *member, caller_control_action_t *action)
{
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "dtmf");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "DTMF-Key", action->binded_dtmf);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Data", action->expanded_data);
switch_event_fire(&event);
}
}
void stop_all_websockets()
{
switch_event_t *event;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, "websocket::stophook") != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Failed to create event!\n");
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "stop", "now");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "stopping all websockets ...\n");
if (switch_event_fire(&event) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Failed to fire the event!\n");
switch_event_destroy(&event);
}
}
cc_status_t cc_agent_get(const char *key, const char *agent, char *ret_result, size_t ret_result_size)
{
cc_status_t result = CC_STATUS_SUCCESS;
char *sql;
switch_event_t *event;
char res[256];
/* Check to see if agent already exists */
sql = switch_mprintf("SELECT count(*) FROM agents WHERE name = '%q'", agent);
cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));
switch_safe_free(sql);
if (atoi(res) == 0) {
result = CC_STATUS_AGENT_NOT_FOUND;
goto done;
}
if (!strcasecmp(key, "status") || !strcasecmp(key, "state") || !strcasecmp(key, "uuid") ) {
/* Check to see if agent already exists */
sql = switch_mprintf("SELECT %q FROM agents WHERE name = '%q'", key, agent);
cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));
switch_safe_free(sql);
switch_snprintf(ret_result, ret_result_size, "%s", res);
result = CC_STATUS_SUCCESS;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CALLCENTER_EVENT) == SWITCH_STATUS_SUCCESS) {
char tmpname[256];
if (!strcasecmp(key, "uuid")) {
switch_snprintf(tmpname, sizeof(tmpname), "CC-Agent-UUID");
} else {
switch_snprintf(tmpname, sizeof(tmpname), "CC-Agent-%c%s", (char) switch_toupper(key[0]), key+1);
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Agent", agent);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "CC-Action", "agent-%s-get", key);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, tmpname, res);
switch_event_fire(&event);
}
} else {
result = CC_STATUS_INVALID_KEY;
goto done;
}
done:
if (result == CC_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Get Info Agent %s %s = %s\n", agent, key, res);
}
return result;
}
/*
* chiedo alla patch tutte le chiamate. Probabilmente ritorna una una insert con tutte le chiamate da inserire.
* usata all'avvio di un nuovo nodo che deve ricostrurie lo stato delle chiamate in corso alla sua accensione.
*/
void utils_send_request_all(char *profile_name)
{
switch_event_t *event = NULL;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, "sofia::recovery_recv") == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "profile_name", profile_name);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "request_all","true");
switch_event_fire(&event);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "request_all sent to sofia\n");
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "request_all not sent to sofia\n");
}
}
void conference_loop_lock_toggle(conference_member_t *member, caller_control_action_t *action)
{
switch_event_t *event;
if (member == NULL)
return;
if (conference_utils_test_flag(member->conference, CFLAG_WAIT_MOD) && !conference_utils_member_test_flag(member, MFLAG_MOD) )
return;
if (!conference_utils_test_flag(member->conference, CFLAG_LOCKED)) {
if (member->conference->is_locked_sound) {
conference_file_play(member->conference, member->conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
}
conference_utils_set_flag_locked(member->conference, CFLAG_LOCKED);
if (test_eflag(member->conference, EFLAG_LOCK) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_event_add_data(member->conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "lock");
switch_event_fire(&event);
}
} else {
if (member->conference->is_unlocked_sound) {
conference_file_play(member->conference, member->conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
}
conference_utils_clear_flag_locked(member->conference, CFLAG_LOCKED);
if (test_eflag(member->conference, EFLAG_UNLOCK) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_event_add_data(member->conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
switch_event_fire(&event);
}
}
}
static switch_event_t *get_extra_headers(oreka_session_t *oreka, oreka_recording_status_t status)
{
switch_event_t *extra_headers = NULL;
switch_channel_t *channel = NULL;
switch_core_session_t *session = oreka->session;
channel = switch_core_session_get_channel(session);
if (status == FS_OREKA_START) {
if (!oreka->invite_extra_headers) {
switch_event_create_subclass(&oreka->invite_extra_headers, SWITCH_EVENT_CLONE, NULL);
switch_assert(oreka->invite_extra_headers);
save_extra_headers(oreka->invite_extra_headers, channel);
}
extra_headers = oreka->invite_extra_headers;
} else if (status == FS_OREKA_STOP) {
if (!oreka->bye_extra_headers) {
switch_event_create_subclass(&oreka->bye_extra_headers, SWITCH_EVENT_CLONE, NULL);
switch_assert(oreka->bye_extra_headers);
save_extra_headers(oreka->bye_extra_headers, channel);
}
extra_headers = oreka->bye_extra_headers;
}
return extra_headers;
}
SWITCH_DECLARE(void) switch_limit_fire_event(const char *backend, const char *realm, const char *key, uint32_t usage, uint32_t rate, uint32_t max, uint32_t ratemax)
{
switch_event_t *event;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, LIMIT_EVENT_USAGE) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "backend", backend);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "realm", realm);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", key);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "usage", "%d", usage);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rate", "%d", rate);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "max", "%d", max);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "ratemax", "%d", ratemax);
switch_event_fire(&event);
}
}
void BoardE1::onLinkStatus(K3L_EVENT *e)
{
DBG(FUNC, D("Link %02hu on board %02hu changed") % e->AddInfo % e->DeviceId);
/* Fire a custom event about this */
switch_event_t * event;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, KHOMP_EVENT_MAINT) == SWITCH_STATUS_SUCCESS)
{
//khomp_add_event_board_data(e->AddInfo, event);
Board::khomp_add_event_board_data(K3LAPI::target(Globals::k3lapi, K3LAPI::target::LINK, e->DeviceId, e->AddInfo), event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "EV_LINK_STATUS", "%d", e->AddInfo);
switch_event_fire(&event);
}
}
static switch_status_t handle_msg_sendevent(listener_t *listener, int arity, ei_x_buff * buf, ei_x_buff * rbuf)
{
char ename[MAXATOMLEN + 1];
char esname[MAXATOMLEN + 1];
int headerlength;
memset(esname, 0, MAXATOMLEN);
if (ei_decode_atom(buf->buff, &buf->index, ename) ||
(!strncasecmp(ename, "CUSTOM", MAXATOMLEN) &&
ei_decode_atom(buf->buff, &buf->index, esname)) || ei_decode_list_header(buf->buff, &buf->index, &headerlength)) {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "badarg");
} else {
switch_event_types_t etype;
if (switch_name_event(ename, &etype) == SWITCH_STATUS_SUCCESS) {
switch_event_t *event;
if ((strlen(esname) && switch_event_create_subclass(&event, etype, esname) == SWITCH_STATUS_SUCCESS) ||
switch_event_create(&event, etype) == SWITCH_STATUS_SUCCESS) {
char key[1024];
char value[1024];
int i = 0;
switch_bool_t fail = SWITCH_FALSE;
while (!ei_decode_tuple_header(buf->buff, &buf->index, &arity) && arity == 2) {
i++;
if (ei_decode_string(buf->buff, &buf->index, key) || ei_decode_string(buf->buff, &buf->index, value)) {
fail = SWITCH_TRUE;
break;
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, key, value);
}
if (headerlength != i || fail) {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "badarg");
} else {
switch_event_fire(&event);
ei_x_encode_atom(rbuf, "ok");
}
}
}
}
return SWITCH_STATUS_SUCCESS;
}
void conference_loop_transfer(conference_member_t *member, caller_control_action_t *action)
{
char *exten = NULL;
char *dialplan = "XML";
char *context = "default";
char *argv[3] = { 0 };
int argc;
char *mydata = NULL;
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Dialplan", action->expanded_data);
switch_event_fire(&event);
}
conference_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
if ((mydata = switch_core_session_strdup(member->session, action->expanded_data))) {
if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
if (argc > 0) {
exten = argv[0];
}
if (argc > 1) {
dialplan = argv[1];
}
if (argc > 2) {
context = argv[2];
}
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Empty transfer string [%s]\n", (char *) action->expanded_data);
goto done;
}
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to allocate memory to duplicate transfer data.\n");
goto done;
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_INFO, "Transfering to: %s, %s, %s\n", exten, dialplan, context);
switch_ivr_session_transfer(member->session, exten, dialplan, context);
done:
return;
}
static void put_text_msg(void *user_data, const uint8_t *msg, int len)
{
switch_tdd_t *pvt = (switch_tdd_t *) user_data;
switch_event_t *event, *clone;
switch_channel_t *channel = switch_core_session_get_channel(pvt->session);
switch_core_session_t *other_session;
switch_channel_add_variable_var_check(channel, "tdd_messages", (char *)msg, SWITCH_FALSE, SWITCH_STACK_PUSH);
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, MY_EVENT_TDD_RECV_MESSAGE) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", "mod_spandsp");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", "tdd");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "subject", "TDD MESSAGE");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "TDD-Data", (char *)msg);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(pvt->session));
switch_event_add_body(event, "%s\n\n", (char *)msg);
if (switch_core_session_get_partner(pvt->session, &other_session) == SWITCH_STATUS_SUCCESS) {
if (switch_event_dup(&clone, event) == SWITCH_STATUS_SUCCESS) {
switch_core_session_receive_event(other_session, &clone);
}
if (switch_event_dup(&clone, event) == SWITCH_STATUS_SUCCESS) {
switch_core_session_queue_event(other_session, &clone);
}
switch_core_session_rwunlock(other_session);
}
switch_event_fire(&event);
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(pvt->session), SWITCH_LOG_DEBUG, "%s got TDD Message [%s]\n", switch_channel_get_name(channel), (char *)msg);
}
switch_status_t skinny_device_event(listener_t *listener, switch_event_t **ev, switch_event_types_t event_id, const char *subclass_name)
{
switch_event_t *event = NULL;
char *sql;
skinny_profile_t *profile;
assert(listener->profile);
profile = listener->profile;
switch_event_create_subclass(&event, event_id, subclass_name);
switch_assert(event);
if ((sql = switch_mprintf("SELECT '%s', name, user_id, instance, ip, type, max_streams, port, codec_string "
"FROM skinny_devices "
"WHERE name='%s' AND instance=%d",
listener->profile->name,
listener->device_name, listener->device_instance))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_device_event_callback, event);
switch_safe_free(sql);
}
*ev = event;
return SWITCH_STATUS_SUCCESS;
}
static void http_sendfile_success_report(http_sendfile_data_t *http_data, switch_event_t *event)
{
if(switch_test_flag(http_data, CSO_EVENT))
{
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, HTTP_SENDFILE_ACK_EVENT) == SWITCH_STATUS_SUCCESS)
{
char *code_as_string = switch_core_alloc(http_data->pool, 16);
memset(code_as_string, 0, 16);
switch_snprintf(code_as_string, 16, "%d", http_data->http_response_code);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Command-Execution-Identifier", http_data->identifier_str);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Filename", http_data->filename_element);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "File-Access", "Success");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "REST-HTTP-Code", code_as_string);
switch_event_add_body(event, "%s", http_data->sendfile_response);
switch_event_fire(&event);
switch_event_destroy(&event);
}
else
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to create a event to report on success of curl_sendfile.\n");
}
if((switch_test_flag(http_data, CSO_STREAM) || switch_test_flag(http_data, CSO_NONE) || switch_test_flag(http_data, CSO_EVENT)) && http_data->stream)
{
if(http_data->http_response_code == 200)
http_data->stream->write_function(http_data->stream, "+200 Ok\n");
else
http_data->stream->write_function(http_data->stream, "-%d Err\n", http_data->http_response_code);
if(http_data->sendfile_response_count && switch_test_flag(http_data, CSO_STREAM))
http_data->stream->write_function(http_data->stream, "%s\n", http_data->sendfile_response);
}
if(switch_test_flag(http_data, CSO_NONE) && !http_data->stream)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Sending of file %s to url %s resulted with code %lu\n", http_data->filename_element, http_data->url, http_data->http_response_code);
}
/* marshall frames from the call leg to the conference thread for muxing to other call legs */
void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj)
{
switch_event_t *event;
conference_member_t *member = obj;
switch_channel_t *channel;
switch_status_t status;
switch_frame_t *read_frame = NULL;
uint32_t hangover = 40, hangunder = 5, hangover_hits = 0, hangunder_hits = 0, diff_level = 400;
switch_core_session_t *session = member->session;
uint32_t flush_len;
switch_frame_t tmp_frame = { 0 };
if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
goto end;
}
switch_assert(member != NULL);
conference_utils_member_clear_flag_locked(member, MFLAG_TALKING);
channel = switch_core_session_get_channel(session);
switch_core_session_get_read_impl(session, &member->read_impl);
switch_channel_audio_sync(channel);
flush_len = switch_samples_per_packet(member->conference->rate, member->conference->interval) * 2 * member->conference->channels * (500 / member->conference->interval);
/* 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 (conference_utils_member_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {
if (switch_channel_ready(channel) && switch_channel_test_app_flag(channel, CF_APP_TAGGED)) {
switch_yield(100000);
continue;
}
/* Read a frame. */
status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
switch_mutex_lock(member->read_mutex);
/* end the loop, if appropriate */
if (!SWITCH_READ_ACCEPTABLE(status) || !conference_utils_member_test_flag(member, MFLAG_RUNNING)) {
switch_mutex_unlock(member->read_mutex);
break;
}
if (switch_channel_test_flag(channel, CF_VIDEO) && !conference_utils_member_test_flag(member, MFLAG_ACK_VIDEO)) {
conference_utils_member_set_flag_locked(member, MFLAG_ACK_VIDEO);
conference_video_check_avatar(member, SWITCH_FALSE);
switch_core_session_video_reinit(member->session);
conference_video_set_floor_holder(member->conference, member, SWITCH_FALSE);
} else if (conference_utils_member_test_flag(member, MFLAG_ACK_VIDEO) && !switch_channel_test_flag(channel, CF_VIDEO)) {
conference_video_check_avatar(member, SWITCH_FALSE);
}
/* if we have caller digits, feed them to the parser to find an action */
if (switch_channel_has_dtmf(channel)) {
char dtmf[128] = "";
switch_channel_dequeue_dtmf_string(channel, dtmf, sizeof(dtmf));
if (conference_utils_member_test_flag(member, MFLAG_DIST_DTMF)) {
conference_member_send_all_dtmf(member, member->conference, dtmf);
} else if (member->dmachine) {
char *p;
char str[2] = "";
for (p = dtmf; p && *p; p++) {
str[0] = *p;
switch_ivr_dmachine_feed(member->dmachine, str, NULL);
}
}
} else if (member->dmachine) {
switch_ivr_dmachine_ping(member->dmachine, NULL);
}
if (switch_queue_size(member->dtmf_queue)) {
switch_dtmf_t *dt;
void *pop;
if (switch_queue_trypop(member->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
dt = (switch_dtmf_t *) pop;
switch_core_session_send_dtmf(member->session, dt);
free(dt);
}
}
if (switch_channel_test_flag(member->channel, CF_CONFERENCE_RESET_MEDIA)) {
member->reset_media = 10;
switch_channel_audio_sync(member->channel);
switch_channel_clear_flag(member->channel, CF_CONFERENCE_RESET_MEDIA);
}
if (member->reset_media) {
if (--member->reset_media > 0) {
goto do_continue;
}
if (conference_member_setup_media(member, member->conference)) {
switch_mutex_unlock(member->read_mutex);
break;
}
member->loop_loop = 1;
goto do_continue;
}
if (switch_test_flag(read_frame, SFF_CNG)) {
if (member->conference->agc_level) {
member->nt_tally++;
}
if (hangunder_hits) {
hangunder_hits--;
}
if (conference_utils_member_test_flag(member, MFLAG_TALKING)) {
if (++hangover_hits >= hangover) {
hangover_hits = hangunder_hits = 0;
conference_utils_member_clear_flag_locked(member, MFLAG_TALKING);
conference_member_update_status_field(member);
conference_member_check_agc_levels(member);
conference_member_clear_avg(member);
member->score_iir = 0;
member->floor_packets = 0;
if (test_eflag(member->conference, EFLAG_STOP_TALKING) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking");
switch_event_fire(&event);
}
}
}
goto do_continue;
}
if (member->nt_tally > (int32_t)(member->read_impl.actual_samples_per_second / member->read_impl.samples_per_packet) * 3) {
member->agc_volume_in_level = 0;
conference_member_clear_avg(member);
}
/* Check for input volume adjustments */
if (!member->conference->agc_level) {
member->conference->agc_level = 0;
conference_member_clear_avg(member);
}
/* if the member can speak, compute the audio energy level and */
/* generate events when the level crosses the threshold */
if ((conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK) || conference_utils_member_test_flag(member, MFLAG_MUTE_DETECT))) {
uint32_t energy = 0, i = 0, samples = 0, j = 0;
int16_t *data;
int agc_period = (member->read_impl.actual_samples_per_second / member->read_impl.samples_per_packet) / 4;
data = read_frame->data;
member->score = 0;
if (member->volume_in_level) {
switch_change_sln_volume(read_frame->data, (read_frame->datalen / 2) * member->conference->channels, member->volume_in_level);
}
if (member->agc_volume_in_level) {
switch_change_sln_volume_granular(read_frame->data, (read_frame->datalen / 2) * member->conference->channels, member->agc_volume_in_level);
}
if ((samples = read_frame->datalen / sizeof(*data) / member->read_impl.number_of_channels)) {
for (i = 0; i < samples; i++) {
energy += abs(data[j]);
j += member->read_impl.number_of_channels;
}
member->score = energy / samples;
}
if (member->vol_period) {
member->vol_period--;
}
if (member->conference->agc_level && member->score &&
conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK) &&
conference_member_noise_gate_check(member)
) {
int last_shift = abs((int)(member->last_score - member->score));
if (member->score && member->last_score && last_shift > 900) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG7,
"AGC %s:%d drop anomalous shift of %d\n",
member->conference->name,
member->id, last_shift);
} else {
member->avg_tally += member->score;
member->avg_itt++;
if (!member->avg_itt) member->avg_itt++;
member->avg_score = member->avg_tally / member->avg_itt;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG7,
"AGC %s:%d diff:%d level:%d cur:%d avg:%d vol:%d\n",
member->conference->name,
member->id, member->conference->agc_level - member->avg_score, member->conference->agc_level,
member->score, member->avg_score, member->agc_volume_in_level);
if (++member->agc_concur >= agc_period) {
if (!member->vol_period) {
conference_member_check_agc_levels(member);
}
member->agc_concur = 0;
}
} else {
member->nt_tally++;
}
member->score_iir = (int) (((1.0 - SCORE_DECAY) * (float) member->score) + (SCORE_DECAY * (float) member->score_iir));
if (member->score_iir > SCORE_MAX_IIR) {
member->score_iir = SCORE_MAX_IIR;
}
if (conference_member_noise_gate_check(member)) {
uint32_t diff = member->score - member->energy_level;
if (hangover_hits) {
hangover_hits--;
}
if (member->conference->agc_level) {
member->nt_tally = 0;
}
if (member == member->conference->floor_holder) {
member->floor_packets++;
}
if (diff >= diff_level || ++hangunder_hits >= hangunder) {
hangover_hits = hangunder_hits = 0;
member->last_talking = switch_epoch_time_now(NULL);
if (!conference_utils_member_test_flag(member, MFLAG_TALKING)) {
conference_utils_member_set_flag_locked(member, MFLAG_TALKING);
conference_member_update_status_field(member);
member->floor_packets = 0;
if (test_eflag(member->conference, EFLAG_START_TALKING) && conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "start-talking");
switch_event_fire(&event);
}
if (conference_utils_member_test_flag(member, MFLAG_MUTE_DETECT) && !conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
if (!zstr(member->conference->mute_detect_sound)) {
conference_utils_member_set_flag(member, MFLAG_INDICATE_MUTE_DETECT);
}
if (test_eflag(member->conference, EFLAG_MUTE_DETECT) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "mute-detect");
switch_event_fire(&event);
}
}
}
}
} else {
if (hangunder_hits) {
hangunder_hits--;
}
if (member->conference->agc_level) {
member->nt_tally++;
}
if (conference_utils_member_test_flag(member, MFLAG_TALKING) && conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
switch_event_t *event;
if (++hangover_hits >= hangover) {
hangover_hits = hangunder_hits = 0;
conference_utils_member_clear_flag_locked(member, MFLAG_TALKING);
conference_member_update_status_field(member);
conference_member_check_agc_levels(member);
conference_member_clear_avg(member);
if (test_eflag(member->conference, EFLAG_STOP_TALKING) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
conference_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking");
switch_event_fire(&event);
}
}
}
}
member->last_score = member->score;
if (member == member->conference->floor_holder) {
if (member->id != member->conference->video_floor_holder &&
(member->floor_packets > member->conference->video_floor_packets || member->energy_level == 0)) {
conference_video_set_floor_holder(member->conference, member, SWITCH_FALSE);
}
}
}
/* skip frames that are not actual media or when we are muted or silent */
if ((conference_utils_member_test_flag(member, MFLAG_TALKING) || member->energy_level == 0 || conference_utils_test_flag(member->conference, CFLAG_AUDIO_ALWAYS))
&& conference_utils_member_test_flag(member, MFLAG_CAN_SPEAK) && !conference_utils_test_flag(member->conference, CFLAG_WAIT_MOD)
&& (member->conference->count > 1 || (member->conference->record_count && member->conference->count >= member->conference->min_recording_participants))) {
switch_audio_resampler_t *read_resampler = member->read_resampler;
void *data;
uint32_t datalen;
if (read_resampler) {
int16_t *bptr = (int16_t *) read_frame->data;
int len = (int) read_frame->datalen;
switch_resample_process(read_resampler, bptr, len / 2 / member->read_impl.number_of_channels);
memcpy(member->resample_out, read_resampler->to, read_resampler->to_len * 2 * member->read_impl.number_of_channels);
len = read_resampler->to_len * 2 * member->read_impl.number_of_channels;
datalen = len;
data = member->resample_out;
} else {
data = read_frame->data;
datalen = read_frame->datalen;
}
tmp_frame.data = data;
tmp_frame.datalen = datalen;
tmp_frame.rate = member->conference->rate;
conference_member_check_channels(&tmp_frame, member, SWITCH_TRUE);
if (datalen) {
switch_size_t ok = 1;
/* Write the audio into the input buffer */
switch_mutex_lock(member->audio_in_mutex);
if (switch_buffer_inuse(member->audio_buffer) > flush_len) {
switch_buffer_toss(member->audio_buffer, tmp_frame.datalen);
}
ok = switch_buffer_write(member->audio_buffer, tmp_frame.data, tmp_frame.datalen);
switch_mutex_unlock(member->audio_in_mutex);
if (!ok) {
switch_mutex_unlock(member->read_mutex);
break;
}
}
}
do_continue:
switch_mutex_unlock(member->read_mutex);
}
if (switch_queue_size(member->dtmf_queue)) {
switch_dtmf_t *dt;
void *pop;
while (switch_queue_trypop(member->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
dt = (switch_dtmf_t *) pop;
free(dt);
}
}
switch_resample_destroy(&member->read_resampler);
switch_core_session_rwunlock(session);
end:
conference_utils_member_clear_flag_locked(member, MFLAG_ITHREAD);
return NULL;
}
static void event_handler(switch_event_t *event)
{
uint8_t send = 0;
if (globals.running != 1) {
return;
}
if (event->subclass_name && (!strcmp(event->subclass_name, MULTICAST_EVENT) ||
!strcmp(event->subclass_name, MULTICAST_PEERUP) || !strcmp(event->subclass_name, MULTICAST_PEERDOWN))) {
char *event_name, *sender;
if ((event_name = switch_event_get_header(event, "orig-event-name")) &&
!strcasecmp(event_name, "HEARTBEAT") && (sender = switch_event_get_header(event, "orig-multicast-sender"))) {
struct peer_status *p;
time_t now = switch_epoch_time_now(NULL);
if (!(p = switch_core_hash_find(globals.peer_hash, sender))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Host %s not already in hash\n", sender);
p = switch_core_alloc(module_pool, sizeof(struct peer_status));
p->active = SWITCH_FALSE;
p->lastseen = 0;
/*} else { */
/*switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Host %s last seen %d seconds ago\n", sender, now - p->lastseen); */
}
if (!p->active) {
switch_event_t *local_event;
if (switch_event_create_subclass(&local_event, SWITCH_EVENT_CUSTOM, MULTICAST_PEERUP) == SWITCH_STATUS_SUCCESS) {
char lastseen[21];
switch_event_add_header_string(local_event, SWITCH_STACK_BOTTOM, "Peer", sender);
if (p->lastseen) {
switch_snprintf(lastseen, sizeof(lastseen), "%d", (int) p->lastseen);
} else {
switch_snprintf(lastseen, sizeof(lastseen), "%s", "Never");
}
switch_event_add_header_string(local_event, SWITCH_STACK_BOTTOM, "Lastseen", lastseen);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Peer %s has come up; last seen: %s\n", sender, lastseen);
switch_event_fire(&local_event);
}
}
p->active = SWITCH_TRUE;
p->lastseen = now;
switch_core_hash_insert(globals.peer_hash, sender, p);
}
/* ignore our own events to avoid ping pong */
return;
}
if (event->event_id == SWITCH_EVENT_RELOADXML) {
switch_mutex_lock(globals.mutex);
switch_core_hash_destroy(&globals.event_hash);
globals.event_hash = NULL;
if (globals.psk) {
switch_safe_free(globals.psk);
globals.psk = NULL;
}
switch_core_hash_init(&globals.event_hash, module_pool);
memset(globals.event_list, 0, SWITCH_EVENT_ALL + 1);
if (load_config() != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to reload config file\n");
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Event Multicast Reloaded\n");
}
switch_mutex_unlock(globals.mutex);
}
if (event->event_id == SWITCH_EVENT_HEARTBEAT) {
switch_hash_index_t *cur;
switch_ssize_t keylen;
const void *key;
void *value;
time_t now = switch_epoch_time_now(NULL);
struct peer_status *last;
char *host;
for (cur = switch_hash_first(NULL, globals.peer_hash); cur; cur = switch_hash_next(cur)) {
switch_hash_this(cur, &key, &keylen, &value);
host = (char *) key;
last = (struct peer_status *) value;
if (last->active && (now - (last->lastseen)) > 60) {
switch_event_t *local_event;
last->active = SWITCH_FALSE;
if (switch_event_create_subclass(&local_event, SWITCH_EVENT_CUSTOM, MULTICAST_PEERDOWN) == SWITCH_STATUS_SUCCESS) {
char lastseen[21];
switch_event_add_header_string(local_event, SWITCH_STACK_BOTTOM, "Peer", host);
switch_snprintf(lastseen, sizeof(lastseen), "%d", (int) last->lastseen);
switch_event_add_header_string(local_event, SWITCH_STACK_BOTTOM, "Lastseen", lastseen);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Peer %s has gone down; last seen: %s\n", host, lastseen);
switch_event_fire(&local_event);
}
}
}
}
switch_mutex_lock(globals.mutex);
if (globals.event_list[(uint8_t) SWITCH_EVENT_ALL]) {
send = 1;
} else if ((globals.event_list[(uint8_t) event->event_id])) {
if (event->event_id != SWITCH_EVENT_CUSTOM || (event->subclass_name && switch_core_hash_find(globals.event_hash, event->subclass_name))) {
send = 1;
}
}
switch_mutex_unlock(globals.mutex);
if (send) {
char *packet;
switch (event->event_id) {
case SWITCH_EVENT_LOG:
return;
default:
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Multicast-Sender", switch_core_get_switchname());
if (switch_event_serialize(event, &packet, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
size_t len;
char *buf;
#ifdef HAVE_OPENSSL
int outlen, tmplen;
EVP_CIPHER_CTX ctx;
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
switch_uuid_t uuid;
switch_uuid_get(&uuid);
switch_uuid_format(uuid_str, &uuid);
len = strlen(packet) + SWITCH_UUID_FORMATTED_LENGTH + EVP_MAX_IV_LENGTH + strlen((char *) MAGIC);
#else
len = strlen(packet) + strlen((char *) MAGIC);
#endif
buf = malloc(len + 1);
memset(buf, 0, len + 1);
switch_assert(buf);
#ifdef HAVE_OPENSSL
if (globals.psk) {
switch_copy_string(buf, uuid_str, SWITCH_UUID_FORMATTED_LENGTH);
EVP_CIPHER_CTX_init(&ctx);
EVP_EncryptInit(&ctx, EVP_bf_cbc(), NULL, NULL);
EVP_CIPHER_CTX_set_key_length(&ctx, strlen(globals.psk));
EVP_EncryptInit(&ctx, NULL, (unsigned char *) globals.psk, (unsigned char *) uuid_str);
EVP_EncryptUpdate(&ctx, (unsigned char *) buf + SWITCH_UUID_FORMATTED_LENGTH,
&outlen, (unsigned char *) packet, (int) strlen(packet));
EVP_EncryptUpdate(&ctx, (unsigned char *) buf + SWITCH_UUID_FORMATTED_LENGTH + outlen,
&tmplen, (unsigned char *) MAGIC, (int) strlen((char *) MAGIC));
outlen += tmplen;
EVP_EncryptFinal(&ctx, (unsigned char *) buf + SWITCH_UUID_FORMATTED_LENGTH + outlen, &tmplen);
outlen += tmplen;
len = (size_t) outlen + SWITCH_UUID_FORMATTED_LENGTH;
*(buf + SWITCH_UUID_FORMATTED_LENGTH + outlen) = '\0';
} else {
#endif
switch_copy_string(buf, packet, len);
switch_copy_string(buf + strlen(packet), (char *) MAGIC, strlen((char *) MAGIC) + 1);
#ifdef HAVE_OPENSSL
}
#endif
switch_socket_sendto(globals.udp_socket, globals.addr, 0, buf, &len);
switch_safe_free(packet);
switch_safe_free(buf);
}
break;
}
}
return;
}
cc_status_t cc_agent_update(const char *key, const char *value, const char *agent)
{
cc_status_t result = CC_STATUS_SUCCESS;
char *sql;
char res[256];
switch_event_t *event;
/* Check to see if agent already exist */
sql = switch_mprintf("SELECT count(*) FROM agents WHERE name = '%q'", agent);
cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));
switch_safe_free(sql);
if (atoi(res) == 0) {
result = CC_STATUS_AGENT_NOT_FOUND;
goto done;
}
if (!strcasecmp(key, "status")) {
if (cc_agent_str2status(value) != CC_AGENT_STATUS_UNKNOWN) {
/* Reset values on available only */
if (cc_agent_str2status(value) == CC_AGENT_STATUS_AVAILABLE) {
sql = switch_mprintf("UPDATE agents SET status = '%q', last_status_change = '%" SWITCH_TIME_T_FMT "', talk_time = 0, calls_answered = 0, no_answer_count = 0"
" WHERE name = '%q' AND NOT status = '%q'",
value, local_epoch_time_now(NULL),
agent, value);
} else {
sql = switch_mprintf("UPDATE agents SET status = '%q', last_status_change = '%" SWITCH_TIME_T_FMT "' WHERE name = '%q'",
value, local_epoch_time_now(NULL), agent);
}
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
/* Used to stop any active callback */
if (cc_agent_str2status(value) != CC_AGENT_STATUS_AVAILABLE) {
sql = switch_mprintf("SELECT uuid FROM members WHERE serving_agent = '%q' AND serving_system = 'single_box' AND NOT state = 'Answered'", agent);
cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));
switch_safe_free(sql);
if (!switch_strlen_zero(res)) {
// switch_core_session_hupall_matching_var("cc_member_pre_answer_uuid", res, SWITCH_CAUSE_ORIGINATOR_CANCEL);
/*hmeng*/
switch_core_session_hupall_matching_var_ans("cc_member_pre_answer_uuid", res, SWITCH_CAUSE_ORIGINATOR_CANCEL, (switch_hup_type_t) (SHT_UNANSWERED | SHT_ANSWERED));
}
}
// get operator
sql = switch_mprintf("SELECT name FROM operators WHERE agent = '%q'", agent);
cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CALLCENTER_EVENT) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Operator", res); // res --> operator.name
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Agent", agent);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Action", "agent-status-change");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Agent-Status", value);
switch_event_fire(&event);
}
} else {
result = CC_STATUS_AGENT_INVALID_STATUS;
goto done;
}
} else if (!strcasecmp(key, "state")) {
if (cc_agent_str2state(value) != CC_AGENT_STATE_UNKNOWN) {
if (cc_agent_str2state(value) != CC_AGENT_STATE_RECEIVING) {
sql = switch_mprintf("UPDATE agents SET state = '%q' WHERE name = '%q'", value, agent);
} else {
sql = switch_mprintf("UPDATE agents SET state = '%q', last_offered_call = '%" SWITCH_TIME_T_FMT "' WHERE name = '%q'",
value, local_epoch_time_now(NULL), agent);
}
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CALLCENTER_EVENT) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Agent", agent);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Action", "agent-state-change");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Agent-State", value);
switch_event_fire(&event);
}
} else {
result = CC_STATUS_AGENT_INVALID_STATE;
goto done;
}
} else if (!strcasecmp(key, "uuid")) {
sql = switch_mprintf("UPDATE agents SET uuid = '%q', system = 'single_box' WHERE name = '%q'", value, agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "contact")) {
sql = switch_mprintf("UPDATE agents SET contact = '%q', system = 'single_box' WHERE name = '%q'", value, agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "ready_time")) {
sql = switch_mprintf("UPDATE agents SET ready_time = '%ld', system = 'single_box' WHERE name = '%q'", atol(value), agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "busy_delay_time")) {
sql = switch_mprintf("UPDATE agents SET busy_delay_time = '%ld', system = 'single_box' WHERE name = '%q'", atol(value), agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "reject_delay_time")) {
sql = switch_mprintf("UPDATE agents SET reject_delay_time = '%ld', system = 'single_box' WHERE name = '%q'", atol(value), agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "no_answer_delay_time")) {
sql = switch_mprintf("UPDATE agents SET no_answer_delay_time = '%ld', system = 'single_box' WHERE name = '%q'", atol(value), agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "type")) {
if (strcasecmp(value, CC_AGENT_TYPE_CALLBACK) && strcasecmp(value, CC_AGENT_TYPE_UUID_STANDBY)) {
result = CC_STATUS_AGENT_INVALID_TYPE;
goto done;
}
sql = switch_mprintf("UPDATE agents SET type = '%q' WHERE name = '%q'", value, agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "max_no_answer")) {
sql = switch_mprintf("UPDATE agents SET max_no_answer = '%d', system = 'single_box' WHERE name = '%q'", atoi(value), agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else if (!strcasecmp(key, "wrap_up_time")) {
sql = switch_mprintf("UPDATE agents SET wrap_up_time = '%d', system = 'single_box' WHERE name = '%q'", atoi(value), agent);
cc_execute_sql(NULL, sql, NULL);
switch_safe_free(sql);
result = CC_STATUS_SUCCESS;
} else {
result = CC_STATUS_INVALID_KEY;
goto done;
}
done:
if (result == CC_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Updated Agent %s set %s = %s\n", agent, key, value);
}
return result;
}
/*重新启动服务器
*/
int CBaseModule::reboot(inner_CmdReq_Frame*& inner_reqFrame,
inner_ResultResponse_Frame*& inner_RespFrame)
{
int iRes = CARICCP_SUCCESS_STATE_CODE;
string strDec;
int notifyCode = CARICCP_NOTIFY_REBOOT;
string strNotifyCode = "";
string strClientID = intToString(inner_reqFrame->header.sClientID);
string strCode = intToString(inner_reqFrame->body.iCmdCode);
string strCmdName = inner_reqFrame->body.strCmdName;
char *pChNotifyNode = NULL,*chDec = NULL;
char *chReboot = "0";
//涉及到通知类型的处理:命令属于通知类型,需要广播通知其他客户端
switch_event_t *notifyInfoEvent = NULL;
string strModel,strParamName,strChinaName;
string strTmp;
//model
strParamName = "model";//model
strChinaName = getValueOfDefinedVar(strParamName);
strModel = getValue(strParamName, inner_reqFrame);
if (0 == strModel.size()) {
//模式为空,返回错误信息
strDec = getValueOfDefinedVar("PARAM_NULL_ERROR");
chDec = switch_mprintf(strDec.c_str(), strChinaName.c_str());
inner_RespFrame->header.iResultCode = CARICCP_ERROR_STATE_CODE;
myMemcpy(inner_RespFrame->header.strResuleDesc, strDec.c_str(), sizeof(inner_RespFrame->header.strResuleDesc));
switch_safe_free(chDec);
goto end_flag;
}
if (isEqualStr("host",strModel)){
chReboot = "1";
//描述信息
strDec = getValueOfDefinedVar("HOST_REBOOT");
}
else{
chReboot = "0";
strDec = getValueOfDefinedVar("SERVER_REBOOT");
}
//if (SWITCH_STATUS_SUCCESS != switch_event_create(¬ifyInfoEvent, CARICCP_EVENT_STATE_NOTIFY)) {
if (SWITCH_STATUS_SUCCESS != switch_event_create_subclass(¬ifyInfoEvent, SWITCH_EVENT_CUSTOM, CARI_CCP_EVENT_NAME)) {
//此时还是按照成功处理
goto end_flag;
}
//通知码
notifyCode = CARICCP_NOTIFY_REBOOT;
//结果码和结果集
pChNotifyNode = switch_mprintf("%d", notifyCode);
strNotifyCode = pChNotifyNode;
switch_event_add_header_string(notifyInfoEvent, SWITCH_STACK_BOTTOM, CARICCP_NOTIFY, "1"); //通知标识
switch_event_add_header_string(notifyInfoEvent, SWITCH_STACK_BOTTOM, CARICCP_RETURNCODE, strNotifyCode.c_str()); //返回码=通知码
switch_event_add_header_string(notifyInfoEvent, SWITCH_STACK_BOTTOM, CLIENT_ID, strClientID.c_str()); //客户端号
switch_event_add_header_string(notifyInfoEvent, SWITCH_STACK_BOTTOM, CARICCP_CMDCODE, strCode.c_str()); //
switch_event_add_header_string(notifyInfoEvent, SWITCH_STACK_BOTTOM, CARICCP_CMDNAME, strCmdName.c_str());
switch_event_add_header_string(notifyInfoEvent, SWITCH_STACK_BOTTOM, CARICCP_RESULTDESC, strDec.c_str()); //描述信息
//发送通知----------------------
cari_net_event_notify(notifyInfoEvent);
//释放内存
switch_event_destroy(¬ifyInfoEvent);
switch_safe_free(pChNotifyNode);
//为了返回给客户端能显示特殊颜色,此处的返回码不为0,为CARICCP_NOTIFY_REBOOT
inner_RespFrame->header.iResultCode = CARICCP_NOTIFY_REBOOT;
myMemcpy(inner_RespFrame->header.strResuleDesc, strDec.c_str(), strlen(strDec.c_str()));//返回的描述信息
end_flag:
//然后再重新启动一个线程来处理重启,因为本命令返回的结果还没有广播给所有的client,服务器就开始重启了
//可以限制重启时间间隔,保证结果能返回即可.
pthread_t pth;
int iRet= pthread_create(&pth,NULL,thread_reboot,(void *)chReboot);
if(CARICCP_SUCCESS_STATE_CODE != iRet){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Creat reboot thred failed!");
}
//#if defined(_WIN32) || defined(WIN32)
// cari_common_excuteSysCmd("shutdown /r");
//#else
// for (int i=0;i<3;i++){
// cari_common_excuteSysCmd("sync");//加快数据更新,将内存中的数据写入到磁盘中,建议如此使用
// }
// cari_common_excuteSysCmd("reboot");//当前linux系统不支持shutdown命令(shutdown -rt 10)
//#endif
return iRes;
}
static switch_status_t channel_on_execute(switch_core_session_t *session)
{
switch_channel_t *channel = NULL;
loopback_private_t *tech_pvt = NULL;
switch_caller_extension_t *exten = NULL;
const char *bowout = NULL;
int bow = 0;
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s CHANNEL EXECUTE\n", switch_channel_get_name(channel));
if ((bowout = switch_channel_get_variable(tech_pvt->channel, "loopback_bowout_on_execute")) && switch_true(bowout)) {
/* loopback_bowout_on_execute variable is set */
bow = 1;
} else if ((exten = switch_channel_get_caller_extension(channel))) {
/* check for bowout flag */
switch_caller_application_t *app_p;
for (app_p = exten->applications; app_p; app_p = app_p->next) {
int32_t flags;
switch_core_session_get_app_flags(app_p->application_name, &flags);
if ((flags & SAF_NO_LOOPBACK)) {
bow = 1;
break;
}
}
}
if (bow) {
switch_core_session_t *other_session = NULL;
switch_caller_profile_t *cp, *clone;
const char *other_uuid = NULL;
switch_event_t *event = NULL;
switch_set_flag(tech_pvt, TFLAG_BOWOUT);
if ((find_non_loopback_bridge(tech_pvt->other_session, &other_session, &other_uuid) == SWITCH_STATUS_SUCCESS)) {
switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
switch_channel_wait_for_state_timeout(other_channel, CS_EXCHANGE_MEDIA, 5000);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_INFO, "BOWOUT Replacing loopback channel with real channel: %s\n",
switch_channel_get_name(other_channel));
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, "loopback::bowout") == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Resigning-UUID", switch_channel_get_uuid(channel));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Acquired-UUID", switch_channel_get_uuid(other_channel));
switch_event_fire(&event);
}
if ((cp = switch_channel_get_caller_profile(channel))) {
clone = switch_caller_profile_clone(other_session, cp);
clone->originator_caller_profile = NULL;
clone->originatee_caller_profile = NULL;
switch_channel_set_caller_profile(other_channel, clone);
}
switch_channel_caller_extension_masquerade(channel, other_channel, 0);
switch_channel_set_state(other_channel, CS_RESET);
switch_channel_wait_for_state(other_channel, NULL, CS_RESET);
switch_channel_set_state(other_channel, CS_EXECUTE);
switch_core_session_rwunlock(other_session);
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_UNSPECIFIED);
}
}
return SWITCH_STATUS_SUCCESS;
}
/*! \brief Find voicemail beep in the audio stream
*
* @author Eric des Courtis
* @param vmd_info The session information associated with the call.
* @param frame The audio data.
* @return The success or failure of the function.
*/
static void find_beep(vmd_session_info_t *vmd_info, switch_frame_t *frame)
{
int i;
int c;
double m[POINTS];
double med;
unsigned int j = (vmd_info->pos + 1) % POINTS;
unsigned int k = j;
switch_event_t *event;
switch_status_t status;
switch_event_t *event_copy;
switch_channel_t *channel = switch_core_session_get_channel(vmd_info->session);
switch (vmd_info->state) {
case BEEP_DETECTED:
for (c = 0, i = 0; i < POINTS; j++, j %= POINTS, i++) {
vmd_info->timestamp++;
if (vmd_info->points[j].freq < TOLERANCE_T(vmd_info->beep_freq) && vmd_info->points[j].freq > TOLERANCE_B(vmd_info->beep_freq)) {
c++;
vmd_info->beep_freq = (vmd_info->beep_freq * 0.95) + (vmd_info->points[j].freq * 0.05);
}
}
if (c < (POINTS - MAX_CHIRP)) {
vmd_info->state = BEEP_NOT_DETECTED;
if (vmd_info->timestamp < (switch_size_t) vmd_info->minTime) {
break;
}
status = switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, VMD_EVENT_BEEP);
if (status != SWITCH_STATUS_SUCCESS) {
return;
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Beep-Status", "stop");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Beep-Time", "%d", (int) vmd_info->timestamp / POINTS);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(vmd_info->session));
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Frequency", "%6.4lf", vmd_info->beep_freq);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "vmd");
if ((switch_event_dup(&event_copy, event)) != SWITCH_STATUS_SUCCESS) {
return;
}
switch_core_session_queue_event(vmd_info->session, &event);
switch_event_fire(&event_copy);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(vmd_info->session), SWITCH_LOG_INFO, "<<< VMD - Beep Detected >>>\n");
switch_channel_set_variable(channel, "vmd_detect", "TRUE");
vmd_info->timestamp = 0;
}
break;
case BEEP_NOT_DETECTED:
for (i = 0; i < POINTS; k++, k %= POINTS, i++) {
m[i] = vmd_info->points[k].freq;
if (ISNAN(m[i])) {
m[i] = 0.0;
}
}
med = median(m, POINTS);
if (ISNAN(med)) {
for (i = 0; i < POINTS; i++) {
if (!ISNAN(m[i])) {
med = m[i];
break;
}
}
}
for (c = 0, i = 0; i < POINTS; j++, j %= POINTS, i++) {
if (vmd_info->points[j].freq < TOLERANCE_T(med) && vmd_info->points[j].freq > TOLERANCE_B(med)) {
if (vmd_info->points[j].ampl > MIN_AMPL && vmd_info->points[j].freq > MIN_FREQ && vmd_info->points[j].freq < MAX_FREQ) {
c++;
}
}
}
if (c >= VALID) {
vmd_info->state = BEEP_DETECTED;
vmd_info->beep_freq = med;
vmd_info->timestamp = 0;
}
break;
}
}
/*! \brief Process one frame of data with avmd algorithm
* @author Eric des Courtis
* @param session An avmd session
* @param frame A audio frame
*/
static void avmd_process(avmd_session_t *session, switch_frame_t *frame)
{
switch_event_t *event;
switch_status_t status;
switch_event_t *event_copy;
switch_channel_t *channel;
circ_buffer_t *b;
size_t pos;
double f;
double a;
double error = 0.0;
double success = 0.0;
double amp = 0.0;
double s_rate;
double e_rate;
double avg_a;
double sine_len;
uint32_t sine_len_i;
int valid;
b = &session->b;
/*! If beep has already been detected skip the CPU heavy stuff */
if(session->state.beep_state == BEEP_DETECTED){
return;
}
/*! Precompute values used heavily in the inner loop */
sine_len_i = SINE_LEN(session->rate);
sine_len = (double)sine_len_i;
channel = switch_core_session_get_channel(session->session);
/*! Insert frame of 16 bit samples into buffer */
INSERT_INT16_FRAME(b, (int16_t *)(frame->data), frame->samples);
/*! INNER LOOP -- OPTIMIZATION TARGET */
for(pos = GET_BACKLOG_POS(b); pos != (GET_CURRENT_POS(b) - P); pos++){
/*! Get a desa2 frequency estimate in Hertz */
f = TO_HZ(session->rate, desa2(b, pos));
/*! Don't caculate amplitude if frequency is not within range */
if(f < MIN_FREQUENCY || f > MAX_FREQUENCY) {
a = 0.0;
error += 1.0;
} else {
a = amplitude(b, pos, f);
success += 1.0;
if(!ISNAN(a)){
amp += a;
}
}
/*! Every once in a while we evaluate the desa2 and amplitude results */
if(((pos + 1) % sine_len_i) == 0){
s_rate = success / (error + success);
e_rate = error / (error + success);
avg_a = amp / sine_len;
/*! Results out of these ranges are considered invalid */
valid = 0;
if( s_rate > 0.60 && avg_a > 0.50) valid = 1;
else if(s_rate > 0.65 && avg_a > 0.45) valid = 1;
else if(s_rate > 0.70 && avg_a > 0.40) valid = 1;
else if(s_rate > 0.80 && avg_a > 0.30) valid = 1;
else if(s_rate > 0.95 && avg_a > 0.05) valid = 1;
else if(s_rate >= 0.99 && avg_a > 0.04) valid = 1;
else if(s_rate == 1.00 && avg_a > 0.02) valid = 1;
if(valid) {
APPEND_SMA_VAL(&session->sma_b, s_rate * avg_a);
}
else {
APPEND_SMA_VAL(&session->sma_b, 0.0 );
}
/*! If sma is higher then 0 we have some kind of detection (increase this value to eliminate false positives ex: 0.01) */
if(session->sma_b.sma > 0.00){
/*! Throw an event to FreeSWITCH */
status = switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, AVMD_EVENT_BEEP);
if(status != SWITCH_STATUS_SUCCESS) {
return;
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Beep-Status", "stop");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(session->session));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "avmd");
if ((switch_event_dup(&event_copy, event)) != SWITCH_STATUS_SUCCESS) {
return;
}
switch_core_session_queue_event(session->session, &event);
switch_event_fire(&event_copy);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session->session), SWITCH_LOG_INFO, "<<< AVMD - Beep Detected >>>\n");
switch_channel_set_variable(channel, "avmd_detect", "TRUE");
RESET_SMA_BUFFER(&session->sma_b);
session->state.beep_state = BEEP_DETECTED;
return;
}
amp = 0.0;
success = 0.0;
error = 0.0;
}
}
}
