<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[Freeswitch-trunk][17319] </title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<div id="header">FreeSWITCH Subversion</div>
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://fisheye.freeswitch.org/changelog/FreeSWITCH?cs=17319">17319</a></dd>
<dt>Author</dt> <dd>math.parent</dd>
<dt>Date</dt> <dd>2010-04-16 08:03:37 -0500 (Fri, 16 Apr 2010)</dd>
</dl>
<h3>Log Message</h3>
<pre>Skinny: Initial implementation of VersionReq
And reordering</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#freeswitchtrunksrcmodendpointsmod_skinnyskinny_protocolc">freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.c</a></li>
<li><a href="#freeswitchtrunksrcmodendpointsmod_skinnyskinny_protocolh">freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.h</a></li>
<li><a href="#freeswitchtrunksrcmodendpointsmod_skinnyskinny_tablesc">freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.c</a></li>
<li><a href="#freeswitchtrunksrcmodendpointsmod_skinnyskinny_tablesh">freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="freeswitchtrunksrcmodendpointsmod_skinnyskinny_protocolc"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.c (17318 => 17319)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.c 2010-04-16 09:59:58 UTC (rev 17318)
+++ freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.c 2010-04-16 13:03:37 UTC (rev 17319)
</span><span class="lines">@@ -1389,6 +1389,15 @@
</span><span class="cx"> return skinny_send_reply(listener, message);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+switch_status_t send_version(listener_t *listener,
+ char *version)
+{
+ skinny_message_t *message;
+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.version));
+ strncpy(message->data.version.version, version, 16);
+ return skinny_send_reply(listener, message);
+}
+
</ins><span class="cx"> switch_status_t send_register_reject(listener_t *listener,
</span><span class="cx"> char *error)
</span><span class="cx"> {
</span><span class="lines">@@ -1579,25 +1588,18 @@
</span><span class="cx"> return skinny_send_reply(listener, message);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/* Message handling */
-switch_status_t skinny_handle_alarm(listener_t *listener, skinny_message_t *request)
</del><ins>+/*****************************************************************************/
+/* SKINNY MESSAGE HANDLERS */
+/*****************************************************************************/
+switch_status_t skinny_handle_keep_alive_message(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- switch_event_t *event = NULL;
</del><ins>+ skinny_message_t *message;
</ins><span class="cx">
</span><del>- skinny_check_data_length(request, sizeof(request->data.alarm));
-
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
- "Received alarm: Severity=%d, DisplayMessage=%s, Param1=%d, Param2=%d.\n",
- request->data.alarm.alarm_severity, request->data.alarm.display_message,
- request->data.alarm.alarm_param1, request->data.alarm.alarm_param2);
- /* skinny::alarm event */
- skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_ALARM);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-Severity", "%d", request->data.alarm.alarm_severity);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-DisplayMessage", "%s", request->data.alarm.display_message);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-Param1", "%d", request->data.alarm.alarm_param1);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-Param2", "%d", request->data.alarm.alarm_param2);
- switch_event_fire(&event);
-
</del><ins>+ message = switch_core_alloc(listener->pool, 12);
+ message->type = KEEP_ALIVE_ACK_MESSAGE;
+ message->length = 4;
+ keepalive_listener(listener, NULL);
+ skinny_send_reply(listener, message);
</ins><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1733,14 +1735,234 @@
</span><span class="cx"> return status;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_headset_status_message(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_port_message(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- skinny_check_data_length(request, sizeof(request->data.headset_status));
</del><ins>+ char *sql;
+ skinny_profile_t *profile;
</ins><span class="cx">
</span><del>- /* Nothing to do */
</del><ins>+ switch_assert(listener->profile);
+ switch_assert(listener->device_name);
+
+ profile = listener->profile;
+
+ skinny_check_data_length(request, sizeof(request->data.as_uint16));
+
+ if ((sql = switch_mprintf(
+ "UPDATE skinny_devices SET port=%d WHERE name='%s' and instance=%d",
+ request->data.port.port,
+ listener->device_name,
+ listener->device_instance
+ ))) {
+ skinny_execute_sql(profile, sql, profile->sql_mutex);
+ switch_safe_free(sql);
+ }
</ins><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+switch_status_t skinny_handle_keypad_button_message(listener_t *listener, skinny_message_t *request)
+{
+ uint32_t line_instance = 0;
+ switch_core_session_t *session;
+
+ skinny_check_data_length(request, sizeof(request->data.keypad_button));
+
+ if(request->data.keypad_button.line_instance) {
+ line_instance = request->data.keypad_button.line_instance;
+ } else {
+ line_instance = 1;
+ }
+
+ session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.keypad_button.call_id);
+
+ if(session) {
+ switch_channel_t *channel = NULL;
+ private_t *tech_pvt = NULL;
+ char digit = '\0';
+
+ channel = switch_core_session_get_channel(session);
+ tech_pvt = switch_core_session_get_private(session);
+
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "SEND DTMF ON CALL %d [%d]\n", tech_pvt->call_id, request->data.keypad_button.button);
+
+ if (request->data.keypad_button.button == 14) {
+ digit = '*';
+ } else if (request->data.keypad_button.button == 15) {
+ digit = '#';
+ } else if (request->data.keypad_button.button >= 0 && request->data.keypad_button.button <= 9) {
+ digit = '0' + request->data.keypad_button.button;
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "UNKNOW DTMF RECEIVED ON CALL %d [%d]\n", tech_pvt->call_id, request->data.keypad_button.button);
+ }
+
+ /* TODO check call_id and line */
+
+ if((skinny_line_get_state(listener, line_instance, tech_pvt->call_id) == SKINNY_OFF_HOOK)) {
+
+ skinny_session_process_dest(session, listener, line_instance, NULL, digit, 0);
+ } else {
+ if(digit != '\0') {
+ switch_dtmf_t dtmf = { 0, switch_core_default_dtmf_duration(0)};
+ dtmf.digit = digit;
+ switch_channel_queue_dtmf(channel, &dtmf);
+ }
+ }
+ }
+
+ if(session) {
+ switch_core_session_rwunlock(session);
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+switch_status_t skinny_handle_stimulus_message(listener_t *listener, skinny_message_t *request)
+{
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ struct speed_dial_stat_res_message *button = NULL;
+ uint32_t line_instance = 0;
+ uint32_t call_id = 0;
+ switch_core_session_t *session = NULL;
+
+ skinny_check_data_length(request, sizeof(request->data.stimulus)-sizeof(request->data.stimulus.call_id));
+
+ if(skinny_check_data_length_soft(request, sizeof(request->data.stimulus))) {
+ call_id = request->data.stimulus.call_id;
+ }
+
+ switch(request->data.stimulus.instance_type) {
+ case SKINNY_BUTTON_LAST_NUMBER_REDIAL:
+ skinny_create_ingoing_session(listener, &line_instance, &session);
+ skinny_session_process_dest(session, listener, line_instance, "redial", '\0', 0);
+ break;
+ case SKINNY_BUTTON_SPEED_DIAL:
+ skinny_speed_dial_get(listener, request->data.stimulus.instance, &button);
+ if(strlen(button->line) > 0) {
+ skinny_create_ingoing_session(listener, &line_instance, &session);
+ skinny_session_process_dest(session, listener, line_instance, button->line, '\0', 0);
+ }
+ break;
+ case SKINNY_BUTTON_HOLD:
+ session = skinny_profile_find_session(listener->profile, listener, &line_instance, call_id);
+
+ if(session) {
+ status = skinny_session_hold_line(session, listener, line_instance);
+ }
+ break;
+ case SKINNY_BUTTON_VOICEMAIL:
+ skinny_create_ingoing_session(listener, &line_instance, &session);
+ skinny_session_process_dest(session, listener, line_instance, "vmain", '\0', 0);
+ break;
+ default:
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unknown Stimulus Type Received [%d]\n", request->data.stimulus.instance_type);
+ }
+
+ if(session) {
+ switch_core_session_rwunlock(session);
+ }
+
+ return status;
+}
+
+switch_status_t skinny_handle_off_hook_message(listener_t *listener, skinny_message_t *request)
+{
+ uint32_t line_instance;
+ switch_core_session_t *session = NULL;
+ private_t *tech_pvt = NULL;
+
+ skinny_check_data_length(request, sizeof(request->data.off_hook));
+
+ if(request->data.off_hook.line_instance > 0) {
+ line_instance = request->data.off_hook.line_instance;
+ } else {
+ line_instance = 1;
+ }
+
+ session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.off_hook.call_id);
+
+ if(session) { /*answering a call */
+ skinny_session_answer(session, listener, line_instance);
+ } else { /* start a new call */
+ skinny_create_ingoing_session(listener, &line_instance, &session);
+ tech_pvt = switch_core_session_get_private(session);
+ assert(tech_pvt != NULL);
+
+ skinny_session_process_dest(session, listener, line_instance, NULL, '\0', 0);
+ }
+
+ if(session) {
+ switch_core_session_rwunlock(session);
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+switch_status_t skinny_handle_on_hook_message(listener_t *listener, skinny_message_t *request)
+{
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ switch_core_session_t *session = NULL;
+ uint32_t line_instance = 0;
+
+ skinny_check_data_length(request, sizeof(request->data.on_hook));
+
+ line_instance = request->data.on_hook.line_instance;
+
+ session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.on_hook.call_id);
+
+ if(session) {
+ switch_channel_t *channel = NULL;
+
+ channel = switch_core_session_get_channel(session);
+
+ switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
+ }
+
+ if(session) {
+ switch_core_session_rwunlock(session);
+ }
+
+ return status;
+}
+
+switch_status_t skinny_handle_speed_dial_stat_request(listener_t *listener, skinny_message_t *request)
+{
+ skinny_message_t *message;
+ struct speed_dial_stat_res_message *button = NULL;
+
+ skinny_check_data_length(request, sizeof(request->data.speed_dial_req));
+
+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.speed_dial_res));
+ message->type = SPEED_DIAL_STAT_RES_MESSAGE;
+ message->length = 4 + sizeof(message->data.speed_dial_res);
+
+ skinny_speed_dial_get(listener, request->data.speed_dial_req.number, &button);
+
+ memcpy(&message->data.speed_dial_res, button, sizeof(struct speed_dial_stat_res_message));
+
+ skinny_send_reply(listener, message);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+switch_status_t skinny_handle_line_stat_request(listener_t *listener, skinny_message_t *request)
+{
+ skinny_message_t *message;
+ struct line_stat_res_message *button = NULL;
+
+ skinny_check_data_length(request, sizeof(request->data.line_req));
+
+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.line_res));
+ message->type = LINE_STAT_RES_MESSAGE;
+ message->length = 4 + sizeof(message->data.line_res);
+
+ skinny_line_get(listener, request->data.line_req.number, &button);
+
+ memcpy(&message->data.line_res, button, sizeof(struct line_stat_res_message));
+
+ skinny_send_reply(listener, message);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
</ins><span class="cx"> int skinny_config_stat_res_callback(void *pArg, int argc, char **argv, char **columnNames)
</span><span class="cx"> {
</span><span class="cx"> skinny_message_t *message = pArg;
</span><span class="lines">@@ -1798,90 +2020,11 @@
</span><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_capabilities_response(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_time_date_request(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- char *sql;
- skinny_profile_t *profile;
-
- uint32_t i = 0;
- uint32_t n = 0;
- char *codec_order[SWITCH_MAX_CODECS];
- char *codec_string;
-
- size_t string_len, string_pos, pos;
-
- switch_assert(listener->profile);
- switch_assert(listener->device_name);
-
- profile = listener->profile;
-
- skinny_check_data_length(request, sizeof(request->data.cap_res.count));
-
- n = request->data.cap_res.count;
- if (n > SWITCH_MAX_CODECS) {
- n = SWITCH_MAX_CODECS;
- }
- string_len = -1;
-
- skinny_check_data_length(request, sizeof(request->data.cap_res.count) + n * sizeof(request->data.cap_res.caps[0]));
-
- for (i = 0; i < n; i++) {
- char *codec = skinny_codec2string(request->data.cap_res.caps[i].codec);
- codec_order[i] = codec;
- string_len += strlen(codec)+1;
- }
- i = 0;
- pos = 0;
- codec_string = switch_core_alloc(listener->pool, string_len+1);
- for (string_pos = 0; string_pos < string_len; string_pos++) {
- char *codec = codec_order[i];
- switch_assert(i < n);
- if(pos == strlen(codec)) {
- codec_string[string_pos] = ',';
- i++;
- pos = 0;
- } else {
- codec_string[string_pos] = codec[pos++];
- }
- }
- codec_string[string_len] = '\0';
- if ((sql = switch_mprintf(
- "UPDATE skinny_devices SET codec_string='%s' WHERE name='%s'",
- codec_string,
- listener->device_name
- ))) {
- skinny_execute_sql(profile, sql, profile->sql_mutex);
- switch_safe_free(sql);
- }
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
- "Codecs %s supported.\n", codec_string);
- return SWITCH_STATUS_SUCCESS;
</del><ins>+ return send_define_current_time_date(listener);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_port_message(listener_t *listener, skinny_message_t *request)
-{
- char *sql;
- skinny_profile_t *profile;
-
- switch_assert(listener->profile);
- switch_assert(listener->device_name);
-
- profile = listener->profile;
-
- skinny_check_data_length(request, sizeof(request->data.as_uint16));
-
- if ((sql = switch_mprintf(
- "UPDATE skinny_devices SET port=%d WHERE name='%s' and instance=%d",
- request->data.port.port,
- listener->device_name,
- listener->device_instance
- ))) {
- skinny_execute_sql(profile, sql, profile->sql_mutex);
- switch_safe_free(sql);
- }
- return SWITCH_STATUS_SUCCESS;
-}
-
</del><span class="cx"> struct button_template_helper {
</span><span class="cx"> skinny_message_t *message;
</span><span class="cx"> int count[SKINNY_BUTTON_UNDEFINED+1];
</span><span class="lines">@@ -1968,38 +2111,187 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- skinny_send_reply(listener, message);
</del><ins>+
</ins><span class="cx">
</span><ins>+ return skinny_send_reply(listener, message);;
+}
+
+switch_status_t skinny_handle_version_request(listener_t *listener, skinny_message_t *request)
+{
+ /* TODO */
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+ "VersionReqMessage not implemented yet.\n");
</ins><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><ins>+ /* return send_version(listener, ""); */
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_soft_key_template_request(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_capabilities_response(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- skinny_message_t *message;
</del><ins>+ char *sql;
</ins><span class="cx"> skinny_profile_t *profile;
</span><span class="cx">
</span><ins>+ uint32_t i = 0;
+ uint32_t n = 0;
+ char *codec_order[SWITCH_MAX_CODECS];
+ char *codec_string;
+
+ size_t string_len, string_pos, pos;
+
</ins><span class="cx"> switch_assert(listener->profile);
</span><span class="cx"> switch_assert(listener->device_name);
</span><span class="cx">
</span><span class="cx"> profile = listener->profile;
</span><span class="cx">
</span><del>- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.soft_key_template));
- message->type = SOFT_KEY_TEMPLATE_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.soft_key_template);
</del><ins>+ skinny_check_data_length(request, sizeof(request->data.cap_res.count));
</ins><span class="cx">
</span><del>- message->data.soft_key_template.soft_key_offset = 0;
- message->data.soft_key_template.soft_key_count = 21;
- message->data.soft_key_template.total_soft_key_count = 21;
</del><ins>+ n = request->data.cap_res.count;
+ if (n > SWITCH_MAX_CODECS) {
+ n = SWITCH_MAX_CODECS;
+ }
+ string_len = -1;
</ins><span class="cx">
</span><del>- memcpy(message->data.soft_key_template.soft_key,
- soft_key_template_default,
- sizeof(soft_key_template_default));
</del><ins>+ skinny_check_data_length(request, sizeof(request->data.cap_res.count) + n * sizeof(request->data.cap_res.caps[0]));
</ins><span class="cx">
</span><del>- skinny_send_reply(listener, message);
</del><ins>+ for (i = 0; i < n; i++) {
+ char *codec = skinny_codec2string(request->data.cap_res.caps[i].codec);
+ codec_order[i] = codec;
+ string_len += strlen(codec)+1;
+ }
+ i = 0;
+ pos = 0;
+ codec_string = switch_core_alloc(listener->pool, string_len+1);
+ for (string_pos = 0; string_pos < string_len; string_pos++) {
+ char *codec = codec_order[i];
+ switch_assert(i < n);
+ if(pos == strlen(codec)) {
+ codec_string[string_pos] = ',';
+ i++;
+ pos = 0;
+ } else {
+ codec_string[string_pos] = codec[pos++];
+ }
+ }
+ codec_string[string_len] = '\0';
+ if ((sql = switch_mprintf(
+ "UPDATE skinny_devices SET codec_string='%s' WHERE name='%s'",
+ codec_string,
+ listener->device_name
+ ))) {
+ skinny_execute_sql(profile, sql, profile->sql_mutex);
+ switch_safe_free(sql);
+ }
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
+ "Codecs %s supported.\n", codec_string);
+ return SWITCH_STATUS_SUCCESS;
+}
</ins><span class="cx">
</span><ins>+switch_status_t skinny_handle_alarm(listener_t *listener, skinny_message_t *request)
+{
+ switch_event_t *event = NULL;
+
+ skinny_check_data_length(request, sizeof(request->data.alarm));
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
+ "Received alarm: Severity=%d, DisplayMessage=%s, Param1=%d, Param2=%d.\n",
+ request->data.alarm.alarm_severity, request->data.alarm.display_message,
+ request->data.alarm.alarm_param1, request->data.alarm.alarm_param2);
+ /* skinny::alarm event */
+ skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_ALARM);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-Severity", "%d", request->data.alarm.alarm_severity);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-DisplayMessage", "%s", request->data.alarm.display_message);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-Param1", "%d", request->data.alarm.alarm_param1);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Alarm-Param2", "%d", request->data.alarm.alarm_param2);
+ switch_event_fire(&event);
+
</ins><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+switch_status_t skinny_handle_open_receive_channel_ack_message(listener_t *listener, skinny_message_t *request)
+{
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ uint32_t line_instance = 0;
+ switch_core_session_t *session;
+
+ skinny_check_data_length(request, sizeof(request->data.open_receive_channel_ack));
+
+ session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.open_receive_channel_ack.pass_thru_party_id);
+
+ if(session) {
+ const char *err = NULL;
+ private_t *tech_pvt = NULL;
+ switch_channel_t *channel = NULL;
+ struct in_addr addr;
+
+ tech_pvt = switch_core_session_get_private(session);
+ channel = switch_core_session_get_channel(session);
+
+ /* Codec */
+ tech_pvt->iananame = "PCMU"; /* TODO */
+ tech_pvt->codec_ms = 10; /* TODO */
+ tech_pvt->rm_rate = 8000; /* TODO */
+ tech_pvt->rm_fmtp = NULL; /* TODO */
+ tech_pvt->agreed_pt = (switch_payload_t) 0; /* TODO */
+ tech_pvt->rm_encoding = switch_core_strdup(switch_core_session_get_pool(session), "");
+ skinny_tech_set_codec(tech_pvt, 0);
+ if ((status = skinny_tech_set_codec(tech_pvt, 0)) != SWITCH_STATUS_SUCCESS) {
+ goto end;
+ }
+
+ /* Request a local port from the core's allocator */
+ if (!(tech_pvt->local_sdp_audio_port = switch_rtp_request_port(listener->profile->ip))) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_CRIT, "No RTP ports available!\n");
+ return SWITCH_STATUS_FALSE;
+ }
+ tech_pvt->local_sdp_audio_ip = switch_core_strdup(switch_core_session_get_pool(session), listener->profile->ip);
+
+ tech_pvt->remote_sdp_audio_ip = inet_ntoa(request->data.open_receive_channel_ack.ip);
+ tech_pvt->remote_sdp_audio_port = request->data.open_receive_channel_ack.port;
+
+ tech_pvt->rtp_session = switch_rtp_new(tech_pvt->local_sdp_audio_ip,
+ tech_pvt->local_sdp_audio_port,
+ tech_pvt->remote_sdp_audio_ip,
+ tech_pvt->remote_sdp_audio_port,
+ tech_pvt->agreed_pt,
+ tech_pvt->read_impl.samples_per_packet,
+ tech_pvt->codec_ms * 1000,
+ (switch_rtp_flag_t) 0, "soft", &err,
+ switch_core_session_get_pool(session));
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG,
+ "AUDIO RTP [%s] %s:%d->%s:%d codec: %u ms: %d [%s]\n",
+ switch_channel_get_name(channel),
+ tech_pvt->local_sdp_audio_ip,
+ tech_pvt->local_sdp_audio_port,
+ tech_pvt->remote_sdp_audio_ip,
+ tech_pvt->remote_sdp_audio_port,
+ tech_pvt->agreed_pt,
+ tech_pvt->read_impl.microseconds_per_packet / 1000,
+ switch_rtp_ready(tech_pvt->rtp_session) ? "SUCCESS" : err);
+ inet_aton(tech_pvt->local_sdp_audio_ip, &addr);
+ send_start_media_transmission(listener,
+ tech_pvt->call_id, /* uint32_t conference_id, */
+ tech_pvt->party_id, /* uint32_t pass_thru_party_id, */
+ addr.s_addr, /* uint32_t remote_ip, */
+ tech_pvt->local_sdp_audio_port, /* uint32_t remote_port, */
+ 20, /* uint32_t ms_per_packet, */
+ SKINNY_CODEC_ULAW_64K, /* uint32_t payload_capacity, */
+ 184, /* uint32_t precedence, */
+ 0, /* uint32_t silence_suppression, */
+ 0, /* uint16_t max_frames_per_packet, */
+ 0 /* uint32_t g723_bitrate */
+ );
+
+ if (switch_channel_get_state(channel) == CS_NEW) {
+ switch_channel_set_state(channel, CS_INIT);
+ }
+ switch_channel_mark_answered(channel);
+ }
+end:
+ if(session) {
+ switch_core_session_rwunlock(session);
+ }
+ return status;
+}
+
</ins><span class="cx"> switch_status_t skinny_handle_soft_key_set_request(listener_t *listener, skinny_message_t *request)
</span><span class="cx"> {
</span><span class="cx"> skinny_message_t *message;
</span><span class="lines">@@ -2052,111 +2344,6 @@
</span><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_line_stat_request(listener_t *listener, skinny_message_t *request)
-{
- skinny_message_t *message;
- struct line_stat_res_message *button = NULL;
-
- skinny_check_data_length(request, sizeof(request->data.line_req));
-
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.line_res));
- message->type = LINE_STAT_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.line_res);
-
- skinny_line_get(listener, request->data.line_req.number, &button);
-
- memcpy(&message->data.line_res, button, sizeof(struct line_stat_res_message));
-
- skinny_send_reply(listener, message);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-switch_status_t skinny_handle_speed_dial_stat_request(listener_t *listener, skinny_message_t *request)
-{
- skinny_message_t *message;
- struct speed_dial_stat_res_message *button = NULL;
-
- skinny_check_data_length(request, sizeof(request->data.speed_dial_req));
-
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.speed_dial_res));
- message->type = SPEED_DIAL_STAT_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.speed_dial_res);
-
- skinny_speed_dial_get(listener, request->data.speed_dial_req.number, &button);
-
- memcpy(&message->data.speed_dial_res, button, sizeof(struct speed_dial_stat_res_message));
-
- skinny_send_reply(listener, message);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-switch_status_t skinny_handle_service_url_stat_request(listener_t *listener, skinny_message_t *request)
-{
- skinny_message_t *message;
- struct service_url_stat_res_message *button = NULL;
-
- skinny_check_data_length(request, sizeof(request->data.service_url_req));
-
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.service_url_res));
- message->type = SERVICE_URL_STAT_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.service_url_res);
-
- skinny_service_url_get(listener, request->data.service_url_req.service_url_index, &button);
-
- memcpy(&message->data.service_url_res, button, sizeof(struct service_url_stat_res_message));
-
- skinny_send_reply(listener, message);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-switch_status_t skinny_handle_feature_stat_request(listener_t *listener, skinny_message_t *request)
-{
- skinny_message_t *message;
- struct feature_stat_res_message *button = NULL;
-
- skinny_check_data_length(request, sizeof(request->data.feature_req));
-
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.feature_res));
- message->type = FEATURE_STAT_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.feature_res);
-
- skinny_feature_get(listener, request->data.feature_req.feature_index, &button);
-
- memcpy(&message->data.feature_res, button, sizeof(struct feature_stat_res_message));
-
- skinny_send_reply(listener, message);
-
- return SWITCH_STATUS_SUCCESS;
-}
-
-switch_status_t skinny_handle_register_available_lines_message(listener_t *listener, skinny_message_t *request)
-{
- skinny_check_data_length(request, sizeof(request->data.reg_lines));
-
- /* Do nothing */
- return SWITCH_STATUS_SUCCESS;
-}
-
-switch_status_t skinny_handle_time_date_request(listener_t *listener, skinny_message_t *request)
-{
- return send_define_current_time_date(listener);
-}
-
-switch_status_t skinny_handle_keep_alive_message(listener_t *listener, skinny_message_t *request)
-{
- skinny_message_t *message;
-
- message = switch_core_alloc(listener->pool, 12);
- message->type = KEEP_ALIVE_ACK_MESSAGE;
- message->length = 4;
- keepalive_listener(listener, NULL);
- skinny_send_reply(listener, message);
- return SWITCH_STATUS_SUCCESS;
-}
-
</del><span class="cx"> switch_status_t skinny_handle_soft_key_event_message(listener_t *listener, skinny_message_t *request)
</span><span class="cx"> {
</span><span class="cx"> switch_status_t status = SWITCH_STATUS_SUCCESS;
</span><span class="lines">@@ -2240,274 +2427,107 @@
</span><span class="cx"> return status;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_off_hook_message(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_unregister(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- uint32_t line_instance;
- switch_core_session_t *session = NULL;
- private_t *tech_pvt = NULL;
</del><ins>+ switch_event_t *event = NULL;
+ skinny_message_t *message;
</ins><span class="cx">
</span><del>- skinny_check_data_length(request, sizeof(request->data.off_hook));
</del><ins>+ /* skinny::unregister event */
+ skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_UNREGISTER);
+ switch_event_fire(&event);
</ins><span class="cx">
</span><del>- if(request->data.off_hook.line_instance > 0) {
- line_instance = request->data.off_hook.line_instance;
- } else {
- line_instance = 1;
- }
</del><ins>+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.unregister_ack));
+ message->type = UNREGISTER_ACK_MESSAGE;
+ message->length = 4 + sizeof(message->data.unregister_ack);
+ message->data.unregister_ack.unregister_status = 0; /* OK */
+ skinny_send_reply(listener, message);
</ins><span class="cx">
</span><del>- session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.off_hook.call_id);
</del><ins>+ /* Close socket */
+ switch_clear_flag_locked(listener, LFLAG_RUNNING);
</ins><span class="cx">
</span><del>- if(session) { /*answering a call */
- skinny_session_answer(session, listener, line_instance);
- } else { /* start a new call */
- skinny_create_ingoing_session(listener, &line_instance, &session);
- tech_pvt = switch_core_session_get_private(session);
- assert(tech_pvt != NULL);
-
- skinny_session_process_dest(session, listener, line_instance, NULL, '\0', 0);
- }
-
- if(session) {
- switch_core_session_rwunlock(session);
- }
-
</del><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_stimulus_message(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_soft_key_template_request(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- switch_status_t status = SWITCH_STATUS_SUCCESS;
- struct speed_dial_stat_res_message *button = NULL;
- uint32_t line_instance = 0;
- uint32_t call_id = 0;
- switch_core_session_t *session = NULL;
</del><ins>+ skinny_message_t *message;
+ skinny_profile_t *profile;
</ins><span class="cx">
</span><del>- skinny_check_data_length(request, sizeof(request->data.stimulus)-sizeof(request->data.stimulus.call_id));
</del><ins>+ switch_assert(listener->profile);
+ switch_assert(listener->device_name);
</ins><span class="cx">
</span><del>- if(skinny_check_data_length_soft(request, sizeof(request->data.stimulus))) {
- call_id = request->data.stimulus.call_id;
- }
</del><ins>+ profile = listener->profile;
</ins><span class="cx">
</span><del>- switch(request->data.stimulus.instance_type) {
- case SKINNY_BUTTON_LAST_NUMBER_REDIAL:
- skinny_create_ingoing_session(listener, &line_instance, &session);
- skinny_session_process_dest(session, listener, line_instance, "redial", '\0', 0);
- break;
- case SKINNY_BUTTON_SPEED_DIAL:
- skinny_speed_dial_get(listener, request->data.stimulus.instance, &button);
- if(strlen(button->line) > 0) {
- skinny_create_ingoing_session(listener, &line_instance, &session);
- skinny_session_process_dest(session, listener, line_instance, button->line, '\0', 0);
- }
- break;
- case SKINNY_BUTTON_HOLD:
- session = skinny_profile_find_session(listener->profile, listener, &line_instance, call_id);
</del><ins>+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.soft_key_template));
+ message->type = SOFT_KEY_TEMPLATE_RES_MESSAGE;
+ message->length = 4 + sizeof(message->data.soft_key_template);
</ins><span class="cx">
</span><del>- if(session) {
- status = skinny_session_hold_line(session, listener, line_instance);
- }
- break;
- case SKINNY_BUTTON_VOICEMAIL:
- skinny_create_ingoing_session(listener, &line_instance, &session);
- skinny_session_process_dest(session, listener, line_instance, "vmain", '\0', 0);
- break;
- default:
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unknown Stimulus Type Received [%d]\n", request->data.stimulus.instance_type);
- }
</del><ins>+ message->data.soft_key_template.soft_key_offset = 0;
+ message->data.soft_key_template.soft_key_count = 21;
+ message->data.soft_key_template.total_soft_key_count = 21;
</ins><span class="cx">
</span><del>- if(session) {
- switch_core_session_rwunlock(session);
- }
</del><ins>+ memcpy(message->data.soft_key_template.soft_key,
+ soft_key_template_default,
+ sizeof(soft_key_template_default));
</ins><span class="cx">
</span><del>- return status;
</del><ins>+ skinny_send_reply(listener, message);
+
+ return SWITCH_STATUS_SUCCESS;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_open_receive_channel_ack_message(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_headset_status_message(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- switch_status_t status = SWITCH_STATUS_SUCCESS;
- uint32_t line_instance = 0;
- switch_core_session_t *session;
</del><ins>+ skinny_check_data_length(request, sizeof(request->data.headset_status));
</ins><span class="cx">
</span><del>- skinny_check_data_length(request, sizeof(request->data.open_receive_channel_ack));
</del><ins>+ /* Nothing to do */
+ return SWITCH_STATUS_SUCCESS;
+}
</ins><span class="cx">
</span><del>- session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.open_receive_channel_ack.pass_thru_party_id);
</del><ins>+switch_status_t skinny_handle_register_available_lines_message(listener_t *listener, skinny_message_t *request)
+{
+ skinny_check_data_length(request, sizeof(request->data.reg_lines));
</ins><span class="cx">
</span><del>- if(session) {
- const char *err = NULL;
- private_t *tech_pvt = NULL;
- switch_channel_t *channel = NULL;
- struct in_addr addr;
-
- tech_pvt = switch_core_session_get_private(session);
- channel = switch_core_session_get_channel(session);
-
- /* Codec */
- tech_pvt->iananame = "PCMU"; /* TODO */
- tech_pvt->codec_ms = 10; /* TODO */
- tech_pvt->rm_rate = 8000; /* TODO */
- tech_pvt->rm_fmtp = NULL; /* TODO */
- tech_pvt->agreed_pt = (switch_payload_t) 0; /* TODO */
- tech_pvt->rm_encoding = switch_core_strdup(switch_core_session_get_pool(session), "");
- skinny_tech_set_codec(tech_pvt, 0);
- if ((status = skinny_tech_set_codec(tech_pvt, 0)) != SWITCH_STATUS_SUCCESS) {
- goto end;
- }
-
- /* Request a local port from the core's allocator */
- if (!(tech_pvt->local_sdp_audio_port = switch_rtp_request_port(listener->profile->ip))) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_CRIT, "No RTP ports available!\n");
- return SWITCH_STATUS_FALSE;
- }
- tech_pvt->local_sdp_audio_ip = switch_core_strdup(switch_core_session_get_pool(session), listener->profile->ip);
-
- tech_pvt->remote_sdp_audio_ip = inet_ntoa(request->data.open_receive_channel_ack.ip);
- tech_pvt->remote_sdp_audio_port = request->data.open_receive_channel_ack.port;
-
- tech_pvt->rtp_session = switch_rtp_new(tech_pvt->local_sdp_audio_ip,
- tech_pvt->local_sdp_audio_port,
- tech_pvt->remote_sdp_audio_ip,
- tech_pvt->remote_sdp_audio_port,
- tech_pvt->agreed_pt,
- tech_pvt->read_impl.samples_per_packet,
- tech_pvt->codec_ms * 1000,
- (switch_rtp_flag_t) 0, "soft", &err,
- switch_core_session_get_pool(session));
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG,
- "AUDIO RTP [%s] %s:%d->%s:%d codec: %u ms: %d [%s]\n",
- switch_channel_get_name(channel),
- tech_pvt->local_sdp_audio_ip,
- tech_pvt->local_sdp_audio_port,
- tech_pvt->remote_sdp_audio_ip,
- tech_pvt->remote_sdp_audio_port,
- tech_pvt->agreed_pt,
- tech_pvt->read_impl.microseconds_per_packet / 1000,
- switch_rtp_ready(tech_pvt->rtp_session) ? "SUCCESS" : err);
- inet_aton(tech_pvt->local_sdp_audio_ip, &addr);
- send_start_media_transmission(listener,
- tech_pvt->call_id, /* uint32_t conference_id, */
- tech_pvt->party_id, /* uint32_t pass_thru_party_id, */
- addr.s_addr, /* uint32_t remote_ip, */
- tech_pvt->local_sdp_audio_port, /* uint32_t remote_port, */
- 20, /* uint32_t ms_per_packet, */
- SKINNY_CODEC_ULAW_64K, /* uint32_t payload_capacity, */
- 184, /* uint32_t precedence, */
- 0, /* uint32_t silence_suppression, */
- 0, /* uint16_t max_frames_per_packet, */
- 0 /* uint32_t g723_bitrate */
- );
-
- if (switch_channel_get_state(channel) == CS_NEW) {
- switch_channel_set_state(channel, CS_INIT);
- }
- switch_channel_mark_answered(channel);
- }
-end:
- if(session) {
- switch_core_session_rwunlock(session);
- }
- return status;
</del><ins>+ /* Do nothing */
+ return SWITCH_STATUS_SUCCESS;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_keypad_button_message(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_service_url_stat_request(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- uint32_t line_instance = 0;
- switch_core_session_t *session;
</del><ins>+ skinny_message_t *message;
+ struct service_url_stat_res_message *button = NULL;
</ins><span class="cx">
</span><del>- skinny_check_data_length(request, sizeof(request->data.keypad_button));
-
- if(request->data.keypad_button.line_instance) {
- line_instance = request->data.keypad_button.line_instance;
- } else {
- line_instance = 1;
- }
</del><ins>+ skinny_check_data_length(request, sizeof(request->data.service_url_req));
</ins><span class="cx">
</span><del>- session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.keypad_button.call_id);
</del><ins>+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.service_url_res));
+ message->type = SERVICE_URL_STAT_RES_MESSAGE;
+ message->length = 4 + sizeof(message->data.service_url_res);
</ins><span class="cx">
</span><del>- if(session) {
- switch_channel_t *channel = NULL;
- private_t *tech_pvt = NULL;
- char digit = '\0';
</del><ins>+ skinny_service_url_get(listener, request->data.service_url_req.service_url_index, &button);
</ins><span class="cx">
</span><del>- channel = switch_core_session_get_channel(session);
- tech_pvt = switch_core_session_get_private(session);
</del><ins>+ memcpy(&message->data.service_url_res, button, sizeof(struct service_url_stat_res_message));
</ins><span class="cx">
</span><del>- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "SEND DTMF ON CALL %d [%d]\n", tech_pvt->call_id, request->data.keypad_button.button);
</del><ins>+ skinny_send_reply(listener, message);
</ins><span class="cx">
</span><del>- if (request->data.keypad_button.button == 14) {
- digit = '*';
- } else if (request->data.keypad_button.button == 15) {
- digit = '#';
- } else if (request->data.keypad_button.button >= 0 && request->data.keypad_button.button <= 9) {
- digit = '0' + request->data.keypad_button.button;
- } else {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "UNKNOW DTMF RECEIVED ON CALL %d [%d]\n", tech_pvt->call_id, request->data.keypad_button.button);
- }
-
- /* TODO check call_id and line */
-
- if((skinny_line_get_state(listener, line_instance, tech_pvt->call_id) == SKINNY_OFF_HOOK)) {
-
- skinny_session_process_dest(session, listener, line_instance, NULL, digit, 0);
- } else {
- if(digit != '\0') {
- switch_dtmf_t dtmf = { 0, switch_core_default_dtmf_duration(0)};
- dtmf.digit = digit;
- switch_channel_queue_dtmf(channel, &dtmf);
- }
- }
- }
-
- if(session) {
- switch_core_session_rwunlock(session);
- }
-
</del><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-switch_status_t skinny_handle_on_hook_message(listener_t *listener, skinny_message_t *request)
</del><ins>+switch_status_t skinny_handle_feature_stat_request(listener_t *listener, skinny_message_t *request)
</ins><span class="cx"> {
</span><del>- switch_status_t status = SWITCH_STATUS_SUCCESS;
- switch_core_session_t *session = NULL;
- uint32_t line_instance = 0;
</del><ins>+ skinny_message_t *message;
+ struct feature_stat_res_message *button = NULL;
</ins><span class="cx">
</span><del>- skinny_check_data_length(request, sizeof(request->data.on_hook));
</del><ins>+ skinny_check_data_length(request, sizeof(request->data.feature_req));
</ins><span class="cx">
</span><del>- line_instance = request->data.on_hook.line_instance;
-
- session = skinny_profile_find_session(listener->profile, listener, &line_instance, request->data.on_hook.call_id);
</del><ins>+ message = switch_core_alloc(listener->pool, 12+sizeof(message->data.feature_res));
+ message->type = FEATURE_STAT_RES_MESSAGE;
+ message->length = 4 + sizeof(message->data.feature_res);
</ins><span class="cx">
</span><del>- if(session) {
- switch_channel_t *channel = NULL;
</del><ins>+ skinny_feature_get(listener, request->data.feature_req.feature_index, &button);
</ins><span class="cx">
</span><del>- channel = switch_core_session_get_channel(session);
</del><ins>+ memcpy(&message->data.feature_res, button, sizeof(struct feature_stat_res_message));
</ins><span class="cx">
</span><del>- switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
- }
-
- if(session) {
- switch_core_session_rwunlock(session);
- }
-
- return status;
-}
-
-switch_status_t skinny_handle_unregister(listener_t *listener, skinny_message_t *request)
-{
- switch_event_t *event = NULL;
- skinny_message_t *message;
-
- /* skinny::unregister event */
- skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_UNREGISTER);
- switch_event_fire(&event);
-
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.unregister_ack));
- message->type = UNREGISTER_ACK_MESSAGE;
- message->length = 4 + sizeof(message->data.unregister_ack);
- message->data.unregister_ack.unregister_status = 0; /* OK */
</del><span class="cx"> skinny_send_reply(listener, message);
</span><span class="cx">
</span><del>- /* Close socket */
- switch_clear_flag_locked(listener, LFLAG_RUNNING);
-
</del><span class="cx"> return SWITCH_STATUS_SUCCESS;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2545,6 +2565,8 @@
</span><span class="cx"> return skinny_handle_time_date_request(listener, request);
</span><span class="cx"> case BUTTON_TEMPLATE_REQ_MESSAGE:
</span><span class="cx"> return skinny_handle_button_template_request(listener, request);
</span><ins>+ case VERSION_REQ_MESSAGE:
+ return skinny_handle_version_request(listener, request);
</ins><span class="cx"> case CAPABILITIES_RES_MESSAGE:
</span><span class="cx"> return skinny_handle_capabilities_response(listener, request);
</span><span class="cx"> case ALARM_MESSAGE:
</span></span></pre></div>
<a id="freeswitchtrunksrcmodendpointsmod_skinnyskinny_protocolh"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.h (17318 => 17319)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.h 2010-04-16 09:59:58 UTC (rev 17318)
+++ freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_protocol.h 2010-04-16 13:03:37 UTC (rev 17319)
</span><span class="lines">@@ -114,6 +114,9 @@
</span><span class="cx"> /* ButtonTemplateReqMessage */
</span><span class="cx"> #define BUTTON_TEMPLATE_REQ_MESSAGE 0x000E
</span><span class="cx">
</span><ins>+/* VersionReqMessage */
+#define VERSION_REQ_MESSAGE 0x000F
+
</ins><span class="cx"> /* CapabilitiesResMessage */
</span><span class="cx"> #define CAPABILITIES_RES_MESSAGE 0x0010
</span><span class="cx"> struct station_capabilities {
</span><span class="lines">@@ -343,6 +346,12 @@
</span><span class="cx"> struct button_definition btn[SKINNY_MAX_BUTTON_COUNT];
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+/* VersionMessage */
+#define VERSION_MESSAGE 0x0098
+struct version_message {
+ char version[16];
+};
+
</ins><span class="cx"> /* CapabilitiesReqMessage */
</span><span class="cx"> #define CAPABILITIES_REQ_MESSAGE 0x009B
</span><span class="cx">
</span><span class="lines">@@ -535,6 +544,7 @@
</span><span class="cx"> struct config_stat_res_message config_res;
</span><span class="cx"> struct define_time_date_message define_time_date;
</span><span class="cx"> struct button_template_message button_template;
</span><ins>+ struct version_message version;
</ins><span class="cx"> struct register_reject_message reg_rej;
</span><span class="cx"> struct reset_message reset;
</span><span class="cx"> struct open_receive_channel_message open_receive_channel;
</span><span class="lines">@@ -724,6 +734,10 @@
</span><span class="cx"> uint32_t milliseconds,
</span><span class="cx"> uint32_t timestamp);
</span><span class="cx"> switch_status_t send_define_current_time_date(listener_t *listener);
</span><ins>+switch_status_t send_version(listener_t *listener,
+ char *version);
+switch_status_t send_register_reject(listener_t *listener,
+ char *error);
</ins><span class="cx"> switch_status_t send_open_receive_channel(listener_t *listener,
</span><span class="cx"> uint32_t conference_id,
</span><span class="cx"> uint32_t pass_thru_party_id,
</span></span></pre></div>
<a id="freeswitchtrunksrcmodendpointsmod_skinnyskinny_tablesc"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.c (17318 => 17319)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.c 2010-04-16 09:59:58 UTC (rev 17318)
+++ freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.c 2010-04-16 13:03:37 UTC (rev 17319)
</span><span class="lines">@@ -47,6 +47,7 @@
</span><span class="cx"> {"ConfigStatReqMessage", CONFIG_STAT_REQ_MESSAGE},
</span><span class="cx"> {"TimeDateReqMessage", TIME_DATE_REQ_MESSAGE},
</span><span class="cx"> {"ButtonTemplateReqMessage", BUTTON_TEMPLATE_REQ_MESSAGE},
</span><ins>+ {"VersionReqMessage", VERSION_REQ_MESSAGE},
</ins><span class="cx"> {"CapabilitiesReqMessage", CAPABILITIES_RES_MESSAGE},
</span><span class="cx"> {"AlarmMessage", ALARM_MESSAGE},
</span><span class="cx"> {"OpenReceiveChannelAckMessage", OPEN_RECEIVE_CHANNEL_ACK_MESSAGE},
</span><span class="lines">@@ -72,6 +73,7 @@
</span><span class="cx"> {"ConfigStatResMessage", CONFIG_STAT_RES_MESSAGE},
</span><span class="cx"> {"DefineTimeDateMessage", DEFINE_TIME_DATE_MESSAGE},
</span><span class="cx"> {"ButtonTemplateResMessage", BUTTON_TEMPLATE_RES_MESSAGE},
</span><ins>+ {"VersionMessage", VERSION_MESSAGE},
</ins><span class="cx"> {"CapabilitiesReqMessage", CAPABILITIES_REQ_MESSAGE},
</span><span class="cx"> {"RegisterRejectMessage", REGISTER_REJECT_MESSAGE},
</span><span class="cx"> {"ResetMessage", RESET_MESSAGE},
</span></span></pre></div>
<a id="freeswitchtrunksrcmodendpointsmod_skinnyskinny_tablesh"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.h (17318 => 17319)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.h 2010-04-16 09:59:58 UTC (rev 17318)
+++ freeswitch/trunk/src/mod/endpoints/mod_skinny/skinny_tables.h 2010-04-16 13:03:37 UTC (rev 17319)
</span><span class="lines">@@ -84,7 +84,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-struct skinny_table SKINNY_MESSAGE_TYPES[57];
</del><ins>+struct skinny_table SKINNY_MESSAGE_TYPES[59];
</ins><span class="cx"> const char *skinny_message_type2str(uint32_t id);
</span><span class="cx"> uint32_t skinny_str2message_type(const char *str);
</span><span class="cx"> #define SKINNY_PUSH_MESSAGE_TYPES SKINNY_DECLARE_PUSH_MATCH(SKINNY_MESSAGE_TYPES)
</span></span></pre>
</div>
</div>
<div id="footer">See you at ClueCon</div>
</body>
</html>