kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Skinny: reindent using vim's =G

This commit is contained in:
Mathieu Parent 2011-05-13 00:32:57 +02:00
parent 5f6c469e44
commit ff08ea68ce
8 changed files with 1832 additions and 1843 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

524
src/mod/endpoints/mod_skinny/mod_skinny.c
View File

@ -50,58 +50,58 @@ skinny_globals_t globals;
/* SQL TABLES */ /* SQL TABLES */
/*****************************************************************************/ /*****************************************************************************/
static char devices_sql[] = static char devices_sql[] =
"CREATE TABLE skinny_devices (\n" "CREATE TABLE skinny_devices (\n"
" name VARCHAR(16),\n" " name VARCHAR(16),\n"
" user_id INTEGER,\n" " user_id INTEGER,\n"
" instance INTEGER,\n" " instance INTEGER,\n"
" ip VARCHAR(15),\n" " ip VARCHAR(15),\n"
" type INTEGER,\n" " type INTEGER,\n"
" max_streams INTEGER,\n" " max_streams INTEGER,\n"
" port INTEGER,\n" " port INTEGER,\n"
" codec_string VARCHAR(255),\n" " codec_string VARCHAR(255),\n"
" headset INTEGER,\n" " headset INTEGER,\n"
" handset INTEGER,\n" " handset INTEGER,\n"
" speaker INTEGER\n" " speaker INTEGER\n"
");\n"; ");\n";
static char lines_sql[] = static char lines_sql[] =
"CREATE TABLE skinny_lines (\n" "CREATE TABLE skinny_lines (\n"
" device_name VARCHAR(16),\n" " device_name VARCHAR(16),\n"
" device_instance INTEGER,\n" " device_instance INTEGER,\n"
" position INTEGER,\n" " position INTEGER,\n"
" line_instance INTEGER,\n" " line_instance INTEGER,\n"
" label VARCHAR(40),\n" " label VARCHAR(40),\n"
" value VARCHAR(24),\n" " value VARCHAR(24),\n"
" caller_name VARCHAR(44),\n" " caller_name VARCHAR(44),\n"
" ring_on_idle INTEGER,\n" " ring_on_idle INTEGER,\n"
" ring_on_active INTEGER,\n" " ring_on_active INTEGER,\n"
" busy_trigger INTEGER,\n" " busy_trigger INTEGER,\n"
" forward_all VARCHAR(255),\n" " forward_all VARCHAR(255),\n"
" forward_busy VARCHAR(255),\n" " forward_busy VARCHAR(255),\n"
" forward_noanswer VARCHAR(255),\n" " forward_noanswer VARCHAR(255),\n"
" noanswer_duration INTEGER\n" " noanswer_duration INTEGER\n"
");\n"; ");\n";
static char buttons_sql[] = static char buttons_sql[] =
"CREATE TABLE skinny_buttons (\n" "CREATE TABLE skinny_buttons (\n"
" device_name VARCHAR(16),\n" " device_name VARCHAR(16),\n"
" device_instance INTEGER,\n" " device_instance INTEGER,\n"
" position INTEGER,\n" " position INTEGER,\n"
" type INTEGER,\n" " type INTEGER,\n"
" label VARCHAR(40),\n" " label VARCHAR(40),\n"
" value VARCHAR(255),\n" " value VARCHAR(255),\n"
" settings VARCHAR(44)\n" " settings VARCHAR(44)\n"
");\n"; ");\n";
static char active_lines_sql[] = static char active_lines_sql[] =
"CREATE TABLE skinny_active_lines (\n" "CREATE TABLE skinny_active_lines (\n"
" device_name VARCHAR(16),\n" " device_name VARCHAR(16),\n"
" device_instance INTEGER,\n" " device_instance INTEGER,\n"
" line_instance INTEGER,\n" " line_instance INTEGER,\n"
" channel_uuid VARCHAR(256),\n" " channel_uuid VARCHAR(256),\n"
" call_id INTEGER,\n" " call_id INTEGER,\n"
" call_state INTEGER\n" " call_state INTEGER\n"
");\n"; ");\n";
/*****************************************************************************/ /*****************************************************************************/
/* PROFILES FUNCTIONS */ /* PROFILES FUNCTIONS */
@ -238,7 +238,7 @@ char * skinny_profile_find_session_uuid(skinny_profile_t *profile, listener_t *l
if(listener) { if(listener) {
device_condition = switch_mprintf("device_name='%s' AND device_instance=%d", device_condition = switch_mprintf("device_name='%s' AND device_instance=%d",
listener->device_name, listener->device_instance); listener->device_name, listener->device_instance);
} else { } else {
device_condition = switch_mprintf("1=1"); device_condition = switch_mprintf("1=1");
} }
@ -256,14 +256,14 @@ char * skinny_profile_find_session_uuid(skinny_profile_t *profile, listener_t *l
} }
switch_assert(call_id_condition); switch_assert(call_id_condition);
if((sql = switch_mprintf( if((sql = switch_mprintf(
"SELECT channel_uuid, line_instance " "SELECT channel_uuid, line_instance "
"FROM skinny_active_lines " "FROM skinny_active_lines "
"WHERE %s AND %s AND %s " "WHERE %s AND %s AND %s "
"ORDER BY call_state, channel_uuid", /* off hook first */ "ORDER BY call_state, channel_uuid", /* off hook first */
device_condition, line_instance_condition, call_id_condition device_condition, line_instance_condition, call_id_condition
))) { ))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_execute_sql_callback(profile, profile->sql_mutex, sql,
skinny_profile_find_session_uuid_callback, &helper); skinny_profile_find_session_uuid_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
} }
switch_safe_free(device_condition); switch_safe_free(device_condition);
@ -291,8 +291,8 @@ switch_core_session_t * skinny_profile_find_session(skinny_profile_t *profile, l
#endif #endif
if(!result) { if(!result) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Unable to find session %s on %s:%d, line %d\n", "Unable to find session %s on %s:%d, line %d\n",
uuid, listener->device_name, listener->device_instance, *line_instance_p); uuid, listener->device_name, listener->device_instance, *line_instance_p);
} }
switch_safe_free(uuid); switch_safe_free(uuid);
} }
@ -340,7 +340,7 @@ switch_status_t skinny_execute_sql(skinny_profile_t *profile, char *sql, switch_
status = switch_cache_db_execute_sql(dbh, sql, NULL); status = switch_cache_db_execute_sql(dbh, sql, NULL);
end: end:
switch_cache_db_release_db_handle(&dbh); switch_cache_db_release_db_handle(&dbh);
@ -352,7 +352,7 @@ switch_status_t skinny_execute_sql(skinny_profile_t *profile, char *sql, switch_
} }
switch_bool_t skinny_execute_sql_callback(skinny_profile_t *profile, switch_mutex_t *mutex, char *sql, switch_core_db_callback_func_t callback, switch_bool_t skinny_execute_sql_callback(skinny_profile_t *profile, switch_mutex_t *mutex, char *sql, switch_core_db_callback_func_t callback,
void *pdata) void *pdata)
{ {
switch_bool_t ret = SWITCH_FALSE; switch_bool_t ret = SWITCH_FALSE;
char *errmsg = NULL; char *errmsg = NULL;
@ -374,7 +374,7 @@ switch_bool_t skinny_execute_sql_callback(skinny_profile_t *profile, switch_mute
free(errmsg); free(errmsg);
} }
end: end:
switch_cache_db_release_db_handle(&dbh); switch_cache_db_release_db_handle(&dbh);
@ -400,9 +400,9 @@ void skinny_line_perform_set_state(const char *file, const char *func, int line,
switch_event_fire(&event); switch_event_fire(&event);
send_call_state(listener, call_state, line_instance, call_id); send_call_state(listener, call_state, line_instance, call_id);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG,
"Device %s:%d, Line %d, Call %d Change State to %s (%d)\n", "Device %s:%d, Line %d, Call %d Change State to %s (%d)\n",
listener->device_name, listener->device_instance, line_instance, call_id, listener->device_name, listener->device_instance, line_instance, call_id,
skinny_call_state2str(call_state), call_state); skinny_call_state2str(call_state), call_state);
} }
@ -443,13 +443,13 @@ uint32_t skinny_line_get_state(listener_t *listener, uint32_t line_instance, uin
helper.call_state = -1; helper.call_state = -1;
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT call_state FROM skinny_active_lines " "SELECT call_state FROM skinny_active_lines "
"WHERE device_name='%s' AND device_instance=%d " "WHERE device_name='%s' AND device_instance=%d "
"AND %s AND %s " "AND %s AND %s "
"ORDER BY call_state, channel_uuid", /* off hook first */ "ORDER BY call_state, channel_uuid", /* off hook first */
listener->device_name, listener->device_instance, listener->device_name, listener->device_instance,
line_instance_condition, call_id_condition line_instance_condition, call_id_condition
))) { ))) {
skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_line_get_state_callback, &helper); skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_line_get_state_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -475,13 +475,13 @@ switch_status_t skinny_tech_set_codec(private_t *tech_pvt, int force)
switch_goto_status(SWITCH_STATUS_SUCCESS, end); switch_goto_status(SWITCH_STATUS_SUCCESS, end);
} }
if (strcasecmp(tech_pvt->read_impl.iananame, tech_pvt->iananame) || if (strcasecmp(tech_pvt->read_impl.iananame, tech_pvt->iananame) ||
tech_pvt->read_impl.samples_per_second != tech_pvt->rm_rate || tech_pvt->read_impl.samples_per_second != tech_pvt->rm_rate ||
tech_pvt->codec_ms != (uint32_t)tech_pvt->read_impl.microseconds_per_packet / 1000) { tech_pvt->codec_ms != (uint32_t)tech_pvt->read_impl.microseconds_per_packet / 1000) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG, "Changing Codec from %s@%dms to %s@%dms\n", switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG, "Changing Codec from %s@%dms to %s@%dms\n",
tech_pvt->read_impl.iananame, tech_pvt->read_impl.microseconds_per_packet / 1000, tech_pvt->read_impl.iananame, tech_pvt->read_impl.microseconds_per_packet / 1000,
tech_pvt->rm_encoding, tech_pvt->codec_ms); tech_pvt->rm_encoding, tech_pvt->codec_ms);
switch_core_session_lock_codec_write(tech_pvt->session); switch_core_session_lock_codec_write(tech_pvt->session);
switch_core_session_lock_codec_read(tech_pvt->session); switch_core_session_lock_codec_read(tech_pvt->session);
resetting = 1; resetting = 1;
@ -494,25 +494,25 @@ switch_status_t skinny_tech_set_codec(private_t *tech_pvt, int force)
} }
if (switch_core_codec_init(&tech_pvt->read_codec, if (switch_core_codec_init(&tech_pvt->read_codec,
tech_pvt->iananame, tech_pvt->iananame,
tech_pvt->rm_fmtp, tech_pvt->rm_fmtp,
tech_pvt->rm_rate, tech_pvt->rm_rate,
tech_pvt->codec_ms, tech_pvt->codec_ms,
1, 1,
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | 0 /* TODO tech_pvt->profile->codec_flags */, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | 0 /* TODO tech_pvt->profile->codec_flags */,
NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) { NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_ERROR, "Can't load codec?\n"); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_ERROR, "Can't load codec?\n");
switch_goto_status(SWITCH_STATUS_FALSE, end); switch_goto_status(SWITCH_STATUS_FALSE, end);
} }
if (switch_core_codec_init(&tech_pvt->write_codec, if (switch_core_codec_init(&tech_pvt->write_codec,
tech_pvt->iananame, tech_pvt->iananame,
tech_pvt->rm_fmtp, tech_pvt->rm_fmtp,
tech_pvt->rm_rate, tech_pvt->rm_rate,
tech_pvt->codec_ms, tech_pvt->codec_ms,
1, 1,
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | 0 /* TODO tech_pvt->profile->codec_flags */, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | 0 /* TODO tech_pvt->profile->codec_flags */,
NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) { NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_ERROR, "Can't load codec?\n"); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_ERROR, "Can't load codec?\n");
switch_goto_status(SWITCH_STATUS_FALSE, end); switch_goto_status(SWITCH_STATUS_FALSE, end);
} }
@ -530,9 +530,9 @@ switch_status_t skinny_tech_set_codec(private_t *tech_pvt, int force)
switch_assert(tech_pvt->read_codec.implementation); switch_assert(tech_pvt->read_codec.implementation);
if (switch_rtp_change_interval(tech_pvt->rtp_session, if (switch_rtp_change_interval(tech_pvt->rtp_session,
tech_pvt->read_impl.microseconds_per_packet, tech_pvt->read_impl.microseconds_per_packet,
tech_pvt->read_impl.samples_per_packet tech_pvt->read_impl.samples_per_packet
) != SWITCH_STATUS_SUCCESS) { ) != SWITCH_STATUS_SUCCESS) {
switch_channel_t *channel = switch_core_session_get_channel(tech_pvt->session); switch_channel_t *channel = switch_core_session_get_channel(tech_pvt->session);
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER); switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
@ -549,8 +549,8 @@ switch_status_t skinny_tech_set_codec(private_t *tech_pvt, int force)
} }
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG, "Set Codec %s %s/%ld %d ms %d samples\n", switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG, "Set Codec %s %s/%ld %d ms %d samples\n",
"" /* TODO switch_channel_get_name(tech_pvt->channel)*/, tech_pvt->iananame, tech_pvt->rm_rate, tech_pvt->codec_ms, "" /* TODO switch_channel_get_name(tech_pvt->channel)*/, tech_pvt->iananame, tech_pvt->rm_rate, tech_pvt->codec_ms,
tech_pvt->read_impl.samples_per_packet); tech_pvt->read_impl.samples_per_packet);
tech_pvt->read_frame.codec = &tech_pvt->read_codec; tech_pvt->read_frame.codec = &tech_pvt->read_codec;
tech_pvt->write_codec.agreed_pt = tech_pvt->agreed_pt; tech_pvt->write_codec.agreed_pt = tech_pvt->agreed_pt;
@ -562,16 +562,16 @@ switch_status_t skinny_tech_set_codec(private_t *tech_pvt, int force)
} }
/* TODO /* TODO
tech_pvt->fmtp_out = switch_core_session_strdup(tech_pvt->session, tech_pvt->write_codec.fmtp_out); tech_pvt->fmtp_out = switch_core_session_strdup(tech_pvt->session, tech_pvt->write_codec.fmtp_out);
*/ */
/* TODO /* TODO
if (switch_rtp_ready(tech_pvt->rtp_session)) { if (switch_rtp_ready(tech_pvt->rtp_session)) {
switch_rtp_set_default_payload(tech_pvt->rtp_session, tech_pvt->pt); switch_rtp_set_default_payload(tech_pvt->rtp_session, tech_pvt->pt);
} }
*/ */
end: end:
if (resetting) { if (resetting) {
switch_core_session_unlock_codec_write(tech_pvt->session); switch_core_session_unlock_codec_write(tech_pvt->session);
switch_core_session_unlock_codec_read(tech_pvt->session); switch_core_session_unlock_codec_read(tech_pvt->session);
@ -600,7 +600,7 @@ void tech_init(private_t *tech_pvt, skinny_profile_t *profile, switch_core_sessi
State methods they get called when the state changes to the specific state State methods they get called when the state changes to the specific state
returning SWITCH_STATUS_SUCCESS tells the core to execute the standard state method next returning SWITCH_STATUS_SUCCESS tells the core to execute the standard state method next
so if you fully implement the state you can return SWITCH_STATUS_FALSE to skip it. so if you fully implement the state you can return SWITCH_STATUS_FALSE to skip it.
*/ */
switch_status_t channel_on_init(switch_core_session_t *session) switch_status_t channel_on_init(switch_core_session_t *session)
{ {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
@ -641,23 +641,23 @@ int channel_on_routing_callback(void *pArg, int argc, char **argv, char **column
skinny_profile_find_listener_by_device_name_and_instance(helper->tech_pvt->profile, device_name, device_instance, &listener); skinny_profile_find_listener_by_device_name_and_instance(helper->tech_pvt->profile, device_name, device_instance, &listener);
if(listener) { if(listener) {
if(!strcmp(device_name, helper->listener->device_name) if(!strcmp(device_name, helper->listener->device_name)
&& (device_instance == helper->listener->device_instance) && (device_instance == helper->listener->device_instance)
&& (line_instance == helper->line_instance)) {/* the calling line */ && (line_instance == helper->line_instance)) {/* the calling line */
helper->tech_pvt->caller_profile->dialplan = switch_core_strdup(helper->tech_pvt->caller_profile->pool, listener->profile->dialplan); helper->tech_pvt->caller_profile->dialplan = switch_core_strdup(helper->tech_pvt->caller_profile->pool, listener->profile->dialplan);
helper->tech_pvt->caller_profile->context = switch_core_strdup(helper->tech_pvt->caller_profile->pool, listener->profile->context); helper->tech_pvt->caller_profile->context = switch_core_strdup(helper->tech_pvt->caller_profile->pool, listener->profile->context);
send_dialed_number(listener, helper->tech_pvt->caller_profile->destination_number, line_instance, helper->tech_pvt->call_id); send_dialed_number(listener, helper->tech_pvt->caller_profile->destination_number, line_instance, helper->tech_pvt->call_id);
skinny_line_set_state(listener, line_instance, helper->tech_pvt->call_id, SKINNY_PROCEED); skinny_line_set_state(listener, line_instance, helper->tech_pvt->call_id, SKINNY_PROCEED);
skinny_session_send_call_info(helper->tech_pvt->session, listener, line_instance); skinny_session_send_call_info(helper->tech_pvt->session, listener, line_instance);
skinny_session_ring_out(helper->tech_pvt->session, listener, line_instance); skinny_session_ring_out(helper->tech_pvt->session, listener, line_instance);
} else { } else {
send_set_lamp(listener, SKINNY_BUTTON_LINE, line_instance, SKINNY_LAMP_ON); send_set_lamp(listener, SKINNY_BUTTON_LINE, line_instance, SKINNY_LAMP_ON);
skinny_line_set_state(listener, line_instance, helper->tech_pvt->call_id, SKINNY_IN_USE_REMOTELY); skinny_line_set_state(listener, line_instance, helper->tech_pvt->call_id, SKINNY_IN_USE_REMOTELY);
send_select_soft_keys(listener, line_instance, helper->tech_pvt->call_id, SKINNY_KEY_SET_IN_USE_HINT, 0xffff); send_select_soft_keys(listener, line_instance, helper->tech_pvt->call_id, SKINNY_KEY_SET_IN_USE_HINT, 0xffff);
send_display_prompt_status(listener, 0, SKINNY_DISP_IN_USE_REMOTE, send_display_prompt_status(listener, 0, SKINNY_DISP_IN_USE_REMOTE,
line_instance, helper->tech_pvt->call_id); line_instance, helper->tech_pvt->call_id);
skinny_session_send_call_info(helper->tech_pvt->session, listener, line_instance); skinny_session_send_call_info(helper->tech_pvt->session, listener, line_instance);
} }
} }
return 0; return 0;
} }
@ -680,8 +680,8 @@ switch_status_t channel_on_routing(switch_core_session_t *session)
switch(action) { switch(action) {
case SKINNY_ACTION_PROCESS: case SKINNY_ACTION_PROCESS:
skinny_profile_find_listener_by_device_name_and_instance(tech_pvt->profile, skinny_profile_find_listener_by_device_name_and_instance(tech_pvt->profile,
switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_name"),
atoi(switch_channel_get_variable(channel, "skinny_device_instance")), &listener); atoi(switch_channel_get_variable(channel, "skinny_device_instance")), &listener);
if (listener) { if (listener) {
helper.tech_pvt = tech_pvt; helper.tech_pvt = tech_pvt;
helper.listener = listener; helper.listener = listener;
@ -689,8 +689,8 @@ switch_status_t channel_on_routing(switch_core_session_t *session)
skinny_session_walk_lines(tech_pvt->profile, switch_core_session_get_uuid(session), channel_on_routing_callback, &helper); skinny_session_walk_lines(tech_pvt->profile, switch_core_session_get_uuid(session), channel_on_routing_callback, &helper);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Could not find listener %s:%s for Channel %s\n", switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Could not find listener %s:%s for Channel %s\n",
switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_instance"), switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_instance"),
switch_channel_get_name(channel)); switch_channel_get_name(channel));
} }
/* Future bridge should go straight */ /* Future bridge should go straight */
switch_set_flag_locked(tech_pvt, TFLAG_FORCE_ROUTE); switch_set_flag_locked(tech_pvt, TFLAG_FORCE_ROUTE);
@ -777,16 +777,16 @@ int channel_on_hangup_callback(void *pArg, int argc, char **argv, char **columnN
send_set_lamp(listener, SKINNY_BUTTON_LINE, line_instance, SKINNY_LAMP_OFF); send_set_lamp(listener, SKINNY_BUTTON_LINE, line_instance, SKINNY_LAMP_OFF);
switch (helper->cause) { switch (helper->cause) {
case SWITCH_CAUSE_UNALLOCATED_NUMBER: case SWITCH_CAUSE_UNALLOCATED_NUMBER:
send_start_tone(listener, SKINNY_TONE_REORDER, 0, line_instance, call_id); send_start_tone(listener, SKINNY_TONE_REORDER, 0, line_instance, call_id);
skinny_session_send_call_info(helper->tech_pvt->session, listener, line_instance); skinny_session_send_call_info(helper->tech_pvt->session, listener, line_instance);
send_display_prompt_status(listener, 0, SKINNY_DISP_UNKNOWN_NUMBER, line_instance, call_id); send_display_prompt_status(listener, 0, SKINNY_DISP_UNKNOWN_NUMBER, line_instance, call_id);
break; break;
case SWITCH_CAUSE_USER_BUSY: case SWITCH_CAUSE_USER_BUSY:
send_start_tone(listener, SKINNY_TONE_BUSYTONE, 0, line_instance, call_id); send_start_tone(listener, SKINNY_TONE_BUSYTONE, 0, line_instance, call_id);
send_display_prompt_status(listener, 0, SKINNY_DISP_BUSY, line_instance, call_id); send_display_prompt_status(listener, 0, SKINNY_DISP_BUSY, line_instance, call_id);
break; break;
case SWITCH_CAUSE_NORMAL_CLEARING: case SWITCH_CAUSE_NORMAL_CLEARING:
send_clear_prompt_status(listener, line_instance, call_id); send_clear_prompt_status(listener, line_instance, call_id);
break; break;
default: default:
send_display_prompt_status(listener, 0, switch_channel_cause2str(helper->cause), line_instance, call_id); send_display_prompt_status(listener, 0, switch_channel_cause2str(helper->cause), line_instance, call_id);
@ -821,9 +821,9 @@ switch_status_t channel_on_hangup(switch_core_session_t *session)
skinny_session_walk_lines(tech_pvt->profile, switch_core_session_get_uuid(session), channel_on_hangup_callback, &helper); skinny_session_walk_lines(tech_pvt->profile, switch_core_session_get_uuid(session), channel_on_hangup_callback, &helper);
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"DELETE FROM skinny_active_lines WHERE channel_uuid='%s'", "DELETE FROM skinny_active_lines WHERE channel_uuid='%s'",
switch_core_session_get_uuid(session) switch_core_session_get_uuid(session)
))) { ))) {
skinny_execute_sql(tech_pvt->profile, sql, tech_pvt->profile->sql_mutex); skinny_execute_sql(tech_pvt->profile, sql, tech_pvt->profile->sql_mutex);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -836,16 +836,16 @@ switch_status_t channel_kill_channel(switch_core_session_t *session, int sig)
private_t *tech_pvt = switch_core_session_get_private(session); private_t *tech_pvt = switch_core_session_get_private(session);
switch (sig) { switch (sig) {
case SWITCH_SIG_KILL: case SWITCH_SIG_KILL:
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING); switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
break; break;
case SWITCH_SIG_BREAK: case SWITCH_SIG_BREAK:
if (switch_rtp_ready(tech_pvt->rtp_session)) { if (switch_rtp_ready(tech_pvt->rtp_session)) {
switch_rtp_break(tech_pvt->rtp_session); switch_rtp_break(tech_pvt->rtp_session);
} }
break; break;
default: default:
break; break;
} }
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s CHANNEL KILL %d\n", switch_channel_get_name(channel), sig); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s CHANNEL KILL %d\n", switch_channel_get_name(channel), sig);
@ -968,8 +968,8 @@ switch_status_t channel_answer_channel(switch_core_session_t *session)
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name_and_instance(tech_pvt->profile, skinny_profile_find_listener_by_device_name_and_instance(tech_pvt->profile,
switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_name"),
atoi(switch_channel_get_variable(channel, "skinny_device_instance")), &listener); atoi(switch_channel_get_variable(channel, "skinny_device_instance")), &listener);
if (listener) { if (listener) {
int x = 0; int x = 0;
skinny_session_start_media(session, listener, atoi(switch_channel_get_variable(channel, "skinny_line_instance"))); skinny_session_start_media(session, listener, atoi(switch_channel_get_variable(channel, "skinny_line_instance")));
@ -978,13 +978,13 @@ switch_status_t channel_answer_channel(switch_core_session_t *session)
switch_cond_next(); switch_cond_next();
if (++x > 1000) { if (++x > 1000) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Wait tooo long to answer %s:%s\n", switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Wait tooo long to answer %s:%s\n",
switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_instance")); switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_instance"));
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Unable to find listener to answer %s:%s\n", switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Unable to find listener to answer %s:%s\n",
switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_instance")); switch_channel_get_variable(channel, "skinny_device_name"), switch_channel_get_variable(channel, "skinny_device_instance"));
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -995,24 +995,24 @@ switch_status_t channel_receive_message(switch_core_session_t *session, switch_c
private_t *tech_pvt = switch_core_session_get_private(session); private_t *tech_pvt = switch_core_session_get_private(session);
switch (msg->message_id) { switch (msg->message_id) {
case SWITCH_MESSAGE_INDICATE_ANSWER: case SWITCH_MESSAGE_INDICATE_ANSWER:
switch_clear_flag_locked(tech_pvt, TFLAG_EARLY_MEDIA); switch_clear_flag_locked(tech_pvt, TFLAG_EARLY_MEDIA);
return channel_answer_channel(session);
case SWITCH_MESSAGE_INDICATE_DISPLAY:
skinny_session_send_call_info_all(session);
return SWITCH_STATUS_SUCCESS;
case SWITCH_MESSAGE_INDICATE_PROGRESS:
if (!switch_test_flag(tech_pvt, TFLAG_EARLY_MEDIA)) {
/* early media */
switch_set_flag_locked(tech_pvt, TFLAG_EARLY_MEDIA);
return channel_answer_channel(session); return channel_answer_channel(session);
}
return SWITCH_STATUS_SUCCESS;
default: case SWITCH_MESSAGE_INDICATE_DISPLAY:
return SWITCH_STATUS_SUCCESS; skinny_session_send_call_info_all(session);
return SWITCH_STATUS_SUCCESS;
case SWITCH_MESSAGE_INDICATE_PROGRESS:
if (!switch_test_flag(tech_pvt, TFLAG_EARLY_MEDIA)) {
/* early media */
switch_set_flag_locked(tech_pvt, TFLAG_EARLY_MEDIA);
return channel_answer_channel(session);
}
return SWITCH_STATUS_SUCCESS;
default:
return SWITCH_STATUS_SUCCESS;
} }
@ -1020,10 +1020,10 @@ switch_status_t channel_receive_message(switch_core_session_t *session, switch_c
/* Make sure when you have 2 sessions in the same scope that you pass the appropriate one to the routines /* Make sure when you have 2 sessions in the same scope that you pass the appropriate one to the routines
that allocate memory or you will have 1 channel with memory allocated from another channel's pool! that allocate memory or you will have 1 channel with memory allocated from another channel's pool!
*/ */
switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,
switch_caller_profile_t *outbound_profile, switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause) switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
{ {
switch_call_cause_t cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; switch_call_cause_t cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
switch_core_session_t *nsession = NULL; switch_core_session_t *nsession = NULL;
@ -1082,13 +1082,13 @@ switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, swi
tech_pvt->caller_profile = caller_profile; tech_pvt->caller_profile = caller_profile;
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"INSERT INTO skinny_active_lines " "INSERT INTO skinny_active_lines "
"(device_name, device_instance, line_instance, channel_uuid, call_id, call_state) " "(device_name, device_instance, line_instance, channel_uuid, call_id, call_state) "
"SELECT device_name, device_instance, line_instance, '%s', %d, %d " "SELECT device_name, device_instance, line_instance, '%s', %d, %d "
"FROM skinny_lines " "FROM skinny_lines "
"WHERE value='%s'", "WHERE value='%s'",
switch_core_session_get_uuid(nsession), tech_pvt->call_id, SKINNY_ON_HOOK, dest switch_core_session_get_uuid(nsession), tech_pvt->call_id, SKINNY_ON_HOOK, dest
))) { ))) {
skinny_execute_sql(profile, sql, profile->sql_mutex); skinny_execute_sql(profile, sql, profile->sql_mutex);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -1098,7 +1098,7 @@ switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, swi
switch_channel_set_variable(switch_core_session_get_channel(session), SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(nsession)); switch_channel_set_variable(switch_core_session_get_channel(session), SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(nsession));
switch_channel_set_variable(nchannel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(session)); switch_channel_set_variable(nchannel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(session));
} }
cause = skinny_ring_lines(tech_pvt, session); cause = skinny_ring_lines(tech_pvt, session);
if(cause != SWITCH_CAUSE_SUCCESS) { if(cause != SWITCH_CAUSE_SUCCESS) {
@ -1116,7 +1116,7 @@ switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, swi
cause = SWITCH_CAUSE_SUCCESS; cause = SWITCH_CAUSE_SUCCESS;
goto done; goto done;
error: error:
if (nsession) { if (nsession) {
switch_core_session_destroy(&nsession); switch_core_session_destroy(&nsession);
} }
@ -1126,7 +1126,7 @@ switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, swi
} }
done: done:
if (profile) { if (profile) {
if (cause == SWITCH_CAUSE_SUCCESS) { if (cause == SWITCH_CAUSE_SUCCESS) {
@ -1267,37 +1267,37 @@ static void flush_listener(listener_t *listener)
char *sql; char *sql;
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT '%q', value, '%q', '%q', '%d' " "SELECT '%q', value, '%q', '%q', '%d' "
"FROM skinny_lines " "FROM skinny_lines "
"WHERE device_name='%s' AND device_instance=%d " "WHERE device_name='%s' AND device_instance=%d "
"ORDER BY position", "ORDER BY position",
profile->name, profile->domain, listener->device_name, listener->device_instance, profile->name, profile->domain, listener->device_name, listener->device_instance,
listener->device_name, listener->device_instance listener->device_name, listener->device_instance
))) { ))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, flush_listener_callback, NULL); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, flush_listener_callback, NULL);
switch_safe_free(sql); switch_safe_free(sql);
} }
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"DELETE FROM skinny_devices " "DELETE FROM skinny_devices "
"WHERE name='%s' and instance=%d", "WHERE name='%s' and instance=%d",
listener->device_name, listener->device_instance))) { listener->device_name, listener->device_instance))) {
skinny_execute_sql(profile, sql, profile->sql_mutex); skinny_execute_sql(profile, sql, profile->sql_mutex);
switch_safe_free(sql); switch_safe_free(sql);
} }
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"DELETE FROM skinny_lines " "DELETE FROM skinny_lines "
"WHERE device_name='%s' and device_instance=%d", "WHERE device_name='%s' and device_instance=%d",
listener->device_name, listener->device_instance))) { listener->device_name, listener->device_instance))) {
skinny_execute_sql(profile, sql, profile->sql_mutex); skinny_execute_sql(profile, sql, profile->sql_mutex);
switch_safe_free(sql); switch_safe_free(sql);
} }
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"DELETE FROM skinny_buttons " "DELETE FROM skinny_buttons "
"WHERE device_name='%s' and device_instance=%d", "WHERE device_name='%s' and device_instance=%d",
listener->device_name, listener->device_instance))) { listener->device_name, listener->device_instance))) {
skinny_execute_sql(profile, sql, profile->sql_mutex); skinny_execute_sql(profile, sql, profile->sql_mutex);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -1348,8 +1348,8 @@ switch_status_t dump_device(skinny_profile_t *profile, const char *device_name,
{ {
char *sql; char *sql;
if ((sql = switch_mprintf("SELECT name, user_id, instance, ip, type, max_streams, port, codec_string, headset, handset, speaker " if ((sql = switch_mprintf("SELECT name, user_id, instance, ip, type, max_streams, port, codec_string, headset, handset, speaker "
"FROM skinny_devices WHERE name='%s'", "FROM skinny_devices WHERE name='%s'",
device_name))) { device_name))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, dump_device_callback, stream); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, dump_device_callback, stream);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -1372,7 +1372,7 @@ static void close_socket(switch_socket_t **sock, skinny_profile_t *profile)
static switch_status_t kill_listener(listener_t *listener, void *pvt) static switch_status_t kill_listener(listener_t *listener, void *pvt)
{ {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Killing listener %s:%d.\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Killing listener %s:%d.\n",
listener->device_name, listener->device_instance); listener->device_name, listener->device_instance);
switch_clear_flag(listener, LFLAG_RUNNING); switch_clear_flag(listener, LFLAG_RUNNING);
close_socket(&listener->sock, listener->profile); close_socket(&listener->sock, listener->profile);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
@ -1435,7 +1435,7 @@ static void *SWITCH_THREAD_FUNC listener_run(switch_thread_t *thread, void *obj)
switch(status) { switch(status) {
case SWITCH_STATUS_TIMEOUT: case SWITCH_STATUS_TIMEOUT:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Communication Time Out with %s:%d.\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Communication Time Out with %s:%d.\n",
listener->remote_ip, listener->remote_port); listener->remote_ip, listener->remote_port);
if(listener->expire_time < switch_epoch_time_now(NULL)) { if(listener->expire_time < switch_epoch_time_now(NULL)) {
switch_event_t *event = NULL; switch_event_t *event = NULL;
@ -1446,7 +1446,7 @@ static void *SWITCH_THREAD_FUNC listener_run(switch_thread_t *thread, void *obj)
break; break;
default: default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Communication Error with %s:%d.\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Communication Error with %s:%d.\n",
listener->remote_ip, listener->remote_port); listener->remote_ip, listener->remote_port);
} }
switch_clear_flag_locked(listener, LFLAG_RUNNING); switch_clear_flag_locked(listener, LFLAG_RUNNING);
break; break;
@ -1470,7 +1470,7 @@ static void *SWITCH_THREAD_FUNC listener_run(switch_thread_t *thread, void *obj)
if (listener->profile->debug > 0) { if (listener->profile->debug > 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Communication Complete with %s:%d.\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Communication Complete with %s:%d.\n",
listener->remote_ip, listener->remote_port); listener->remote_ip, listener->remote_port);
} }
switch_thread_rwlock_wrlock(listener->rwlock); switch_thread_rwlock_wrlock(listener->rwlock);
@ -1484,7 +1484,7 @@ static void *SWITCH_THREAD_FUNC listener_run(switch_thread_t *thread, void *obj)
if (listener->profile->debug > 0) { if (listener->profile->debug > 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Communication Closed with %s:%d.\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Communication Closed with %s:%d.\n",
listener->remote_ip, listener->remote_port); listener->remote_ip, listener->remote_port);
} }
if(destroy_pool == 0) { if(destroy_pool == 0) {
@ -1559,7 +1559,7 @@ new_socket:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Socket up listening on %s:%u\n", profile->ip, profile->port); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Socket up listening on %s:%u\n", profile->ip, profile->port);
break; break;
sock_fail: sock_fail:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Error! Could not listen on %s:%u\n", profile->ip, profile->port); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Error! Could not listen on %s:%u\n", profile->ip, profile->port);
switch_yield(100000); switch_yield(100000);
} }
@ -1622,7 +1622,7 @@ new_socket:
} }
end: end:
close_socket(&profile->sock, profile); close_socket(&profile->sock, profile);
@ -1635,7 +1635,7 @@ new_socket:
} }
fail: fail:
return NULL; return NULL;
} }
@ -1677,7 +1677,7 @@ switch_status_t skinny_profile_set(skinny_profile_t *profile, const char *var, c
if (profile->sock && !strcasecmp(var, "odbc-dsn")) { if (profile->sock && !strcasecmp(var, "odbc-dsn")) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"Skinny profile setting 'odbc-dsn' can't be changed while running\n"); "Skinny profile setting 'odbc-dsn' can't be changed while running\n");
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
@ -1758,7 +1758,7 @@ static switch_status_t load_skinny_config(void)
switch_xml_t xsettings, xdevice_types, xsoft_key_set_sets; switch_xml_t xsettings, xdevice_types, xsoft_key_set_sets;
if (zstr(profile_name)) { if (zstr(profile_name)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"<profile> is missing name attribute\n"); "<profile> is missing name attribute\n");
continue; continue;
} }
if ((xsettings = switch_xml_child(xprofile, "settings"))) { if ((xsettings = switch_xml_child(xprofile, "settings"))) {
@ -1767,11 +1767,11 @@ static switch_status_t load_skinny_config(void)
switch_core_db_t *db; switch_core_db_t *db;
skinny_profile_t *profile = NULL; skinny_profile_t *profile = NULL;
switch_xml_t param; switch_xml_t param;
if (switch_core_new_memory_pool(&profile_pool) != SWITCH_STATUS_SUCCESS) { if (switch_core_new_memory_pool(&profile_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "OH OH no pool\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "OH OH no pool\n");
return SWITCH_STATUS_TERM; return SWITCH_STATUS_TERM;
} }
profile = switch_core_alloc(profile_pool, sizeof(skinny_profile_t)); profile = switch_core_alloc(profile_pool, sizeof(skinny_profile_t));
profile->pool = profile_pool; profile->pool = profile_pool;
profile->name = switch_core_strdup(profile->pool, profile_name); profile->name = switch_core_strdup(profile->pool, profile_name);
@ -1780,17 +1780,17 @@ static switch_status_t load_skinny_config(void)
switch_mutex_init(&profile->listener_mutex, SWITCH_MUTEX_NESTED, profile->pool); switch_mutex_init(&profile->listener_mutex, SWITCH_MUTEX_NESTED, profile->pool);
switch_mutex_init(&profile->sock_mutex, SWITCH_MUTEX_NESTED, profile->pool); switch_mutex_init(&profile->sock_mutex, SWITCH_MUTEX_NESTED, profile->pool);
switch_mutex_init(&profile->flag_mutex, SWITCH_MUTEX_NESTED, profile->pool); switch_mutex_init(&profile->flag_mutex, SWITCH_MUTEX_NESTED, profile->pool);
for (param = switch_xml_child(xsettings, "param"); param; param = param->next) { for (param = switch_xml_child(xsettings, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name"); char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value"); char *val = (char *) switch_xml_attr_soft(param, "value");
if (skinny_profile_set(profile, var, val) != SWITCH_STATUS_SUCCESS) { if (skinny_profile_set(profile, var, val) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Unable to set skinny setting '%s'. Does it exists?\n", var); "Unable to set skinny setting '%s'. Does it exists?\n", var);
} }
} /* param */ } /* param */
if (!profile->dialplan) { if (!profile->dialplan) {
skinny_profile_set(profile, "dialplan","XML"); skinny_profile_set(profile, "dialplan","XML");
} }
@ -1838,8 +1838,8 @@ static switch_status_t load_skinny_config(void)
} }
if (soft_key_set_id > 15) { if (soft_key_set_id > 15) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"soft-key-set name '%s' is greater than 15 in soft-key-set-set '%s' in profile %s.\n", "soft-key-set name '%s' is greater than 15 in soft-key-set-set '%s' in profile %s.\n",
switch_xml_attr_soft(xsoft_key_set, "name"), soft_key_set_set_name, profile->name); switch_xml_attr_soft(xsoft_key_set, "name"), soft_key_set_set_name, profile->name);
continue; continue;
} }
for (string_pos = 0; string_pos <= string_len; string_pos++) { for (string_pos = 0; string_pos <= string_len; string_pos++) {
@ -1847,8 +1847,8 @@ static switch_status_t load_skinny_config(void)
val[string_pos] = '\0'; val[string_pos] = '\0';
if (field_no > 15) { if (field_no > 15) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"soft-key-set name '%s' is limited to 16 buttons in soft-key-set-set '%s' in profile %s.\n", "soft-key-set name '%s' is limited to 16 buttons in soft-key-set-set '%s' in profile %s.\n",
switch_xml_attr_soft(xsoft_key_set, "name"), soft_key_set_set_name, profile->name); switch_xml_attr_soft(xsoft_key_set, "name"), soft_key_set_set_name, profile->name);
break; break;
} }
message->data.soft_key_set.soft_key_set[soft_key_set_id].soft_key_template_index[field_no++] = skinny_str2soft_key_event(&val[start]); message->data.soft_key_set.soft_key_set[soft_key_set_id].soft_key_template_index[field_no++] = skinny_str2soft_key_event(&val[start]);
@ -1857,28 +1857,28 @@ static switch_status_t load_skinny_config(void)
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Unknown soft-key-set name '%s' in soft-key-set-set '%s' in profile %s.\n", "Unknown soft-key-set name '%s' in soft-key-set-set '%s' in profile %s.\n",
switch_xml_attr_soft(xsoft_key_set, "name"), soft_key_set_set_name, profile->name); switch_xml_attr_soft(xsoft_key_set, "name"), soft_key_set_set_name, profile->name);
} }
} /* soft-key-set */ } /* soft-key-set */
switch_core_hash_insert(profile->soft_key_set_sets_hash, soft_key_set_set_name, message); switch_core_hash_insert(profile->soft_key_set_sets_hash, soft_key_set_set_name, message);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"<soft-key-set-set> is missing a name attribute in profile %s.\n", profile->name); "<soft-key-set-set> is missing a name attribute in profile %s.\n", profile->name);
} }
} /* soft-key-set-set */ } /* soft-key-set-set */
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"<soft-key-set-sets> is missing in profile %s.\n", profile->name); "<soft-key-set-sets> is missing in profile %s.\n", profile->name);
} /* soft-key-set-sets */ } /* soft-key-set-sets */
if (!switch_core_hash_find(profile->soft_key_set_sets_hash, "default")) { if (!switch_core_hash_find(profile->soft_key_set_sets_hash, "default")) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"Profile %s doesn't have a default <soft-key-set-set>. Profile ignored.\n", profile->name); "Profile %s doesn't have a default <soft-key-set-set>. Profile ignored.\n", profile->name);
switch_core_destroy_memory_pool(&profile_pool); switch_core_destroy_memory_pool(&profile_pool);
continue; continue;
} }
/* Device types */ /* Device types */
switch_core_hash_init(&profile->device_type_params_hash, profile->pool); switch_core_hash_init(&profile->device_type_params_hash, profile->pool);
if ((xdevice_types = switch_xml_child(xprofile, "device-types"))) { if ((xdevice_types = switch_xml_child(xprofile, "device-types"))) {
@ -1893,13 +1893,13 @@ static switch_status_t load_skinny_config(void)
char *val = (char *) switch_xml_attr_soft(param, "value"); char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "firmware-version")) { if (!strcasecmp(var, "firmware-version")) {
strncpy(params->firmware_version, val, 16); strncpy(params->firmware_version, val, 16);
} }
} /* param */ } /* param */
switch_core_hash_insert(profile->device_type_params_hash, id_str, params); switch_core_hash_insert(profile->device_type_params_hash, id_str, params);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Unknow device type %s in profile %s.\n", switch_xml_attr_soft(xdevice_type, "id"), profile->name); "Unknow device type %s in profile %s.\n", switch_xml_attr_soft(xdevice_type, "id"), profile->name);
} }
} }
} }
@ -1936,7 +1936,7 @@ static switch_status_t load_skinny_config(void)
} }
switch_core_db_close(db); switch_core_db_close(db);
} }
skinny_execute_sql_callback(profile, profile->sql_mutex, "DELETE FROM skinny_devices", NULL, NULL); skinny_execute_sql_callback(profile, profile->sql_mutex, "DELETE FROM skinny_devices", NULL, NULL);
skinny_execute_sql_callback(profile, profile->sql_mutex, "DELETE FROM skinny_lines", NULL, NULL); skinny_execute_sql_callback(profile, profile->sql_mutex, "DELETE FROM skinny_lines", NULL, NULL);
skinny_execute_sql_callback(profile, profile->sql_mutex, "DELETE FROM skinny_buttons", NULL, NULL); skinny_execute_sql_callback(profile, profile->sql_mutex, "DELETE FROM skinny_buttons", NULL, NULL);
@ -1945,13 +1945,13 @@ static switch_status_t load_skinny_config(void)
skinny_profile_respawn(profile, 0); skinny_profile_respawn(profile, 0);
/* Register profile */ /* Register profile */
switch_mutex_lock(globals.mutex); switch_mutex_lock(globals.mutex);
switch_core_hash_insert(globals.profile_hash, profile->name, profile); switch_core_hash_insert(globals.profile_hash, profile->name, profile);
switch_mutex_unlock(globals.mutex); switch_mutex_unlock(globals.mutex);
profile = NULL; profile = NULL;
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"Settings are missing from profile %s.\n", profile_name); "Settings are missing from profile %s.\n", profile_name);
} /* settings */ } /* settings */
} /* profile */ } /* profile */
} }
@ -1991,26 +1991,26 @@ static void skinny_user_to_device_event_handler(switch_event_t *event)
case USER_TO_DEVICE_DATA_MESSAGE: case USER_TO_DEVICE_DATA_MESSAGE:
data_length = strlen(data); /* we ignore data_length sent */ data_length = strlen(data); /* we ignore data_length sent */
send_data(listener, message_type, send_data(listener, message_type,
application_id, line_instance, call_id, transaction_id, data_length, application_id, line_instance, call_id, transaction_id, data_length,
data); data);
case USER_TO_DEVICE_DATA_VERSION1_MESSAGE: case USER_TO_DEVICE_DATA_VERSION1_MESSAGE:
data_length = strlen(data); /* we ignore data_length sent */ data_length = strlen(data); /* we ignore data_length sent */
send_extended_data(listener, message_type, send_extended_data(listener, message_type,
application_id, line_instance, call_id, transaction_id, data_length, application_id, line_instance, call_id, transaction_id, data_length,
sequence_flag, display_priority, conference_id, app_instance_id, routing_id, sequence_flag, display_priority, conference_id, app_instance_id, routing_id,
data); data);
break; break;
default: default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Incorrect message type %s (%d).\n", skinny_message_type2str(message_type), message_type); "Incorrect message type %s (%d).\n", skinny_message_type2str(message_type), message_type);
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Device %s:%d in profile '%s' not found.\n", device_name, device_instance, profile_name); "Device %s:%d in profile '%s' not found.\n", device_name, device_instance, profile_name);
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Profile '%s' not found.\n", profile_name); "Profile '%s' not found.\n", profile_name);
} }
} }
@ -2032,41 +2032,41 @@ static void skinny_call_state_event_handler(switch_event_t *event)
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
skinny_profile_find_listener_by_device_name_and_instance(profile, device_name, device_instance, &listener); skinny_profile_find_listener_by_device_name_and_instance(profile, device_name, device_instance, &listener);
if(listener) { if(listener) {
if(line_instance > 0) { if(line_instance > 0) {
line_instance_condition = switch_mprintf("line_instance=%d", line_instance); line_instance_condition = switch_mprintf("line_instance=%d", line_instance);
} else { } else {
line_instance_condition = switch_mprintf("1=1"); line_instance_condition = switch_mprintf("1=1");
} }
switch_assert(line_instance_condition); switch_assert(line_instance_condition);
if(call_id > 0) { if(call_id > 0) {
call_id_condition = switch_mprintf("call_id=%d", call_id); call_id_condition = switch_mprintf("call_id=%d", call_id);
} else { } else {
call_id_condition = switch_mprintf("1=1"); call_id_condition = switch_mprintf("1=1");
} }
switch_assert(call_id_condition); switch_assert(call_id_condition);
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"UPDATE skinny_active_lines " "UPDATE skinny_active_lines "
"SET call_state=%d " "SET call_state=%d "
"WHERE device_name='%s' AND device_instance=%d " "WHERE device_name='%s' AND device_instance=%d "
"AND %s AND %s", "AND %s AND %s",
call_state, call_state,
listener->device_name, listener->device_instance, listener->device_name, listener->device_instance,
line_instance_condition, call_id_condition line_instance_condition, call_id_condition
))) { ))) {
skinny_execute_sql(listener->profile, sql, listener->profile->sql_mutex); skinny_execute_sql(listener->profile, sql, listener->profile->sql_mutex);
switch_safe_free(sql); switch_safe_free(sql);
} }
switch_safe_free(line_instance_condition); switch_safe_free(line_instance_condition);
switch_safe_free(call_id_condition); switch_safe_free(call_id_condition);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Device %s:%d in profile '%s' not found.\n", device_name, device_instance, profile_name); "Device %s:%d in profile '%s' not found.\n", device_name, device_instance, profile_name);
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Profile '%s' not found.\n", profile_name); "Profile '%s' not found.\n", profile_name);
} }
} }
} }
@ -2089,7 +2089,7 @@ int skinny_message_waiting_event_handler_callback(void *pArg, int argc, char **a
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name_and_instance(helper->profile, skinny_profile_find_listener_by_device_name_and_instance(helper->profile,
device_name, device_instance, &listener); device_name, device_instance, &listener);
if (listener) { if (listener) {
if (helper->yn == SWITCH_TRUE) { if (helper->yn == SWITCH_TRUE) {
@ -2143,15 +2143,15 @@ static void skinny_message_waiting_event_handler(switch_event_t *event)
count_str = switch_event_get_header(event, "mwi-voice-message"); count_str = switch_event_get_header(event, "mwi-voice-message");
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT device_name, device_instance FROM skinny_lines " "SELECT device_name, device_instance FROM skinny_lines "
"WHERE value='%s' AND line_instance=1", user))) { "WHERE value='%s' AND line_instance=1", user))) {
struct skinny_message_waiting_event_handler_helper helper = {0}; struct skinny_message_waiting_event_handler_helper helper = {0};
helper.profile = profile; helper.profile = profile;
helper.yn = switch_true(yn); helper.yn = switch_true(yn);
if (count_str) { if (count_str) {
sscanf(count_str,"%d/%d (%d/%d)", sscanf(count_str,"%d/%d (%d/%d)",
&helper.total_new_messages, &helper.total_saved_messages, &helper.total_new_messages, &helper.total_saved_messages,
&helper.total_new_urgent_messages, &helper.total_saved_urgent_messages); &helper.total_new_urgent_messages, &helper.total_saved_urgent_messages);
} }
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_message_waiting_event_handler_callback, &helper); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_message_waiting_event_handler_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
@ -2285,7 +2285,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_skinny_load)
switch_hash_this(hi, NULL, NULL, &val); switch_hash_this(hi, NULL, NULL, &val);
profile = (skinny_profile_t *) val; profile = (skinny_profile_t *) val;
launch_skinny_profile_thread(profile); launch_skinny_profile_thread(profile);
} }
switch_mutex_unlock(globals.mutex); switch_mutex_unlock(globals.mutex);
@ -2303,7 +2303,7 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_skinny_shutdown)
int sanity = 0; int sanity = 0;
skinny_api_unregister(); skinny_api_unregister();
/* release events */ /* release events */
switch_event_unbind(&globals.user_to_device_node); switch_event_unbind(&globals.user_to_device_node);
switch_event_unbind(&globals.call_state_node); switch_event_unbind(&globals.call_state_node);

120
src/mod/endpoints/mod_skinny/mod_skinny.h
View File

@ -48,66 +48,66 @@
#define SKINNY_EVENT_DEVICE_TO_USER "skinny::device_to_user" #define SKINNY_EVENT_DEVICE_TO_USER "skinny::device_to_user"
struct skinny_globals { struct skinny_globals {
int running; int running;
switch_memory_pool_t *pool; switch_memory_pool_t *pool;
switch_mutex_t *mutex; switch_mutex_t *mutex;
switch_hash_t *profile_hash; switch_hash_t *profile_hash;
switch_event_node_t *user_to_device_node; switch_event_node_t *user_to_device_node;
switch_event_node_t *call_state_node; switch_event_node_t *call_state_node;
switch_event_node_t *message_waiting_node; switch_event_node_t *message_waiting_node;
switch_event_node_t *trap_node; switch_event_node_t *trap_node;
int auto_restart; int auto_restart;
}; };
typedef struct skinny_globals skinny_globals_t; typedef struct skinny_globals skinny_globals_t;
extern skinny_globals_t globals; extern skinny_globals_t globals;
typedef enum { typedef enum {
PFLAG_LISTENER_READY = (1 << 0), PFLAG_LISTENER_READY = (1 << 0),
PFLAG_SHOULD_RESPAWN = (1 << 1), PFLAG_SHOULD_RESPAWN = (1 << 1),
PFLAG_RESPAWN = (1 << 2), PFLAG_RESPAWN = (1 << 2),
} profile_flag_t; } profile_flag_t;
struct skinny_profile { struct skinny_profile {
/* prefs */ /* prefs */
char *name; char *name;
char *domain; char *domain;
char *ip; char *ip;
unsigned int port; unsigned int port;
char *dialplan; char *dialplan;
char *context; char *context;
char *patterns_dialplan; char *patterns_dialplan;
char *patterns_context; char *patterns_context;
uint32_t keep_alive; uint32_t keep_alive;
char date_format[6]; char date_format[6];
int debug; int debug;
int auto_restart; int auto_restart;
switch_hash_t *soft_key_set_sets_hash; switch_hash_t *soft_key_set_sets_hash;
switch_hash_t *device_type_params_hash; switch_hash_t *device_type_params_hash;
/* db */ /* db */
char *dbname; char *dbname;
char *odbc_dsn; char *odbc_dsn;
char *odbc_user; char *odbc_user;
char *odbc_pass; char *odbc_pass;
switch_odbc_handle_t *master_odbc; switch_odbc_handle_t *master_odbc;
switch_mutex_t *sql_mutex; switch_mutex_t *sql_mutex;
/* stats */ /* stats */
uint32_t ib_calls; uint32_t ib_calls;
uint32_t ob_calls; uint32_t ob_calls;
uint32_t ib_failed_calls; uint32_t ib_failed_calls;
uint32_t ob_failed_calls; uint32_t ob_failed_calls;
/* listener */ /* listener */
int listener_threads; int listener_threads;
switch_mutex_t *listener_mutex; switch_mutex_t *listener_mutex;
switch_socket_t *sock; switch_socket_t *sock;
switch_mutex_t *sock_mutex; switch_mutex_t *sock_mutex;
struct listener *listeners; struct listener *listeners;
int flags; int flags;
switch_mutex_t *flag_mutex; switch_mutex_t *flag_mutex;
/* call id */ /* call id */
uint32_t next_call_id; uint32_t next_call_id;
/* others */ /* others */
switch_memory_pool_t *pool; switch_memory_pool_t *pool;
}; };
typedef struct skinny_profile skinny_profile_t; typedef struct skinny_profile skinny_profile_t;
@ -127,7 +127,7 @@ typedef enum {
/*****************************************************************************/ /*****************************************************************************/
typedef enum { typedef enum {
LFLAG_RUNNING = (1 << 0), LFLAG_RUNNING = (1 << 0),
} listener_flag_t; } listener_flag_t;
#define SKINNY_MAX_LINES 42 #define SKINNY_MAX_LINES 42
@ -161,15 +161,15 @@ typedef switch_status_t (*skinny_listener_callback_func_t) (listener_t *listener
/* CHANNEL TYPES */ /* CHANNEL TYPES */
/*****************************************************************************/ /*****************************************************************************/
typedef enum { typedef enum {
TFLAG_FORCE_ROUTE = (1 << 0), TFLAG_FORCE_ROUTE = (1 << 0),
TFLAG_EARLY_MEDIA = (1 << 1), TFLAG_EARLY_MEDIA = (1 << 1),
TFLAG_IO = (1 << 2), TFLAG_IO = (1 << 2),
TFLAG_READING = (1 << 3), TFLAG_READING = (1 << 3),
TFLAG_WRITING = (1 << 4) TFLAG_WRITING = (1 << 4)
} TFLAGS; } TFLAGS;
typedef enum { typedef enum {
GFLAG_MY_CODEC_PREFS = (1 << 0) GFLAG_MY_CODEC_PREFS = (1 << 0)
} GFLAGS; } GFLAGS;
struct private_object { struct private_object {
@ -236,7 +236,7 @@ void profile_walk_listeners(skinny_profile_t *profile, skinny_listener_callback_
switch_cache_db_handle_t *skinny_get_db_handle(skinny_profile_t *profile); switch_cache_db_handle_t *skinny_get_db_handle(skinny_profile_t *profile);
switch_status_t skinny_execute_sql(skinny_profile_t *profile, char *sql, switch_mutex_t *mutex); switch_status_t skinny_execute_sql(skinny_profile_t *profile, char *sql, switch_mutex_t *mutex);
switch_bool_t skinny_execute_sql_callback(skinny_profile_t *profile, switch_bool_t skinny_execute_sql_callback(skinny_profile_t *profile,
switch_mutex_t *mutex, char *sql, switch_core_db_callback_func_t callback, void *pdata); switch_mutex_t *mutex, char *sql, switch_core_db_callback_func_t callback, void *pdata);
/*****************************************************************************/ /*****************************************************************************/
/* LISTENER FUNCTIONS */ /* LISTENER FUNCTIONS */
@ -261,8 +261,8 @@ switch_status_t channel_on_routing(switch_core_session_t *session);
switch_status_t channel_on_exchange_media(switch_core_session_t *session); switch_status_t channel_on_exchange_media(switch_core_session_t *session);
switch_status_t channel_on_soft_execute(switch_core_session_t *session); switch_status_t channel_on_soft_execute(switch_core_session_t *session);
switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,
switch_caller_profile_t *outbound_profile, switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause); switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause);
switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id); switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);
switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id); switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
switch_status_t channel_kill_channel(switch_core_session_t *session, int sig); switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);

698
src/mod/endpoints/mod_skinny/skinny_api.c
View File

@ -41,202 +41,202 @@
static switch_status_t skinny_api_list_profiles(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_profiles(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_console_callback_match_t *my_matches = NULL; switch_console_callback_match_t *my_matches = NULL;
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_hash_index_t *hi; switch_hash_index_t *hi;
void *val; void *val;
skinny_profile_t *profile; skinny_profile_t *profile;
/* walk profiles */ /* walk profiles */
switch_mutex_lock(globals.mutex); switch_mutex_lock(globals.mutex);
for (hi = switch_hash_first(NULL, globals.profile_hash); hi; hi = switch_hash_next(hi)) { for (hi = switch_hash_first(NULL, globals.profile_hash); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, NULL, NULL, &val); switch_hash_this(hi, NULL, NULL, &val);
profile = (skinny_profile_t *) val; profile = (skinny_profile_t *) val;
switch_console_push_match(&my_matches, profile->name); switch_console_push_match(&my_matches, profile->name);
} }
switch_mutex_unlock(globals.mutex); switch_mutex_unlock(globals.mutex);
if (my_matches) { if (my_matches) {
*matches = my_matches; *matches = my_matches;
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
return status; return status;
} }
struct match_helper { struct match_helper {
switch_console_callback_match_t *my_matches; switch_console_callback_match_t *my_matches;
}; };
static int skinny_api_list_devices_callback(void *pArg, int argc, char **argv, char **columnNames) static int skinny_api_list_devices_callback(void *pArg, int argc, char **argv, char **columnNames)
{ {
struct match_helper *h = (struct match_helper *) pArg; struct match_helper *h = (struct match_helper *) pArg;
char *device_name = argv[0]; char *device_name = argv[0];
switch_console_push_match(&h->my_matches, device_name); switch_console_push_match(&h->my_matches, device_name);
return 0; return 0;
} }
static switch_status_t skinny_api_list_devices(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_devices(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
struct match_helper h = { 0 }; struct match_helper h = { 0 };
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
skinny_profile_t *profile = NULL; skinny_profile_t *profile = NULL;
char *sql; char *sql;
char *myline; char *myline;
char *argv[1024] = { 0 }; char *argv[1024] = { 0 };
int argc = 0; int argc = 0;
if (!(myline = strdup(line))) { if (!(myline = strdup(line))) {
status = SWITCH_STATUS_MEMERR; status = SWITCH_STATUS_MEMERR;
return status; return status;
} }
if (!(argc = switch_separate_string(myline, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) || argc < 4) { if (!(argc = switch_separate_string(myline, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) || argc < 4) {
return status; return status;
} }
if(!strcasecmp(argv[1], "profile")) {/* skinny profile <profile_name> ... */ if(!strcasecmp(argv[1], "profile")) {/* skinny profile <profile_name> ... */
profile = skinny_find_profile(argv[2]); profile = skinny_find_profile(argv[2]);
} else if(!strcasecmp(argv[2], "profile")) {/* skinny status profile <profile_name> ... */ } else if(!strcasecmp(argv[2], "profile")) {/* skinny status profile <profile_name> ... */
profile = skinny_find_profile(argv[3]); profile = skinny_find_profile(argv[3]);
} }
if(profile) { if(profile) {
if ((sql = switch_mprintf("SELECT name FROM skinny_devices"))) { if ((sql = switch_mprintf("SELECT name FROM skinny_devices"))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_api_list_devices_callback, &h); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_api_list_devices_callback, &h);
switch_safe_free(sql); switch_safe_free(sql);
} }
} }
if (h.my_matches) { if (h.my_matches) {
*matches = h.my_matches; *matches = h.my_matches;
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
return status; return status;
} }
static switch_status_t skinny_api_list_reset_types(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_reset_types(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_DEVICE_RESET_TYPES SKINNY_PUSH_DEVICE_RESET_TYPES
return status; return status;
} }
static switch_status_t skinny_api_list_stimuli(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_stimuli(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_STIMULI SKINNY_PUSH_STIMULI
return status; return status;
} }
static switch_status_t skinny_api_list_ring_types(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_ring_types(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_RING_TYPES SKINNY_PUSH_RING_TYPES
return status; return status;
} }
static switch_status_t skinny_api_list_ring_modes(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_ring_modes(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_RING_MODES SKINNY_PUSH_RING_MODES
return status; return status;
} }
static switch_status_t skinny_api_list_stimulus_instances(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_stimulus_instances(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_console_callback_match_t *my_matches = NULL; switch_console_callback_match_t *my_matches = NULL;
switch_console_push_match(&my_matches, "<stimulus_instance>"); switch_console_push_match(&my_matches, "<stimulus_instance>");
switch_console_push_match(&my_matches, "0"); switch_console_push_match(&my_matches, "0");
if (my_matches) { if (my_matches) {
*matches = my_matches; *matches = my_matches;
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
return status; return status;
} }
static switch_status_t skinny_api_list_stimulus_modes(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_stimulus_modes(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_LAMP_MODES SKINNY_PUSH_LAMP_MODES
return status; return status;
} }
static switch_status_t skinny_api_list_speaker_modes(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_speaker_modes(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_SPEAKER_MODES SKINNY_PUSH_SPEAKER_MODES
return status; return status;
} }
static switch_status_t skinny_api_list_call_states(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_call_states(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
SKINNY_PUSH_CALL_STATES SKINNY_PUSH_CALL_STATES
return status; return status;
} }
static switch_status_t skinny_api_list_line_instances(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_line_instances(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_console_callback_match_t *my_matches = NULL; switch_console_callback_match_t *my_matches = NULL;
/* TODO */ /* TODO */
switch_console_push_match(&my_matches, "1"); switch_console_push_match(&my_matches, "1");
switch_console_push_match(&my_matches, "<line_instance>"); switch_console_push_match(&my_matches, "<line_instance>");
if (my_matches) { if (my_matches) {
*matches = my_matches; *matches = my_matches;
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
return status; return status;
} }
static switch_status_t skinny_api_list_call_ids(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_call_ids(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_console_callback_match_t *my_matches = NULL; switch_console_callback_match_t *my_matches = NULL;
/* TODO */ /* TODO */
switch_console_push_match(&my_matches, "1345"); switch_console_push_match(&my_matches, "1345");
switch_console_push_match(&my_matches, "<call_id>"); switch_console_push_match(&my_matches, "<call_id>");
if (my_matches) { if (my_matches) {
*matches = my_matches; *matches = my_matches;
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
return status; return status;
} }
static switch_status_t skinny_api_list_settings(const char *line, const char *cursor, switch_console_callback_match_t **matches) static switch_status_t skinny_api_list_settings(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_console_callback_match_t *my_matches = NULL; switch_console_callback_match_t *my_matches = NULL;
switch_console_push_match(&my_matches, "domain"); switch_console_push_match(&my_matches, "domain");
switch_console_push_match(&my_matches, "ip"); switch_console_push_match(&my_matches, "ip");
switch_console_push_match(&my_matches, "port"); switch_console_push_match(&my_matches, "port");
switch_console_push_match(&my_matches, "patterns-dialplan"); switch_console_push_match(&my_matches, "patterns-dialplan");
switch_console_push_match(&my_matches, "patterns-context"); switch_console_push_match(&my_matches, "patterns-context");
switch_console_push_match(&my_matches, "dialplan"); switch_console_push_match(&my_matches, "dialplan");
switch_console_push_match(&my_matches, "context"); switch_console_push_match(&my_matches, "context");
switch_console_push_match(&my_matches, "keep-alive"); switch_console_push_match(&my_matches, "keep-alive");
switch_console_push_match(&my_matches, "date-format"); switch_console_push_match(&my_matches, "date-format");
switch_console_push_match(&my_matches, "odbc-dsn"); switch_console_push_match(&my_matches, "odbc-dsn");
switch_console_push_match(&my_matches, "debug"); switch_console_push_match(&my_matches, "debug");
switch_console_push_match(&my_matches, "auto-restart"); switch_console_push_match(&my_matches, "auto-restart");
if (my_matches) { if (my_matches) {
*matches = my_matches; *matches = my_matches;
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
return status; return status;
} }
/*****************************************************************************/ /*****************************************************************************/
@ -244,136 +244,136 @@ static switch_status_t skinny_api_list_settings(const char *line, const char *cu
/*****************************************************************************/ /*****************************************************************************/
static switch_status_t skinny_api_cmd_status_profile(const char *profile_name, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_status_profile(const char *profile_name, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
skinny_profile_dump(profile, stream); skinny_profile_dump(profile, stream);
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_status_profile_device(const char *profile_name, const char *device_name, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_status_profile_device(const char *profile_name, const char *device_name, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
dump_device(profile, device_name, stream); dump_device(profile, device_name, stream);
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_device_send_ringer_message(const char *profile_name, const char *device_name, const char *ring_type, const char *ring_mode, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_device_send_ringer_message(const char *profile_name, const char *device_name, const char *ring_type, const char *ring_mode, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name(profile, device_name, &listener); skinny_profile_find_listener_by_device_name(profile, device_name, &listener);
if(listener) { if(listener) {
send_set_ringer(listener, skinny_str2ring_type(ring_type), skinny_str2ring_mode(ring_mode), 0, 0); send_set_ringer(listener, skinny_str2ring_type(ring_type), skinny_str2ring_mode(ring_mode), 0, 0);
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Listener not found!\n"); stream->write_function(stream, "Listener not found!\n");
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_device_send_lamp_message(const char *profile_name, const char *device_name, const char *stimulus, const char *instance, const char *lamp_mode, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_device_send_lamp_message(const char *profile_name, const char *device_name, const char *stimulus, const char *instance, const char *lamp_mode, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name(profile, device_name, &listener); skinny_profile_find_listener_by_device_name(profile, device_name, &listener);
if(listener) { if(listener) {
send_set_lamp(listener, skinny_str2button(stimulus), atoi(instance), skinny_str2lamp_mode(lamp_mode)); send_set_lamp(listener, skinny_str2button(stimulus), atoi(instance), skinny_str2lamp_mode(lamp_mode));
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Listener not found!\n"); stream->write_function(stream, "Listener not found!\n");
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_device_send_speaker_mode_message(const char *profile_name, const char *device_name, const char *speaker_mode, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_device_send_speaker_mode_message(const char *profile_name, const char *device_name, const char *speaker_mode, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name(profile, device_name, &listener); skinny_profile_find_listener_by_device_name(profile, device_name, &listener);
if(listener) { if(listener) {
send_set_speaker_mode(listener, skinny_str2speaker_mode(speaker_mode)); send_set_speaker_mode(listener, skinny_str2speaker_mode(speaker_mode));
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Listener not found!\n"); stream->write_function(stream, "Listener not found!\n");
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_device_send_call_state_message(const char *profile_name, const char *device_name, const char *call_state, const char *line_instance, const char *call_id, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_device_send_call_state_message(const char *profile_name, const char *device_name, const char *call_state, const char *line_instance, const char *call_id, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name(profile, device_name, &listener); skinny_profile_find_listener_by_device_name(profile, device_name, &listener);
if(listener) { if(listener) {
send_call_state(listener, skinny_str2call_state(call_state), atoi(line_instance), atoi(call_id)); send_call_state(listener, skinny_str2call_state(call_state), atoi(line_instance), atoi(call_id));
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Listener not found!\n"); stream->write_function(stream, "Listener not found!\n");
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_device_send_reset_message(const char *profile_name, const char *device_name, const char *reset_type, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_device_send_reset_message(const char *profile_name, const char *device_name, const char *reset_type, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name(profile, device_name, &listener); skinny_profile_find_listener_by_device_name(profile, device_name, &listener);
if(listener) { if(listener) {
send_reset(listener, skinny_str2device_reset_type(reset_type)); send_reset(listener, skinny_str2device_reset_type(reset_type));
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Listener not found!\n"); stream->write_function(stream, "Listener not found!\n");
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_device_send_data(const char *profile_name, const char *device_name, const char *message_type, char *params, const char *body, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_device_send_data(const char *profile_name, const char *device_name, const char *message_type, char *params, const char *body, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
listener_t *listener = NULL; listener_t *listener = NULL;
skinny_profile_find_listener_by_device_name(profile, device_name, &listener); skinny_profile_find_listener_by_device_name(profile, device_name, &listener);
if(listener) { if(listener) {
switch_event_t *event = NULL; switch_event_t *event = NULL;
char *argv[64] = { 0 }; char *argv[64] = { 0 };
int argc = 0; int argc = 0;
@ -395,49 +395,49 @@ static switch_status_t skinny_api_cmd_profile_device_send_data(const char *profi
switch_event_add_header(event, SWITCH_STACK_BOTTOM, tmp, "%s", var_value); switch_event_add_header(event, SWITCH_STACK_BOTTOM, tmp, "%s", var_value);
switch_safe_free(tmp); switch_safe_free(tmp);
/* /*
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Application-Id", "%d", request->data.extended_data.application_id); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Application-Id", "%d", request->data.extended_data.application_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Line-Instance", "%d", request->data.extended_data.line_instance); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Line-Instance", "%d", request->data.extended_data.line_instance);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Call-Id", "%d", request->data.extended_data.call_id); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Call-Id", "%d", request->data.extended_data.call_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Transaction-Id", "%d", request->data.extended_data.transaction_id); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Transaction-Id", "%d", request->data.extended_data.transaction_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Data-Length", "%d", request->data.extended_data.data_length); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Data-Length", "%d", request->data.extended_data.data_length);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Sequence-Flag", "%d", request->data.extended_data.sequence_flag); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Sequence-Flag", "%d", request->data.extended_data.sequence_flag);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Display-Priority", "%d", request->data.extended_data.display_priority); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Display-Priority", "%d", request->data.extended_data.display_priority);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Conference-Id", "%d", request->data.extended_data.conference_id); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Conference-Id", "%d", request->data.extended_data.conference_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-App-Instance-Id", "%d", request->data.extended_data.app_instance_id); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-App-Instance-Id", "%d", request->data.extended_data.app_instance_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Routing-Id", "%d", request->data.extended_data.routing_id); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Routing-Id", "%d", request->data.extended_data.routing_id);
*/ */
} }
} }
switch_event_add_body(event, "%s", body); switch_event_add_body(event, "%s", body);
switch_event_fire(&event); switch_event_fire(&event);
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Listener not found!\n"); stream->write_function(stream, "Listener not found!\n");
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t skinny_api_cmd_profile_set(const char *profile_name, const char *name, const char *value, switch_stream_handle_t *stream) static switch_status_t skinny_api_cmd_profile_set(const char *profile_name, const char *name, const char *value, switch_stream_handle_t *stream)
{ {
skinny_profile_t *profile; skinny_profile_t *profile;
if ((profile = skinny_find_profile(profile_name))) { if ((profile = skinny_find_profile(profile_name))) {
if (skinny_profile_set(profile, name, value) == SWITCH_STATUS_SUCCESS) { if (skinny_profile_set(profile, name, value) == SWITCH_STATUS_SUCCESS) {
skinny_profile_respawn(profile, 0); skinny_profile_respawn(profile, 0);
stream->write_function(stream, "+OK\n"); stream->write_function(stream, "+OK\n");
} else { } else {
stream->write_function(stream, "Unable to set skinny setting '%s'. Does it exists?\n", name); stream->write_function(stream, "Unable to set skinny setting '%s'. Does it exists?\n", name);
} }
} else { } else {
stream->write_function(stream, "Profile not found!\n"); stream->write_function(stream, "Profile not found!\n");
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
/*****************************************************************************/ /*****************************************************************************/
@ -445,148 +445,148 @@ static switch_status_t skinny_api_cmd_profile_set(const char *profile_name, cons
/*****************************************************************************/ /*****************************************************************************/
SWITCH_STANDARD_API(skinny_function) SWITCH_STANDARD_API(skinny_function)
{ {
char *argv[1024] = { 0 }; char *argv[1024] = { 0 };
int argc = 0; int argc = 0;
char *mycmd = NULL; char *mycmd = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
const char *usage_string = "USAGE:\n" const char *usage_string = "USAGE:\n"
"--------------------------------------------------------------------------------\n" "--------------------------------------------------------------------------------\n"
"skinny help\n" "skinny help\n"
"skinny status profile <profile_name>\n" "skinny status profile <profile_name>\n"
"skinny status profile <profile_name> device <device_name>\n" "skinny status profile <profile_name> device <device_name>\n"
"skinny profile <profile_name> device <device_name> send ResetMessage [DeviceReset|DeviceRestart]\n" "skinny profile <profile_name> device <device_name> send ResetMessage [DeviceReset|DeviceRestart]\n"
"skinny profile <profile_name> device <device_name> send SetRingerMessage <ring_type> <ring_mode>\n" "skinny profile <profile_name> device <device_name> send SetRingerMessage <ring_type> <ring_mode>\n"
"skinny profile <profile_name> device <device_name> send SetLampMessage <stimulus> <instance> <lamp_mode>\n" "skinny profile <profile_name> device <device_name> send SetLampMessage <stimulus> <instance> <lamp_mode>\n"
"skinny profile <profile_name> device <device_name> send SetSpeakerModeMessage <speaker_mode>\n" "skinny profile <profile_name> device <device_name> send SetSpeakerModeMessage <speaker_mode>\n"
"skinny profile <profile_name> device <device_name> send CallStateMessage <call_state> <line_instance> <call_id>\n" "skinny profile <profile_name> device <device_name> send CallStateMessage <call_state> <line_instance> <call_id>\n"
"skinny profile <profile_name> device <device_name> send <UserToDeviceDataMessage|UserToDeviceDataVersion1Message> [ <param>=<value>;... ] <data>\n" "skinny profile <profile_name> device <device_name> send <UserToDeviceDataMessage|UserToDeviceDataVersion1Message> [ <param>=<value>;... ] <data>\n"
"skinny profile <profile_name> set <name> <value>\n" "skinny profile <profile_name> set <name> <value>\n"
"--------------------------------------------------------------------------------\n"; "--------------------------------------------------------------------------------\n";
if (session) { if (session) {
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
if (zstr(cmd)) { if (zstr(cmd)) {
stream->write_function(stream, "%s", usage_string); stream->write_function(stream, "%s", usage_string);
goto done; goto done;
} }
if (!(mycmd = strdup(cmd))) { if (!(mycmd = strdup(cmd))) {
status = SWITCH_STATUS_MEMERR; status = SWITCH_STATUS_MEMERR;
goto done; goto done;
} }
if (!(argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) || !argv[0]) { if (!(argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) || !argv[0]) {
stream->write_function(stream, "%s", usage_string); stream->write_function(stream, "%s", usage_string);
goto done; goto done;
} }
if (!strcasecmp(argv[0], "help")) {/* skinny help */ if (!strcasecmp(argv[0], "help")) {/* skinny help */
stream->write_function(stream, "%s", usage_string); stream->write_function(stream, "%s", usage_string);
} else if (argc == 3 && !strcasecmp(argv[0], "status") && !strcasecmp(argv[1], "profile")) { } else if (argc == 3 && !strcasecmp(argv[0], "status") && !strcasecmp(argv[1], "profile")) {
/* skinny status profile <profile_name> */ /* skinny status profile <profile_name> */
status = skinny_api_cmd_status_profile(argv[2], stream); status = skinny_api_cmd_status_profile(argv[2], stream);
} else if (argc == 5 && !strcasecmp(argv[0], "status") && !strcasecmp(argv[1], "profile") && !strcasecmp(argv[3], "device")) { } else if (argc == 5 && !strcasecmp(argv[0], "status") && !strcasecmp(argv[1], "profile") && !strcasecmp(argv[3], "device")) {
/* skinny status profile <profile_name> device <device_name> */ /* skinny status profile <profile_name> device <device_name> */
status = skinny_api_cmd_status_profile_device(argv[2], argv[4], stream); status = skinny_api_cmd_status_profile_device(argv[2], argv[4], stream);
} else if (argc >= 6 && !strcasecmp(argv[0], "profile") && !strcasecmp(argv[2], "device") && !strcasecmp(argv[4], "send")) { } else if (argc >= 6 && !strcasecmp(argv[0], "profile") && !strcasecmp(argv[2], "device") && !strcasecmp(argv[4], "send")) {
/* skinny profile <profile_name> device <device_name> send ... */ /* skinny profile <profile_name> device <device_name> send ... */
switch(skinny_str2message_type(argv[5])) { switch(skinny_str2message_type(argv[5])) {
case SET_RINGER_MESSAGE: case SET_RINGER_MESSAGE:
if(argc == 8) { if(argc == 8) {
/* SetRingerMessage <ring_type> <ring_mode> */ /* SetRingerMessage <ring_type> <ring_mode> */
status = skinny_api_cmd_profile_device_send_ringer_message(argv[1], argv[3], argv[6], argv[7], stream); status = skinny_api_cmd_profile_device_send_ringer_message(argv[1], argv[3], argv[6], argv[7], stream);
} }
break; break;
case SET_LAMP_MESSAGE: case SET_LAMP_MESSAGE:
if (argc == 9) { if (argc == 9) {
/* SetLampMessage <stimulus> <instance> <lamp_mode> */ /* SetLampMessage <stimulus> <instance> <lamp_mode> */
status = skinny_api_cmd_profile_device_send_lamp_message(argv[1], argv[3], argv[6], argv[7], argv[8], stream); status = skinny_api_cmd_profile_device_send_lamp_message(argv[1], argv[3], argv[6], argv[7], argv[8], stream);
} }
break; break;
case SET_SPEAKER_MODE_MESSAGE: case SET_SPEAKER_MODE_MESSAGE:
if (argc == 7) { if (argc == 7) {
/* SetSpeakerModeMessage <speaker_mode> */ /* SetSpeakerModeMessage <speaker_mode> */
status = skinny_api_cmd_profile_device_send_speaker_mode_message(argv[1], argv[3], argv[6], stream); status = skinny_api_cmd_profile_device_send_speaker_mode_message(argv[1], argv[3], argv[6], stream);
} }
break; break;
case CALL_STATE_MESSAGE: case CALL_STATE_MESSAGE:
if (argc == 9) { if (argc == 9) {
/* CallStateMessage <call_state> <line_instance> <call_id> */ /* CallStateMessage <call_state> <line_instance> <call_id> */
status = skinny_api_cmd_profile_device_send_call_state_message(argv[1], argv[3], argv[6], argv[7], argv[8], stream); status = skinny_api_cmd_profile_device_send_call_state_message(argv[1], argv[3], argv[6], argv[7], argv[8], stream);
} }
break; break;
case RESET_MESSAGE: case RESET_MESSAGE:
if (argc == 7) { if (argc == 7) {
/* ResetMessage <reset_type> */ /* ResetMessage <reset_type> */
status = skinny_api_cmd_profile_device_send_reset_message(argv[1], argv[3], argv[6], stream); status = skinny_api_cmd_profile_device_send_reset_message(argv[1], argv[3], argv[6], stream);
} }
break; break;
case USER_TO_DEVICE_DATA_MESSAGE: case USER_TO_DEVICE_DATA_MESSAGE:
case USER_TO_DEVICE_DATA_VERSION1_MESSAGE: case USER_TO_DEVICE_DATA_VERSION1_MESSAGE:
if(argc == 8) { if(argc == 8) {
/* <UserToDeviceDataMessage|UserToDeviceDataVersion1Message> [ <param>=<value>;... ] <data> */ /* <UserToDeviceDataMessage|UserToDeviceDataVersion1Message> [ <param>=<value>;... ] <data> */
status = skinny_api_cmd_profile_device_send_data(argv[1], argv[3], argv[5], argv[6], argv[7], stream); status = skinny_api_cmd_profile_device_send_data(argv[1], argv[3], argv[5], argv[6], argv[7], stream);
} else if(argc == 7) { } else if(argc == 7) {
/* <UserToDeviceDataMessage|UserToDeviceDataVersion1Message> <data> */ /* <UserToDeviceDataMessage|UserToDeviceDataVersion1Message> <data> */
status = skinny_api_cmd_profile_device_send_data(argv[1], argv[3], argv[5], "", argv[6], stream); status = skinny_api_cmd_profile_device_send_data(argv[1], argv[3], argv[5], "", argv[6], stream);
} }
break; break;
default: default:
stream->write_function(stream, "Unhandled message %s\n", argv[5]); stream->write_function(stream, "Unhandled message %s\n", argv[5]);
} }
} else if (argc == 5 && !strcasecmp(argv[0], "profile") && !strcasecmp(argv[2], "set")) { } else if (argc == 5 && !strcasecmp(argv[0], "profile") && !strcasecmp(argv[2], "set")) {
/* skinny profile <profile_name> set <name> <value> */ /* skinny profile <profile_name> set <name> <value> */
status = skinny_api_cmd_profile_set(argv[1], argv[3], argv[4], stream); status = skinny_api_cmd_profile_set(argv[1], argv[3], argv[4], stream);
} else { } else {
stream->write_function(stream, "%s", usage_string); stream->write_function(stream, "%s", usage_string);
} }
done: done:
switch_safe_free(mycmd); switch_safe_free(mycmd);
return status; return status;
} }
switch_status_t skinny_api_register(switch_loadable_module_interface_t **module_interface) switch_status_t skinny_api_register(switch_loadable_module_interface_t **module_interface)
{ {
switch_api_interface_t *api_interface; switch_api_interface_t *api_interface;
SWITCH_ADD_API(api_interface, "skinny", "Skinny Controls", skinny_function, "<cmd> <args>"); SWITCH_ADD_API(api_interface, "skinny", "Skinny Controls", skinny_function, "<cmd> <args>");
switch_console_set_complete("add skinny help"); switch_console_set_complete("add skinny help");
switch_console_set_complete("add skinny status profile ::skinny::list_profiles"); switch_console_set_complete("add skinny status profile ::skinny::list_profiles");
switch_console_set_complete("add skinny status profile ::skinny::list_profiles device ::skinny::list_devices"); switch_console_set_complete("add skinny status profile ::skinny::list_profiles device ::skinny::list_devices");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send ResetMessage ::skinny::list_reset_types"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send ResetMessage ::skinny::list_reset_types");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send SetRingerMessage ::skinny::list_ring_types ::skinny::list_ring_modes"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send SetRingerMessage ::skinny::list_ring_types ::skinny::list_ring_modes");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send SetLampMessage ::skinny::list_stimuli ::skinny::list_stimulus_instances ::skinny::list_stimulus_modes"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send SetLampMessage ::skinny::list_stimuli ::skinny::list_stimulus_instances ::skinny::list_stimulus_modes");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send SetSpeakerModeMessage ::skinny::list_speaker_modes"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send SetSpeakerModeMessage ::skinny::list_speaker_modes");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send CallStateMessage ::skinny::list_call_states ::skinny::list_line_instances ::skinny::list_call_ids"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send CallStateMessage ::skinny::list_call_states ::skinny::list_line_instances ::skinny::list_call_ids");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send UserToDeviceDataMessage"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send UserToDeviceDataMessage");
switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send UserToDeviceDataVersion1Message"); switch_console_set_complete("add skinny profile ::skinny::list_profiles device ::skinny::list_devices send UserToDeviceDataVersion1Message");
switch_console_set_complete("add skinny profile ::skinny::list_profiles set ::skinny::list_settings"); switch_console_set_complete("add skinny profile ::skinny::list_profiles set ::skinny::list_settings");
switch_console_add_complete_func("::skinny::list_profiles", skinny_api_list_profiles); switch_console_add_complete_func("::skinny::list_profiles", skinny_api_list_profiles);
switch_console_add_complete_func("::skinny::list_devices", skinny_api_list_devices); switch_console_add_complete_func("::skinny::list_devices", skinny_api_list_devices);
switch_console_add_complete_func("::skinny::list_reset_types", skinny_api_list_reset_types); switch_console_add_complete_func("::skinny::list_reset_types", skinny_api_list_reset_types);
switch_console_add_complete_func("::skinny::list_ring_types", skinny_api_list_ring_types); switch_console_add_complete_func("::skinny::list_ring_types", skinny_api_list_ring_types);
switch_console_add_complete_func("::skinny::list_ring_modes", skinny_api_list_ring_modes); switch_console_add_complete_func("::skinny::list_ring_modes", skinny_api_list_ring_modes);
switch_console_add_complete_func("::skinny::list_stimuli", skinny_api_list_stimuli); switch_console_add_complete_func("::skinny::list_stimuli", skinny_api_list_stimuli);
switch_console_add_complete_func("::skinny::list_stimulus_instances", skinny_api_list_stimulus_instances); switch_console_add_complete_func("::skinny::list_stimulus_instances", skinny_api_list_stimulus_instances);
switch_console_add_complete_func("::skinny::list_stimulus_modes", skinny_api_list_stimulus_modes); switch_console_add_complete_func("::skinny::list_stimulus_modes", skinny_api_list_stimulus_modes);
switch_console_add_complete_func("::skinny::list_speaker_modes", skinny_api_list_speaker_modes); switch_console_add_complete_func("::skinny::list_speaker_modes", skinny_api_list_speaker_modes);
switch_console_add_complete_func("::skinny::list_call_states", skinny_api_list_call_states); switch_console_add_complete_func("::skinny::list_call_states", skinny_api_list_call_states);
switch_console_add_complete_func("::skinny::list_line_instances", skinny_api_list_line_instances); switch_console_add_complete_func("::skinny::list_line_instances", skinny_api_list_line_instances);
switch_console_add_complete_func("::skinny::list_call_ids", skinny_api_list_call_ids); switch_console_add_complete_func("::skinny::list_call_ids", skinny_api_list_call_ids);
switch_console_add_complete_func("::skinny::list_settings", skinny_api_list_settings); switch_console_add_complete_func("::skinny::list_settings", skinny_api_list_settings);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
switch_status_t skinny_api_unregister() switch_status_t skinny_api_unregister()
{ {
switch_console_set_complete("del skinny"); switch_console_set_complete("del skinny");
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
/* For Emacs: /* For Emacs:

398
src/mod/endpoints/mod_skinny/skinny_protocol.c
View File

@ -149,26 +149,26 @@ switch_status_t skinny_read_packet(listener_t *listener, skinny_message_t **req)
if(mlen) { if(mlen) {
bytes += mlen; bytes += mlen;
if(bytes >= SKINNY_MESSAGE_FIELD_SIZE) { if(bytes >= SKINNY_MESSAGE_FIELD_SIZE) {
do_sleep = 0; do_sleep = 0;
ptr += mlen; ptr += mlen;
memcpy(request, mbuf, bytes); memcpy(request, mbuf, bytes);
#ifdef SKINNY_MEGA_DEBUG #ifdef SKINNY_MEGA_DEBUG
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"Got request: length=%d,reserved=%x,type=%x\n", "Got request: length=%d,reserved=%x,type=%x\n",
request->length,request->reserved,request->type); request->length,request->reserved,request->type);
#endif #endif
if(request->length < SKINNY_MESSAGE_FIELD_SIZE) { if(request->length < SKINNY_MESSAGE_FIELD_SIZE) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"Skinny client sent invalid data. Length should be greater than 4 but got %d.\n", "Skinny client sent invalid data. Length should be greater than 4 but got %d.\n",
request->length); request->length);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
if(request->length + 2*SKINNY_MESSAGE_FIELD_SIZE > SKINNY_MESSAGE_MAXSIZE) { if(request->length + 2*SKINNY_MESSAGE_FIELD_SIZE > SKINNY_MESSAGE_MAXSIZE) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"Skinny client sent too huge data. Got %d which is above threshold %d.\n", "Skinny client sent too huge data. Got %d which is above threshold %d.\n",
request->length, SKINNY_MESSAGE_MAXSIZE - 2*SKINNY_MESSAGE_FIELD_SIZE); request->length, SKINNY_MESSAGE_MAXSIZE - 2*SKINNY_MESSAGE_FIELD_SIZE);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
if(bytes >= request->length + 2*SKINNY_MESSAGE_FIELD_SIZE) { if(bytes >= request->length + 2*SKINNY_MESSAGE_FIELD_SIZE) {
@ -224,10 +224,10 @@ switch_status_t skinny_device_event(listener_t *listener, switch_event_t **ev, s
switch_event_create_subclass(&event, event_id, subclass_name); switch_event_create_subclass(&event, event_id, subclass_name);
switch_assert(event); switch_assert(event);
if ((sql = switch_mprintf("SELECT '%s', name, user_id, instance, ip, type, max_streams, port, codec_string " if ((sql = switch_mprintf("SELECT '%s', name, user_id, instance, ip, type, max_streams, port, codec_string "
"FROM skinny_devices " "FROM skinny_devices "
"WHERE name='%s' AND instance=%d", "WHERE name='%s' AND instance=%d",
listener->profile->name, listener->profile->name,
listener->device_name, listener->device_instance))) { listener->device_name, listener->device_instance))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_device_event_callback, event); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_device_event_callback, event);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -243,14 +243,14 @@ switch_status_t skinny_session_walk_lines(skinny_profile_t *profile, char *chann
{ {
char *sql; char *sql;
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT skinny_lines.*, channel_uuid, call_id, call_state " "SELECT skinny_lines.*, channel_uuid, call_id, call_state "
"FROM skinny_active_lines " "FROM skinny_active_lines "
"INNER JOIN skinny_lines " "INNER JOIN skinny_lines "
"ON skinny_active_lines.device_name = skinny_lines.device_name " "ON skinny_active_lines.device_name = skinny_lines.device_name "
"AND skinny_active_lines.device_instance = skinny_lines.device_instance " "AND skinny_active_lines.device_instance = skinny_lines.device_instance "
"AND skinny_active_lines.line_instance = skinny_lines.line_instance " "AND skinny_active_lines.line_instance = skinny_lines.line_instance "
"WHERE channel_uuid='%s'", "WHERE channel_uuid='%s'",
channel_uuid))) { channel_uuid))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, callback, data); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, callback, data);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -261,14 +261,14 @@ switch_status_t skinny_session_walk_lines_by_call_id(skinny_profile_t *profile,
{ {
char *sql; char *sql;
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT skinny_lines.*, channel_uuid, call_id, call_state " "SELECT skinny_lines.*, channel_uuid, call_id, call_state "
"FROM skinny_active_lines " "FROM skinny_active_lines "
"INNER JOIN skinny_lines " "INNER JOIN skinny_lines "
"ON skinny_active_lines.device_name = skinny_lines.device_name " "ON skinny_active_lines.device_name = skinny_lines.device_name "
"AND skinny_active_lines.device_instance = skinny_lines.device_instance " "AND skinny_active_lines.device_instance = skinny_lines.device_instance "
"AND skinny_active_lines.line_instance = skinny_lines.line_instance " "AND skinny_active_lines.line_instance = skinny_lines.line_instance "
"WHERE call_id='%d'", "WHERE call_id='%d'",
call_id))) { call_id))) {
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, callback, data); skinny_execute_sql_callback(profile, profile->sql_mutex, sql, callback, data);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -309,13 +309,13 @@ void skinny_line_get(listener_t *listener, uint32_t instance, struct line_stat_r
helper.button = switch_core_alloc(listener->pool, sizeof(struct line_stat_res_message)); helper.button = switch_core_alloc(listener->pool, sizeof(struct line_stat_res_message));
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT '%d' AS wanted_position, position, label, value, caller_name " "SELECT '%d' AS wanted_position, position, label, value, caller_name "
"FROM skinny_lines " "FROM skinny_lines "
"WHERE device_name='%s' AND device_instance=%d " "WHERE device_name='%s' AND device_instance=%d "
"ORDER BY position", "ORDER BY position",
instance, instance,
listener->device_name, listener->device_instance listener->device_name, listener->device_instance
))) { ))) {
skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_line_get_callback, &helper); skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_line_get_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -352,14 +352,14 @@ void skinny_speed_dial_get(listener_t *listener, uint32_t instance, struct speed
helper.button = switch_core_alloc(listener->pool, sizeof(struct speed_dial_stat_res_message)); helper.button = switch_core_alloc(listener->pool, sizeof(struct speed_dial_stat_res_message));
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT '%d' AS wanted_position, position, label, value, settings " "SELECT '%d' AS wanted_position, position, label, value, settings "
"FROM skinny_buttons " "FROM skinny_buttons "
"WHERE device_name='%s' AND device_instance=%d AND type=%d " "WHERE device_name='%s' AND device_instance=%d AND type=%d "
"ORDER BY position", "ORDER BY position",
instance, instance,
listener->device_name, listener->device_instance, listener->device_name, listener->device_instance,
SKINNY_BUTTON_SPEED_DIAL SKINNY_BUTTON_SPEED_DIAL
))) { ))) {
skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_speed_dial_get_callback, &helper); skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_speed_dial_get_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -396,15 +396,15 @@ void skinny_service_url_get(listener_t *listener, uint32_t instance, struct serv
helper.button = switch_core_alloc(listener->pool, sizeof(struct service_url_stat_res_message)); helper.button = switch_core_alloc(listener->pool, sizeof(struct service_url_stat_res_message));
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT '%d' AS wanted_position, position, label, value, settings " "SELECT '%d' AS wanted_position, position, label, value, settings "
"FROM skinny_buttons " "FROM skinny_buttons "
"WHERE device_name='%s' AND device_instance=%d AND type=%d " "WHERE device_name='%s' AND device_instance=%d AND type=%d "
"ORDER BY position", "ORDER BY position",
instance, instance,
listener->device_name, listener->device_name,
listener->device_instance, listener->device_instance,
SKINNY_BUTTON_SERVICE_URL SKINNY_BUTTON_SERVICE_URL
))) { ))) {
skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_service_url_get_callback, &helper); skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_service_url_get_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -442,15 +442,15 @@ void skinny_feature_get(listener_t *listener, uint32_t instance, struct feature_
helper.button = switch_core_alloc(listener->pool, sizeof(struct feature_stat_res_message)); helper.button = switch_core_alloc(listener->pool, sizeof(struct feature_stat_res_message));
if ((sql = switch_mprintf( if ((sql = switch_mprintf(
"SELECT '%d' AS wanted_position, position, label, value, settings " "SELECT '%d' AS wanted_position, position, label, value, settings "
"FROM skinny_buttons " "FROM skinny_buttons "
"WHERE device_name='%s' AND device_instance=%d AND NOT (type=%d OR type=%d) " "WHERE device_name='%s' AND device_instance=%d AND NOT (type=%d OR type=%d) "
"ORDER BY position", "ORDER BY position",
instance, instance,
listener->device_name, listener->device_name,
listener->device_instance, listener->device_instance,
SKINNY_BUTTON_SPEED_DIAL, SKINNY_BUTTON_SERVICE_URL SKINNY_BUTTON_SPEED_DIAL, SKINNY_BUTTON_SERVICE_URL
))) { ))) {
skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_feature_get_callback, &helper); skinny_execute_sql_callback(listener->profile, listener->profile->sql_mutex, sql, skinny_feature_get_callback, &helper);
switch_safe_free(sql); switch_safe_free(sql);
} }
@ -461,11 +461,11 @@ void skinny_feature_get(listener_t *listener, uint32_t instance, struct feature_
/* SKINNY MESSAGE SENDER */ /* SKINNY MESSAGE SENDER */
/*****************************************************************************/ /*****************************************************************************/
switch_status_t send_register_ack(listener_t *listener, switch_status_t send_register_ack(listener_t *listener,
uint32_t keep_alive, uint32_t keep_alive,
char *date_format, char *date_format,
char *reserved, char *reserved,
uint32_t secondary_keep_alive, uint32_t secondary_keep_alive,
char *reserved2) char *reserved2)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reg_ack)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reg_ack));
@ -480,10 +480,10 @@ switch_status_t send_register_ack(listener_t *listener,
} }
switch_status_t send_start_tone(listener_t *listener, switch_status_t send_start_tone(listener_t *listener,
uint32_t tone, uint32_t tone,
uint32_t reserved, uint32_t reserved,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.start_tone)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.start_tone));
@ -497,8 +497,8 @@ switch_status_t send_start_tone(listener_t *listener,
} }
switch_status_t send_stop_tone(listener_t *listener, switch_status_t send_stop_tone(listener_t *listener,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.stop_tone)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.stop_tone));
@ -510,10 +510,10 @@ switch_status_t send_stop_tone(listener_t *listener,
} }
switch_status_t send_set_ringer(listener_t *listener, switch_status_t send_set_ringer(listener_t *listener,
uint32_t ring_type, uint32_t ring_type,
uint32_t ring_mode, uint32_t ring_mode,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.ringer)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.ringer));
@ -527,9 +527,9 @@ switch_status_t send_set_ringer(listener_t *listener,
} }
switch_status_t send_set_lamp(listener_t *listener, switch_status_t send_set_lamp(listener_t *listener,
uint32_t stimulus, uint32_t stimulus,
uint32_t stimulus_instance, uint32_t stimulus_instance,
uint32_t mode) uint32_t mode)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.lamp)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.lamp));
@ -542,7 +542,7 @@ switch_status_t send_set_lamp(listener_t *listener,
} }
switch_status_t send_set_speaker_mode(listener_t *listener, switch_status_t send_set_speaker_mode(listener_t *listener,
uint32_t mode) uint32_t mode)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.speaker_mode)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.speaker_mode));
@ -553,16 +553,16 @@ switch_status_t send_set_speaker_mode(listener_t *listener,
} }
switch_status_t send_start_media_transmission(listener_t *listener, switch_status_t send_start_media_transmission(listener_t *listener,
uint32_t conference_id, uint32_t conference_id,
uint32_t pass_thru_party_id, uint32_t pass_thru_party_id,
uint32_t remote_ip, uint32_t remote_ip,
uint32_t remote_port, uint32_t remote_port,
uint32_t ms_per_packet, uint32_t ms_per_packet,
uint32_t payload_capacity, uint32_t payload_capacity,
uint32_t precedence, uint32_t precedence,
uint32_t silence_suppression, uint32_t silence_suppression,
uint16_t max_frames_per_packet, uint16_t max_frames_per_packet,
uint32_t g723_bitrate) uint32_t g723_bitrate)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.start_media)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.start_media));
@ -583,9 +583,9 @@ switch_status_t send_start_media_transmission(listener_t *listener,
} }
switch_status_t send_stop_media_transmission(listener_t *listener, switch_status_t send_stop_media_transmission(listener_t *listener,
uint32_t conference_id, uint32_t conference_id,
uint32_t pass_thru_party_id, uint32_t pass_thru_party_id,
uint32_t conference_id2) uint32_t conference_id2)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.stop_media)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.stop_media));
@ -599,26 +599,26 @@ switch_status_t send_stop_media_transmission(listener_t *listener,
} }
switch_status_t skinny_send_call_info(listener_t *listener, switch_status_t skinny_send_call_info(listener_t *listener,
const char *calling_party_name, const char *calling_party_name,
const char *calling_party, const char *calling_party,
const char *called_party_name, const char *called_party_name,
const char *called_party, const char *called_party,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id, uint32_t call_id,
uint32_t call_type, uint32_t call_type,
const char *original_called_party_name, const char *original_called_party_name,
const char *original_called_party, const char *original_called_party,
const char *last_redirecting_party_name, const char *last_redirecting_party_name,
const char *last_redirecting_party, const char *last_redirecting_party,
uint32_t original_called_party_redirect_reason, uint32_t original_called_party_redirect_reason,
uint32_t last_redirecting_reason, uint32_t last_redirecting_reason,
const char *calling_party_voice_mailbox, const char *calling_party_voice_mailbox,
const char *called_party_voice_mailbox, const char *called_party_voice_mailbox,
const char *original_called_party_voice_mailbox, const char *original_called_party_voice_mailbox,
const char *last_redirecting_voice_mailbox, const char *last_redirecting_voice_mailbox,
uint32_t call_instance, uint32_t call_instance,
uint32_t call_security_status, uint32_t call_security_status,
uint32_t party_pi_restriction_bits) uint32_t party_pi_restriction_bits)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.call_info)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.call_info));
@ -648,15 +648,15 @@ switch_status_t skinny_send_call_info(listener_t *listener,
} }
switch_status_t send_define_time_date(listener_t *listener, switch_status_t send_define_time_date(listener_t *listener,
uint32_t year, uint32_t year,
uint32_t month, uint32_t month,
uint32_t day_of_week, /* monday = 1 */ uint32_t day_of_week, /* monday = 1 */
uint32_t day, uint32_t day,
uint32_t hour, uint32_t hour,
uint32_t minute, uint32_t minute,
uint32_t seconds, uint32_t seconds,
uint32_t milliseconds, uint32_t milliseconds,
uint32_t timestamp) uint32_t timestamp)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.define_time_date)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.define_time_date));
@ -681,15 +681,15 @@ switch_status_t send_define_current_time_date(listener_t *listener)
ts = switch_micro_time_now(); ts = switch_micro_time_now();
switch_time_exp_lt(&tm, ts); switch_time_exp_lt(&tm, ts);
return send_define_time_date(listener, return send_define_time_date(listener,
tm.tm_year + 1900, tm.tm_year + 1900,
tm.tm_mon + 1, tm.tm_mon + 1,
tm.tm_wday, tm.tm_wday,
tm.tm_mday, tm.tm_mday,
tm.tm_hour, tm.tm_hour,
tm.tm_min, tm.tm_min,
tm.tm_sec, tm.tm_sec,
tm.tm_usec / 1000, tm.tm_usec / 1000,
ts / 1000000); ts / 1000000);
} }
switch_status_t send_capabilities_req(listener_t *listener) switch_status_t send_capabilities_req(listener_t *listener)
@ -702,7 +702,7 @@ switch_status_t send_capabilities_req(listener_t *listener)
} }
switch_status_t send_version(listener_t *listener, switch_status_t send_version(listener_t *listener,
char *version) char *version)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.version)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.version));
@ -713,7 +713,7 @@ switch_status_t send_version(listener_t *listener,
} }
switch_status_t send_register_reject(listener_t *listener, switch_status_t send_register_reject(listener_t *listener,
char *error) char *error)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reg_rej)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reg_rej));
@ -724,14 +724,14 @@ switch_status_t send_register_reject(listener_t *listener,
} }
switch_status_t send_open_receive_channel(listener_t *listener, switch_status_t send_open_receive_channel(listener_t *listener,
uint32_t conference_id, uint32_t conference_id,
uint32_t pass_thru_party_id, uint32_t pass_thru_party_id,
uint32_t packets, uint32_t packets,
uint32_t payload_capacity, uint32_t payload_capacity,
uint32_t echo_cancel_type, uint32_t echo_cancel_type,
uint32_t g723_bitrate, uint32_t g723_bitrate,
uint32_t conference_id2, uint32_t conference_id2,
uint32_t reserved[10]) uint32_t reserved[10])
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.open_receive_channel)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.open_receive_channel));
@ -745,24 +745,24 @@ switch_status_t send_open_receive_channel(listener_t *listener,
message->data.open_receive_channel.g723_bitrate = g723_bitrate; message->data.open_receive_channel.g723_bitrate = g723_bitrate;
message->data.open_receive_channel.conference_id2 = conference_id2; message->data.open_receive_channel.conference_id2 = conference_id2;
/* /*
message->data.open_receive_channel.reserved[0] = reserved[0]; message->data.open_receive_channel.reserved[0] = reserved[0];
message->data.open_receive_channel.reserved[1] = reserved[1]; message->data.open_receive_channel.reserved[1] = reserved[1];
message->data.open_receive_channel.reserved[2] = reserved[2]; message->data.open_receive_channel.reserved[2] = reserved[2];
message->data.open_receive_channel.reserved[3] = reserved[3]; message->data.open_receive_channel.reserved[3] = reserved[3];
message->data.open_receive_channel.reserved[4] = reserved[4]; message->data.open_receive_channel.reserved[4] = reserved[4];
message->data.open_receive_channel.reserved[5] = reserved[5]; message->data.open_receive_channel.reserved[5] = reserved[5];
message->data.open_receive_channel.reserved[6] = reserved[6]; message->data.open_receive_channel.reserved[6] = reserved[6];
message->data.open_receive_channel.reserved[7] = reserved[7]; message->data.open_receive_channel.reserved[7] = reserved[7];
message->data.open_receive_channel.reserved[8] = reserved[8]; message->data.open_receive_channel.reserved[8] = reserved[8];
message->data.open_receive_channel.reserved[9] = reserved[9]; message->data.open_receive_channel.reserved[9] = reserved[9];
*/ */
return skinny_send_reply(listener, message); return skinny_send_reply(listener, message);
} }
switch_status_t send_close_receive_channel(listener_t *listener, switch_status_t send_close_receive_channel(listener_t *listener,
uint32_t conference_id, uint32_t conference_id,
uint32_t pass_thru_party_id, uint32_t pass_thru_party_id,
uint32_t conference_id2) uint32_t conference_id2)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.close_receive_channel)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.close_receive_channel));
@ -775,10 +775,10 @@ switch_status_t send_close_receive_channel(listener_t *listener,
} }
switch_status_t send_select_soft_keys(listener_t *listener, switch_status_t send_select_soft_keys(listener_t *listener,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id, uint32_t call_id,
uint32_t soft_key_set, uint32_t soft_key_set,
uint32_t valid_key_mask) uint32_t valid_key_mask)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.select_soft_keys)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.select_soft_keys));
@ -792,9 +792,9 @@ switch_status_t send_select_soft_keys(listener_t *listener,
} }
switch_status_t send_call_state(listener_t *listener, switch_status_t send_call_state(listener_t *listener,
uint32_t call_state, uint32_t call_state,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.call_state)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.call_state));
@ -807,10 +807,10 @@ switch_status_t send_call_state(listener_t *listener,
} }
switch_status_t send_display_prompt_status(listener_t *listener, switch_status_t send_display_prompt_status(listener_t *listener,
uint32_t timeout, uint32_t timeout,
const char *display, const char *display,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_prompt_status)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_prompt_status));
@ -824,8 +824,8 @@ switch_status_t send_display_prompt_status(listener_t *listener,
} }
switch_status_t send_clear_prompt_status(listener_t *listener, switch_status_t send_clear_prompt_status(listener_t *listener,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.clear_prompt_status)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.clear_prompt_status));
@ -837,7 +837,7 @@ switch_status_t send_clear_prompt_status(listener_t *listener,
} }
switch_status_t send_activate_call_plane(listener_t *listener, switch_status_t send_activate_call_plane(listener_t *listener,
uint32_t line_instance) uint32_t line_instance)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.activate_call_plane)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.activate_call_plane));
@ -848,8 +848,8 @@ switch_status_t send_activate_call_plane(listener_t *listener,
} }
switch_status_t send_back_space_request(listener_t *listener, switch_status_t send_back_space_request(listener_t *listener,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.back_space_req)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.back_space_req));
@ -862,9 +862,9 @@ switch_status_t send_back_space_request(listener_t *listener,
} }
switch_status_t send_dialed_number(listener_t *listener, switch_status_t send_dialed_number(listener_t *listener,
char called_party[24], char called_party[24],
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id) uint32_t call_id)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.dialed_number)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.dialed_number));
@ -877,9 +877,9 @@ switch_status_t send_dialed_number(listener_t *listener,
} }
switch_status_t send_display_pri_notify(listener_t *listener, switch_status_t send_display_pri_notify(listener_t *listener,
uint32_t message_timeout, uint32_t message_timeout,
uint32_t priority, uint32_t priority,
char *notify) char *notify)
{ {
skinny_message_t *message; skinny_message_t *message;
message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_pri_notify)); message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_pri_notify));
@ -903,12 +903,12 @@ switch_status_t send_reset(listener_t *listener, uint32_t reset_type)
} }
switch_status_t send_data(listener_t *listener, uint32_t message_type, switch_status_t send_data(listener_t *listener, uint32_t message_type,
uint32_t application_id, uint32_t application_id,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id, uint32_t call_id,
uint32_t transaction_id, uint32_t transaction_id,
uint32_t data_length, uint32_t data_length,
const char *data) const char *data)
{ {
skinny_message_t *message; skinny_message_t *message;
switch_assert(data_length == strlen(data)); switch_assert(data_length == strlen(data));
@ -929,17 +929,17 @@ switch_status_t send_data(listener_t *listener, uint32_t message_type,
} }
switch_status_t send_extended_data(listener_t *listener, uint32_t message_type, switch_status_t send_extended_data(listener_t *listener, uint32_t message_type,
uint32_t application_id, uint32_t application_id,
uint32_t line_instance, uint32_t line_instance,
uint32_t call_id, uint32_t call_id,
uint32_t transaction_id, uint32_t transaction_id,
uint32_t data_length, uint32_t data_length,
uint32_t sequence_flag, uint32_t sequence_flag,
uint32_t display_priority, uint32_t display_priority,
uint32_t conference_id, uint32_t conference_id,
uint32_t app_instance_id, uint32_t app_instance_id,
uint32_t routing_id, uint32_t routing_id,
const char *data) const char *data)
{ {
skinny_message_t *message; skinny_message_t *message;
switch_assert(data_length == strlen(data)); switch_assert(data_length == strlen(data));
@ -975,16 +975,16 @@ switch_status_t skinny_perform_send_reply(listener_t *listener, const char *file
if (listener_is_ready(listener)) { if (listener_is_ready(listener)) {
if (listener->profile->debug >= 10 || reply->type != KEEP_ALIVE_ACK_MESSAGE) { if (listener->profile->debug >= 10 || reply->type != KEEP_ALIVE_ACK_MESSAGE) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG,
"Sending %s (type=%x,length=%d) to %s:%d.\n", "Sending %s (type=%x,length=%d) to %s:%d.\n",
skinny_message_type2str(reply->type), reply->type, reply->length, skinny_message_type2str(reply->type), reply->type, reply->length,
listener->device_name, listener->device_instance); listener->device_name, listener->device_instance);
} }
return switch_socket_send(listener->sock, ptr, &len); return switch_socket_send(listener->sock, ptr, &len);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_WARNING,
"Not sending %s (type=%x,length=%d) to %s:%d while not ready.\n", "Not sending %s (type=%x,length=%d) to %s:%d while not ready.\n",
skinny_message_type2str(reply->type), reply->type, reply->length, skinny_message_type2str(reply->type), reply->type, reply->length,
listener->device_name, listener->device_instance); listener->device_name, listener->device_instance);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
} }

700
src/mod/endpoints/mod_skinny/skinny_protocol.h
View File

File diff suppressed because it is too large Load Diff

697
src/mod/endpoints/mod_skinny/skinny_server.c
View File

File diff suppressed because it is too large Load Diff

302
src/mod/endpoints/mod_skinny/skinny_tables.c
View File

@ -108,181 +108,181 @@ struct skinny_table SKINNY_MESSAGE_TYPES[] = {
{XML_ALARM_MESSAGE, "XMLAlarmMessage"}, {XML_ALARM_MESSAGE, "XMLAlarmMessage"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_message_type2str, SKINNY_MESSAGE_TYPES, "UnknownMessage") SKINNY_DECLARE_ID2STR(skinny_message_type2str, SKINNY_MESSAGE_TYPES, "UnknownMessage")
SKINNY_DECLARE_STR2ID(skinny_str2message_type, SKINNY_MESSAGE_TYPES, -1) SKINNY_DECLARE_STR2ID(skinny_str2message_type, SKINNY_MESSAGE_TYPES, -1)
struct skinny_table SKINNY_DEVICE_TYPES[] = { struct skinny_table SKINNY_DEVICE_TYPES[] = {
{1, "Cisco 30 SP+"}, {1, "Cisco 30 SP+"},
{2, "Cisco 12 SP+"}, {2, "Cisco 12 SP+"},
{3, "Cisco 12 SP"}, {3, "Cisco 12 SP"},
{4, "Cisco 12"}, {4, "Cisco 12"},
{5, "Cisco 30 VIP"}, {5, "Cisco 30 VIP"},
{6, "Cisco IP Phone 7910"}, {6, "Cisco IP Phone 7910"},
{7, "Cisco IP Phone 7960"}, {7, "Cisco IP Phone 7960"},
{8, "Cisco IP Phone 7940"}, {8, "Cisco IP Phone 7940"},
{9, "Cisco IP Phone 7935"}, {9, "Cisco IP Phone 7935"},
{12, "Cisco ATA 186"}, {12, "Cisco ATA 186"},
{365, "Cisco IP Phone CP-7921G"}, {365, "Cisco IP Phone CP-7921G"},
{404, "Cisco IP Phone CP-7962G"}, {404, "Cisco IP Phone CP-7962G"},
{436, "Cisco IP Phone CP-7965G"}, {436, "Cisco IP Phone CP-7965G"},
{30018, "Cisco IP Phone CP-7961G"}, {30018, "Cisco IP Phone CP-7961G"},
{30019, "Cisco IP Phone 7936"}, {30019, "Cisco IP Phone 7936"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_device_type2str, SKINNY_DEVICE_TYPES, "UnknownDeviceType") SKINNY_DECLARE_ID2STR(skinny_device_type2str, SKINNY_DEVICE_TYPES, "UnknownDeviceType")
SKINNY_DECLARE_STR2ID(skinny_str2device_type, SKINNY_DEVICE_TYPES, -1) SKINNY_DECLARE_STR2ID(skinny_str2device_type, SKINNY_DEVICE_TYPES, -1)
struct skinny_table SKINNY_RING_TYPES[] = { struct skinny_table SKINNY_RING_TYPES[] = {
{SKINNY_RING_OFF, "RingOff"}, {SKINNY_RING_OFF, "RingOff"},
{SKINNY_RING_INSIDE, "RingInside"}, {SKINNY_RING_INSIDE, "RingInside"},
{SKINNY_RING_OUTSIDE, "RingOutside"}, {SKINNY_RING_OUTSIDE, "RingOutside"},
{SKINNY_RING_FEATURE, "RingFeature"}, {SKINNY_RING_FEATURE, "RingFeature"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_ring_type2str, SKINNY_RING_TYPES, "RingTypeUnknown") SKINNY_DECLARE_ID2STR(skinny_ring_type2str, SKINNY_RING_TYPES, "RingTypeUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2ring_type, SKINNY_RING_TYPES, -1) SKINNY_DECLARE_STR2ID(skinny_str2ring_type, SKINNY_RING_TYPES, -1)
struct skinny_table SKINNY_RING_MODES[] = { struct skinny_table SKINNY_RING_MODES[] = {
{SKINNY_RING_FOREVER, "RingForever"}, {SKINNY_RING_FOREVER, "RingForever"},
{SKINNY_RING_ONCE, "RingOnce"}, {SKINNY_RING_ONCE, "RingOnce"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_ring_mode2str, SKINNY_RING_MODES, "RingModeUnknown") SKINNY_DECLARE_ID2STR(skinny_ring_mode2str, SKINNY_RING_MODES, "RingModeUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2ring_mode, SKINNY_RING_MODES, -1) SKINNY_DECLARE_STR2ID(skinny_str2ring_mode, SKINNY_RING_MODES, -1)
struct skinny_table SKINNY_BUTTONS[] = { struct skinny_table SKINNY_BUTTONS[] = {
{SKINNY_BUTTON_UNKNOWN, "Unknown"}, {SKINNY_BUTTON_UNKNOWN, "Unknown"},
{SKINNY_BUTTON_LAST_NUMBER_REDIAL, "LastNumberRedial"}, {SKINNY_BUTTON_LAST_NUMBER_REDIAL, "LastNumberRedial"},
{SKINNY_BUTTON_SPEED_DIAL, "SpeedDial"}, {SKINNY_BUTTON_SPEED_DIAL, "SpeedDial"},
{SKINNY_BUTTON_HOLD, "Hold"}, {SKINNY_BUTTON_HOLD, "Hold"},
{SKINNY_BUTTON_TRANSFER, "Transfer"}, {SKINNY_BUTTON_TRANSFER, "Transfer"},
{SKINNY_BUTTON_LINE, "Line"}, {SKINNY_BUTTON_LINE, "Line"},
{SKINNY_BUTTON_VOICEMAIL, "Voicemail"}, {SKINNY_BUTTON_VOICEMAIL, "Voicemail"},
{SKINNY_BUTTON_PRIVACY, "Privacy"}, {SKINNY_BUTTON_PRIVACY, "Privacy"},
{SKINNY_BUTTON_SERVICE_URL, "ServiceUrl"}, {SKINNY_BUTTON_SERVICE_URL, "ServiceUrl"},
{SKINNY_BUTTON_UNDEFINED, "Undefined"}, {SKINNY_BUTTON_UNDEFINED, "Undefined"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_button2str, SKINNY_BUTTONS, "Unknown") SKINNY_DECLARE_ID2STR(skinny_button2str, SKINNY_BUTTONS, "Unknown")
SKINNY_DECLARE_STR2ID(skinny_str2button, SKINNY_BUTTONS, -1) SKINNY_DECLARE_STR2ID(skinny_str2button, SKINNY_BUTTONS, -1)
struct skinny_table SKINNY_SOFT_KEY_EVENTS[] = { struct skinny_table SKINNY_SOFT_KEY_EVENTS[] = {
{SOFTKEY_REDIAL, "SoftkeyRedial"}, {SOFTKEY_REDIAL, "SoftkeyRedial"},
{SOFTKEY_NEWCALL, "SoftkeyNewcall"}, {SOFTKEY_NEWCALL, "SoftkeyNewcall"},
{SOFTKEY_HOLD, "SoftkeyHold"}, {SOFTKEY_HOLD, "SoftkeyHold"},
{SOFTKEY_TRANSFER, "SoftkeyTransfer"}, {SOFTKEY_TRANSFER, "SoftkeyTransfer"},
{SOFTKEY_CFWDALL, "SoftkeyCfwdall"}, {SOFTKEY_CFWDALL, "SoftkeyCfwdall"},
{SOFTKEY_CFWDBUSY, "SoftkeyCfwdbusy"}, {SOFTKEY_CFWDBUSY, "SoftkeyCfwdbusy"},
{SOFTKEY_CFWDNOANSWER, "SoftkeyCfwdnoanswer"}, {SOFTKEY_CFWDNOANSWER, "SoftkeyCfwdnoanswer"},
{SOFTKEY_BACKSPACE, "SoftkeyBackspace"}, {SOFTKEY_BACKSPACE, "SoftkeyBackspace"},
{SOFTKEY_ENDCALL, "SoftkeyEndcall"}, {SOFTKEY_ENDCALL, "SoftkeyEndcall"},
{SOFTKEY_RESUME, "SoftkeyResume"}, {SOFTKEY_RESUME, "SoftkeyResume"},
{SOFTKEY_ANSWER , "SoftkeyAnswer"}, {SOFTKEY_ANSWER , "SoftkeyAnswer"},
{SOFTKEY_INFO, "SoftkeyInfo"}, {SOFTKEY_INFO, "SoftkeyInfo"},
{SOFTKEY_CONFRM, "SoftkeyConfrm"}, {SOFTKEY_CONFRM, "SoftkeyConfrm"},
{SOFTKEY_PARK, "SoftkeyPark"}, {SOFTKEY_PARK, "SoftkeyPark"},
{SOFTKEY_JOIN, "SoftkeyJoin"}, {SOFTKEY_JOIN, "SoftkeyJoin"},
{SOFTKEY_MEETMECONFRM, "SoftkeyMeetmeconfrm"}, {SOFTKEY_MEETMECONFRM, "SoftkeyMeetmeconfrm"},
{SOFTKEY_CALLPICKUP, "SoftkeyCallpickup"}, {SOFTKEY_CALLPICKUP, "SoftkeyCallpickup"},
{SOFTKEY_GRPCALLPICKUP, "SoftkeyGrpcallpickup"}, {SOFTKEY_GRPCALLPICKUP, "SoftkeyGrpcallpickup"},
{SOFTKEY_DND, "SoftkeyDnd"}, {SOFTKEY_DND, "SoftkeyDnd"},
{SOFTKEY_IDIVERT, "SoftkeyIdivert"}, {SOFTKEY_IDIVERT, "SoftkeyIdivert"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_soft_key_event2str, SKINNY_SOFT_KEY_EVENTS, "SoftkeyUnknown") SKINNY_DECLARE_ID2STR(skinny_soft_key_event2str, SKINNY_SOFT_KEY_EVENTS, "SoftkeyUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2soft_key_event, SKINNY_SOFT_KEY_EVENTS, 0) SKINNY_DECLARE_STR2ID(skinny_str2soft_key_event, SKINNY_SOFT_KEY_EVENTS, 0)
struct skinny_table SKINNY_LAMP_MODES[] = { struct skinny_table SKINNY_LAMP_MODES[] = {
{SKINNY_LAMP_OFF, "Off"}, {SKINNY_LAMP_OFF, "Off"},
{SKINNY_LAMP_ON, "On"}, {SKINNY_LAMP_ON, "On"},
{SKINNY_LAMP_WINK, "Wink"}, {SKINNY_LAMP_WINK, "Wink"},
{SKINNY_LAMP_FLASH, "Flash"}, {SKINNY_LAMP_FLASH, "Flash"},
{SKINNY_LAMP_BLINK, "Blink"}, {SKINNY_LAMP_BLINK, "Blink"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_lamp_mode2str, SKINNY_LAMP_MODES, "Unknown") SKINNY_DECLARE_ID2STR(skinny_lamp_mode2str, SKINNY_LAMP_MODES, "Unknown")
SKINNY_DECLARE_STR2ID(skinny_str2lamp_mode, SKINNY_LAMP_MODES, -1) SKINNY_DECLARE_STR2ID(skinny_str2lamp_mode, SKINNY_LAMP_MODES, -1)
struct skinny_table SKINNY_SPEAKER_MODES[] = { struct skinny_table SKINNY_SPEAKER_MODES[] = {
{SKINNY_SPEAKER_ON, "SpeakerOn"}, {SKINNY_SPEAKER_ON, "SpeakerOn"},
{SKINNY_SPEAKER_OFF, "SpeakerOff"}, {SKINNY_SPEAKER_OFF, "SpeakerOff"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_speaker_mode2str, SKINNY_SPEAKER_MODES, "Unknown") SKINNY_DECLARE_ID2STR(skinny_speaker_mode2str, SKINNY_SPEAKER_MODES, "Unknown")
SKINNY_DECLARE_STR2ID(skinny_str2speaker_mode, SKINNY_SPEAKER_MODES, -1) SKINNY_DECLARE_STR2ID(skinny_str2speaker_mode, SKINNY_SPEAKER_MODES, -1)
struct skinny_table SKINNY_KEY_SETS[] = { struct skinny_table SKINNY_KEY_SETS[] = {
{SKINNY_KEY_SET_ON_HOOK, "KeySetOnHook"}, {SKINNY_KEY_SET_ON_HOOK, "KeySetOnHook"},
{SKINNY_KEY_SET_CONNECTED, "KeySetConnected"}, {SKINNY_KEY_SET_CONNECTED, "KeySetConnected"},
{SKINNY_KEY_SET_ON_HOLD, "KeySetOnHold"}, {SKINNY_KEY_SET_ON_HOLD, "KeySetOnHold"},
{SKINNY_KEY_SET_RING_IN, "KeySetRingIn"}, {SKINNY_KEY_SET_RING_IN, "KeySetRingIn"},
{SKINNY_KEY_SET_OFF_HOOK, "KeySetOffHook"}, {SKINNY_KEY_SET_OFF_HOOK, "KeySetOffHook"},
{SKINNY_KEY_SET_CONNECTED_WITH_TRANSFER, "KeySetConnectedWithTransfer"}, {SKINNY_KEY_SET_CONNECTED_WITH_TRANSFER, "KeySetConnectedWithTransfer"},
{SKINNY_KEY_SET_DIGITS_AFTER_DIALING_FIRST_DIGIT, "KeySetDigitsAfterDialingFirstDigit"}, {SKINNY_KEY_SET_DIGITS_AFTER_DIALING_FIRST_DIGIT, "KeySetDigitsAfterDialingFirstDigit"},
{SKINNY_KEY_SET_CONNECTED_WITH_CONFERENCE, "KeySetConnectedWithConference"}, {SKINNY_KEY_SET_CONNECTED_WITH_CONFERENCE, "KeySetConnectedWithConference"},
{SKINNY_KEY_SET_RING_OUT, "KeySetRingOut"}, {SKINNY_KEY_SET_RING_OUT, "KeySetRingOut"},
{SKINNY_KEY_SET_OFF_HOOK_WITH_FEATURES, "KeySetOffHookWithFeatures"}, {SKINNY_KEY_SET_OFF_HOOK_WITH_FEATURES, "KeySetOffHookWithFeatures"},
{SKINNY_KEY_SET_IN_USE_HINT, "KeySetInUseHint"}, {SKINNY_KEY_SET_IN_USE_HINT, "KeySetInUseHint"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_soft_key_set2str, SKINNY_KEY_SETS, "UNKNOWN_SOFT_KEY_SET") SKINNY_DECLARE_ID2STR(skinny_soft_key_set2str, SKINNY_KEY_SETS, "UNKNOWN_SOFT_KEY_SET")
SKINNY_DECLARE_STR2ID(skinny_str2soft_key_set, SKINNY_KEY_SETS, -1) SKINNY_DECLARE_STR2ID(skinny_str2soft_key_set, SKINNY_KEY_SETS, -1)
struct skinny_table SKINNY_CALL_STATES[] = { struct skinny_table SKINNY_CALL_STATES[] = {
{SKINNY_OFF_HOOK, "OffHook"}, {SKINNY_OFF_HOOK, "OffHook"},
{SKINNY_ON_HOOK, "OnHook"}, {SKINNY_ON_HOOK, "OnHook"},
{SKINNY_RING_OUT, "RingOut"}, {SKINNY_RING_OUT, "RingOut"},
{SKINNY_RING_IN, "RingIn"}, {SKINNY_RING_IN, "RingIn"},
{SKINNY_CONNECTED, "Connected"}, {SKINNY_CONNECTED, "Connected"},
{SKINNY_BUSY, "Busy"}, {SKINNY_BUSY, "Busy"},
{SKINNY_LINE_IN_USE, "LineInUse"}, {SKINNY_LINE_IN_USE, "LineInUse"},
{SKINNY_HOLD, "Hold"}, {SKINNY_HOLD, "Hold"},
{SKINNY_CALL_WAITING, "CallWaiting"}, {SKINNY_CALL_WAITING, "CallWaiting"},
{SKINNY_CALL_TRANSFER, "CallTransfer"}, {SKINNY_CALL_TRANSFER, "CallTransfer"},
{SKINNY_CALL_PARK, "CallPark"}, {SKINNY_CALL_PARK, "CallPark"},
{SKINNY_PROCEED, "Proceed"}, {SKINNY_PROCEED, "Proceed"},
{SKINNY_IN_USE_REMOTELY, "InUseRemotely"}, {SKINNY_IN_USE_REMOTELY, "InUseRemotely"},
{SKINNY_INVALID_NUMBER, "InvalidNumber"}, {SKINNY_INVALID_NUMBER, "InvalidNumber"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_call_state2str, SKINNY_CALL_STATES, "CallStateUnknown") SKINNY_DECLARE_ID2STR(skinny_call_state2str, SKINNY_CALL_STATES, "CallStateUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2call_state, SKINNY_CALL_STATES, -1) SKINNY_DECLARE_STR2ID(skinny_str2call_state, SKINNY_CALL_STATES, -1)
struct skinny_table SKINNY_DEVICE_RESET_TYPES[] = { struct skinny_table SKINNY_DEVICE_RESET_TYPES[] = {
{SKINNY_DEVICE_RESET, "DeviceReset"}, {SKINNY_DEVICE_RESET, "DeviceReset"},
{SKINNY_DEVICE_RESTART, "DeviceRestart"}, {SKINNY_DEVICE_RESTART, "DeviceRestart"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_device_reset_type2str, SKINNY_DEVICE_RESET_TYPES, "DeviceResetTypeUnknown") SKINNY_DECLARE_ID2STR(skinny_device_reset_type2str, SKINNY_DEVICE_RESET_TYPES, "DeviceResetTypeUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2device_reset_type, SKINNY_DEVICE_RESET_TYPES, -1) SKINNY_DECLARE_STR2ID(skinny_str2device_reset_type, SKINNY_DEVICE_RESET_TYPES, -1)
struct skinny_table SKINNY_ACCESSORY_TYPES[] = { struct skinny_table SKINNY_ACCESSORY_TYPES[] = {
{SKINNY_ACCESSORY_NONE, "AccessoryNone"}, {SKINNY_ACCESSORY_NONE, "AccessoryNone"},
{SKINNY_ACCESSORY_HEADSET, "Headset"}, {SKINNY_ACCESSORY_HEADSET, "Headset"},
{SKINNY_ACCESSORY_HANDSET, "Handset"}, {SKINNY_ACCESSORY_HANDSET, "Handset"},
{SKINNY_ACCESSORY_SPEAKER, "Speaker"}, {SKINNY_ACCESSORY_SPEAKER, "Speaker"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_accessory_type2str, SKINNY_ACCESSORY_TYPES, "AccessoryUnknown") SKINNY_DECLARE_ID2STR(skinny_accessory_type2str, SKINNY_ACCESSORY_TYPES, "AccessoryUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2accessory_type, SKINNY_ACCESSORY_TYPES, -1) SKINNY_DECLARE_STR2ID(skinny_str2accessory_type, SKINNY_ACCESSORY_TYPES, -1)
struct skinny_table SKINNY_ACCESSORY_STATES[] = { struct skinny_table SKINNY_ACCESSORY_STATES[] = {
{SKINNY_ACCESSORY_STATE_NONE, "AccessoryNoState"}, {SKINNY_ACCESSORY_STATE_NONE, "AccessoryNoState"},
{SKINNY_ACCESSORY_STATE_OFFHOOK, "OffHook"}, {SKINNY_ACCESSORY_STATE_OFFHOOK, "OffHook"},
{SKINNY_ACCESSORY_STATE_ONHOOK, "OnHook"}, {SKINNY_ACCESSORY_STATE_ONHOOK, "OnHook"},
{0, NULL} {0, NULL}
}; };
SKINNY_DECLARE_ID2STR(skinny_accessory_state2str, SKINNY_ACCESSORY_STATES, "AccessoryStateUnknown") SKINNY_DECLARE_ID2STR(skinny_accessory_state2str, SKINNY_ACCESSORY_STATES, "AccessoryStateUnknown")
SKINNY_DECLARE_STR2ID(skinny_str2accessory_state, SKINNY_ACCESSORY_STATES, -1) SKINNY_DECLARE_STR2ID(skinny_str2accessory_state, SKINNY_ACCESSORY_STATES, -1)
/* For Emacs: /* For Emacs:
* Local Variables: * Local Variables:
* mode:c * mode:c
* indent-tabs-mode:t * indent-tabs-mode:t
* tab-width:4 * tab-width:4
* c-basic-offset:4 * c-basic-offset:4
* End: * End:
* For VIM: * For VIM:
* vim:set softtabstop=4 shiftwidth=4 tabstop=4: * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
*/ */

236
src/mod/endpoints/mod_skinny/skinny_tables.h
View File

@ -36,55 +36,55 @@
/* SKINNY TABLES */ /* SKINNY TABLES */
/*****************************************************************************/ /*****************************************************************************/
struct skinny_table { struct skinny_table {
uint32_t id; uint32_t id;
const char *name; const char *name;
}; };
#define SKINNY_DECLARE_ID2STR(func, TABLE, DEFAULT_STR) \ #define SKINNY_DECLARE_ID2STR(func, TABLE, DEFAULT_STR) \
const char *func(uint32_t id) \ const char *func(uint32_t id) \
{ \ { \
const char *str = DEFAULT_STR; \ const char *str = DEFAULT_STR; \
uint8_t x; \ uint8_t x; \
\ \
for (x = 0; x < (sizeof(TABLE) / sizeof(struct skinny_table)) - 1; x++) {\ for (x = 0; x < (sizeof(TABLE) / sizeof(struct skinny_table)) - 1; x++) {\
if (TABLE[x].id == id) {\ if (TABLE[x].id == id) {\
str = TABLE[x].name;\ str = TABLE[x].name;\
break;\ break;\
}\ }\
}\ }\
\ \
return str;\ return str;\
} }
#define SKINNY_DECLARE_STR2ID(func, TABLE, DEFAULT_ID) \ #define SKINNY_DECLARE_STR2ID(func, TABLE, DEFAULT_ID) \
uint32_t func(const char *str)\ uint32_t func(const char *str)\
{\ {\
uint32_t id = (uint32_t) DEFAULT_ID;\ uint32_t id = (uint32_t) DEFAULT_ID;\
\ \
if (*str > 47 && *str < 58) {\ if (*str > 47 && *str < 58) {\
id = atoi(str);\ id = atoi(str);\
} else {\ } else {\
uint8_t x;\ uint8_t x;\
for (x = 0; x < (sizeof(TABLE) / sizeof(struct skinny_table)) - 1 && TABLE[x].name; x++) {\ for (x = 0; x < (sizeof(TABLE) / sizeof(struct skinny_table)) - 1 && TABLE[x].name; x++) {\
if (!strcasecmp(TABLE[x].name, str)) {\ if (!strcasecmp(TABLE[x].name, str)) {\
id = TABLE[x].id;\ id = TABLE[x].id;\
break;\ break;\
}\ }\
}\ }\
}\ }\
return id;\ return id;\
} }
#define SKINNY_DECLARE_PUSH_MATCH(TABLE) \ #define SKINNY_DECLARE_PUSH_MATCH(TABLE) \
switch_console_callback_match_t *my_matches = NULL;\ switch_console_callback_match_t *my_matches = NULL;\
uint8_t x;\ uint8_t x;\
for (x = 0; x < (sizeof(TABLE) / sizeof(struct skinny_table)) - 1; x++) {\ for (x = 0; x < (sizeof(TABLE) / sizeof(struct skinny_table)) - 1; x++) {\
switch_console_push_match(&my_matches, TABLE[x].name);\ switch_console_push_match(&my_matches, TABLE[x].name);\
}\ }\
if (my_matches) {\ if (my_matches) {\
*matches = my_matches;\ *matches = my_matches;\
status = SWITCH_STATUS_SUCCESS;\ status = SWITCH_STATUS_SUCCESS;\
} }
extern struct skinny_table SKINNY_MESSAGE_TYPES[72]; extern struct skinny_table SKINNY_MESSAGE_TYPES[72];
@ -98,20 +98,20 @@ uint32_t skinny_str2device_type(const char *str);
#define SKINNY_PUSH_DEVICE_TYPES SKINNY_DECLARE_PUSH_MATCH(SKINNY_DEVICE_TYPES) #define SKINNY_PUSH_DEVICE_TYPES SKINNY_DECLARE_PUSH_MATCH(SKINNY_DEVICE_TYPES)
enum skinny_tone { enum skinny_tone {
SKINNY_TONE_SILENCE = 0x00, SKINNY_TONE_SILENCE = 0x00,
SKINNY_TONE_DIALTONE = 0x21, SKINNY_TONE_DIALTONE = 0x21,
SKINNY_TONE_BUSYTONE = 0x23, SKINNY_TONE_BUSYTONE = 0x23,
SKINNY_TONE_ALERT = 0x24, SKINNY_TONE_ALERT = 0x24,
SKINNY_TONE_REORDER = 0x25, SKINNY_TONE_REORDER = 0x25,
SKINNY_TONE_CALLWAITTONE = 0x2D, SKINNY_TONE_CALLWAITTONE = 0x2D,
SKINNY_TONE_NOTONE = 0x7F, SKINNY_TONE_NOTONE = 0x7F,
}; };
enum skinny_ring_type { enum skinny_ring_type {
SKINNY_RING_OFF = 1, SKINNY_RING_OFF = 1,
SKINNY_RING_INSIDE = 2, SKINNY_RING_INSIDE = 2,
SKINNY_RING_OUTSIDE = 3, SKINNY_RING_OUTSIDE = 3,
SKINNY_RING_FEATURE = 4 SKINNY_RING_FEATURE = 4
}; };
extern struct skinny_table SKINNY_RING_TYPES[5]; extern struct skinny_table SKINNY_RING_TYPES[5];
const char *skinny_ring_type2str(uint32_t id); const char *skinny_ring_type2str(uint32_t id);
@ -119,8 +119,8 @@ uint32_t skinny_str2ring_type(const char *str);
#define SKINNY_PUSH_RING_TYPES SKINNY_DECLARE_PUSH_MATCH(SKINNY_RING_TYPES) #define SKINNY_PUSH_RING_TYPES SKINNY_DECLARE_PUSH_MATCH(SKINNY_RING_TYPES)
enum skinny_ring_mode { enum skinny_ring_mode {
SKINNY_RING_FOREVER = 1, SKINNY_RING_FOREVER = 1,
SKINNY_RING_ONCE = 2, SKINNY_RING_ONCE = 2,
}; };
extern struct skinny_table SKINNY_RING_MODES[3]; extern struct skinny_table SKINNY_RING_MODES[3];
const char *skinny_ring_mode2str(uint32_t id); const char *skinny_ring_mode2str(uint32_t id);
@ -129,11 +129,11 @@ uint32_t skinny_str2ring_mode(const char *str);
enum skinny_lamp_mode { enum skinny_lamp_mode {
SKINNY_LAMP_OFF = 1, SKINNY_LAMP_OFF = 1,
SKINNY_LAMP_ON = 2, SKINNY_LAMP_ON = 2,
SKINNY_LAMP_WINK = 3, SKINNY_LAMP_WINK = 3,
SKINNY_LAMP_FLASH = 4, SKINNY_LAMP_FLASH = 4,
SKINNY_LAMP_BLINK = 5, SKINNY_LAMP_BLINK = 5,
}; };
extern struct skinny_table SKINNY_LAMP_MODES[6]; extern struct skinny_table SKINNY_LAMP_MODES[6];
const char *skinny_lamp_mode2str(uint32_t id); const char *skinny_lamp_mode2str(uint32_t id);
@ -141,8 +141,8 @@ uint32_t skinny_str2lamp_mode(const char *str);
#define SKINNY_PUSH_LAMP_MODES SKINNY_DECLARE_PUSH_MATCH(SKINNY_LAMP_MODES) #define SKINNY_PUSH_LAMP_MODES SKINNY_DECLARE_PUSH_MATCH(SKINNY_LAMP_MODES)
enum skinny_speaker_mode { enum skinny_speaker_mode {
SKINNY_SPEAKER_ON = 1, SKINNY_SPEAKER_ON = 1,
SKINNY_SPEAKER_OFF = 2, SKINNY_SPEAKER_OFF = 2,
}; };
extern struct skinny_table SKINNY_SPEAKER_MODES[3]; extern struct skinny_table SKINNY_SPEAKER_MODES[3];
const char *skinny_speaker_mode2str(uint32_t id); const char *skinny_speaker_mode2str(uint32_t id);
@ -150,22 +150,22 @@ uint32_t skinny_str2speaker_mode(const char *str);
#define SKINNY_PUSH_SPEAKER_MODES SKINNY_DECLARE_PUSH_MATCH(SKINNY_SPEAKER_MODES) #define SKINNY_PUSH_SPEAKER_MODES SKINNY_DECLARE_PUSH_MATCH(SKINNY_SPEAKER_MODES)
enum skinny_call_type { enum skinny_call_type {
SKINNY_INBOUND_CALL = 1, SKINNY_INBOUND_CALL = 1,
SKINNY_OUTBOUND_CALL = 2, SKINNY_OUTBOUND_CALL = 2,
SKINNY_FORWARD_CALL = 3, SKINNY_FORWARD_CALL = 3,
}; };
enum skinny_button_definition { enum skinny_button_definition {
SKINNY_BUTTON_UNKNOWN = 0x00, SKINNY_BUTTON_UNKNOWN = 0x00,
SKINNY_BUTTON_LAST_NUMBER_REDIAL = 0x01, SKINNY_BUTTON_LAST_NUMBER_REDIAL = 0x01,
SKINNY_BUTTON_SPEED_DIAL = 0x02, SKINNY_BUTTON_SPEED_DIAL = 0x02,
SKINNY_BUTTON_HOLD = 0x03, SKINNY_BUTTON_HOLD = 0x03,
SKINNY_BUTTON_TRANSFER = 0x04, SKINNY_BUTTON_TRANSFER = 0x04,
SKINNY_BUTTON_LINE = 0x09, SKINNY_BUTTON_LINE = 0x09,
SKINNY_BUTTON_VOICEMAIL = 0x0F, SKINNY_BUTTON_VOICEMAIL = 0x0F,
SKINNY_BUTTON_PRIVACY = 0x13, SKINNY_BUTTON_PRIVACY = 0x13,
SKINNY_BUTTON_SERVICE_URL = 0x14, SKINNY_BUTTON_SERVICE_URL = 0x14,
SKINNY_BUTTON_UNDEFINED = 0xFF, SKINNY_BUTTON_UNDEFINED = 0xFF,
}; };
extern struct skinny_table SKINNY_BUTTONS[11]; extern struct skinny_table SKINNY_BUTTONS[11];
const char *skinny_button2str(uint32_t id); const char *skinny_button2str(uint32_t id);
@ -173,26 +173,26 @@ uint32_t skinny_str2button(const char *str);
#define SKINNY_PUSH_STIMULI SKINNY_DECLARE_PUSH_MATCH(SKINNY_BUTTONS) #define SKINNY_PUSH_STIMULI SKINNY_DECLARE_PUSH_MATCH(SKINNY_BUTTONS)
enum skinny_soft_key_event { enum skinny_soft_key_event {
SOFTKEY_REDIAL = 0x01, SOFTKEY_REDIAL = 0x01,
SOFTKEY_NEWCALL = 0x02, SOFTKEY_NEWCALL = 0x02,
SOFTKEY_HOLD = 0x03, SOFTKEY_HOLD = 0x03,
SOFTKEY_TRANSFER = 0x04, SOFTKEY_TRANSFER = 0x04,
SOFTKEY_CFWDALL = 0x05, SOFTKEY_CFWDALL = 0x05,
SOFTKEY_CFWDBUSY = 0x06, SOFTKEY_CFWDBUSY = 0x06,
SOFTKEY_CFWDNOANSWER = 0x07, SOFTKEY_CFWDNOANSWER = 0x07,
SOFTKEY_BACKSPACE = 0x08, SOFTKEY_BACKSPACE = 0x08,
SOFTKEY_ENDCALL = 0x09, SOFTKEY_ENDCALL = 0x09,
SOFTKEY_RESUME = 0x0A, SOFTKEY_RESUME = 0x0A,
SOFTKEY_ANSWER = 0x0B, SOFTKEY_ANSWER = 0x0B,
SOFTKEY_INFO = 0x0C, SOFTKEY_INFO = 0x0C,
SOFTKEY_CONFRM = 0x0D, SOFTKEY_CONFRM = 0x0D,
SOFTKEY_PARK = 0x0E, SOFTKEY_PARK = 0x0E,
SOFTKEY_JOIN = 0x0F, SOFTKEY_JOIN = 0x0F,
SOFTKEY_MEETMECONFRM = 0x10, SOFTKEY_MEETMECONFRM = 0x10,
SOFTKEY_CALLPICKUP = 0x11, SOFTKEY_CALLPICKUP = 0x11,
SOFTKEY_GRPCALLPICKUP = 0x12, SOFTKEY_GRPCALLPICKUP = 0x12,
SOFTKEY_DND = 0x13, SOFTKEY_DND = 0x13,
SOFTKEY_IDIVERT = 0x14, SOFTKEY_IDIVERT = 0x14,
}; };
extern struct skinny_table SKINNY_SOFT_KEY_EVENTS[21]; extern struct skinny_table SKINNY_SOFT_KEY_EVENTS[21];
const char *skinny_soft_key_event2str(uint32_t id); const char *skinny_soft_key_event2str(uint32_t id);
@ -200,17 +200,17 @@ uint32_t skinny_str2soft_key_event(const char *str);
#define SKINNY_PUSH_SOFT_KEY_EVENTS SKINNY_DECLARE_PUSH_MATCH(SOFT_KEY_EVENTS) #define SKINNY_PUSH_SOFT_KEY_EVENTS SKINNY_DECLARE_PUSH_MATCH(SOFT_KEY_EVENTS)
enum skinny_key_set { enum skinny_key_set {
SKINNY_KEY_SET_ON_HOOK = 0, SKINNY_KEY_SET_ON_HOOK = 0,
SKINNY_KEY_SET_CONNECTED = 1, SKINNY_KEY_SET_CONNECTED = 1,
SKINNY_KEY_SET_ON_HOLD = 2, SKINNY_KEY_SET_ON_HOLD = 2,
SKINNY_KEY_SET_RING_IN = 3, SKINNY_KEY_SET_RING_IN = 3,
SKINNY_KEY_SET_OFF_HOOK = 4, SKINNY_KEY_SET_OFF_HOOK = 4,
SKINNY_KEY_SET_CONNECTED_WITH_TRANSFER = 5, SKINNY_KEY_SET_CONNECTED_WITH_TRANSFER = 5,
SKINNY_KEY_SET_DIGITS_AFTER_DIALING_FIRST_DIGIT = 6, SKINNY_KEY_SET_DIGITS_AFTER_DIALING_FIRST_DIGIT = 6,
SKINNY_KEY_SET_CONNECTED_WITH_CONFERENCE = 7, SKINNY_KEY_SET_CONNECTED_WITH_CONFERENCE = 7,
SKINNY_KEY_SET_RING_OUT = 8, SKINNY_KEY_SET_RING_OUT = 8,
SKINNY_KEY_SET_OFF_HOOK_WITH_FEATURES = 9, SKINNY_KEY_SET_OFF_HOOK_WITH_FEATURES = 9,
SKINNY_KEY_SET_IN_USE_HINT = 10, SKINNY_KEY_SET_IN_USE_HINT = 10,
}; };
extern struct skinny_table SKINNY_KEY_SETS[12]; extern struct skinny_table SKINNY_KEY_SETS[12];
const char *skinny_soft_key_set2str(uint32_t id); const char *skinny_soft_key_set2str(uint32_t id);
@ -219,20 +219,20 @@ uint32_t skinny_str2soft_key_set(const char *str);
enum skinny_call_state { enum skinny_call_state {
SKINNY_OFF_HOOK = 1, SKINNY_OFF_HOOK = 1,
SKINNY_ON_HOOK = 2, SKINNY_ON_HOOK = 2,
SKINNY_RING_OUT = 3, SKINNY_RING_OUT = 3,
SKINNY_RING_IN = 4, SKINNY_RING_IN = 4,
SKINNY_CONNECTED = 5, SKINNY_CONNECTED = 5,
SKINNY_BUSY = 6, SKINNY_BUSY = 6,
SKINNY_LINE_IN_USE = 7, SKINNY_LINE_IN_USE = 7,
SKINNY_HOLD = 8, SKINNY_HOLD = 8,
SKINNY_CALL_WAITING = 9, SKINNY_CALL_WAITING = 9,
SKINNY_CALL_TRANSFER = 10, SKINNY_CALL_TRANSFER = 10,
SKINNY_CALL_PARK = 11, SKINNY_CALL_PARK = 11,
SKINNY_PROCEED = 12, SKINNY_PROCEED = 12,
SKINNY_IN_USE_REMOTELY = 13, SKINNY_IN_USE_REMOTELY = 13,
SKINNY_INVALID_NUMBER = 14 SKINNY_INVALID_NUMBER = 14
}; };
extern struct skinny_table SKINNY_CALL_STATES[15]; extern struct skinny_table SKINNY_CALL_STATES[15];
const char *skinny_call_state2str(uint32_t id); const char *skinny_call_state2str(uint32_t id);
@ -240,8 +240,8 @@ uint32_t skinny_str2call_state(const char *str);
#define SKINNY_PUSH_CALL_STATES SKINNY_DECLARE_PUSH_MATCH(SKINNY_CALL_STATES) #define SKINNY_PUSH_CALL_STATES SKINNY_DECLARE_PUSH_MATCH(SKINNY_CALL_STATES)
enum skinny_device_reset_types { enum skinny_device_reset_types {
SKINNY_DEVICE_RESET = 1, SKINNY_DEVICE_RESET = 1,
SKINNY_DEVICE_RESTART = 2 SKINNY_DEVICE_RESTART = 2
}; };
extern struct skinny_table SKINNY_DEVICE_RESET_TYPES[3]; extern struct skinny_table SKINNY_DEVICE_RESET_TYPES[3];
const char *skinny_device_reset_type2str(uint32_t id); const char *skinny_device_reset_type2str(uint32_t id);