const char *file, const char *func, int line)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12);
- message->type = KEEP_ALIVE_ACK_MESSAGE;
- message->length = 4;
+
+ skinny_create_empty_message(message, KEEP_ALIVE_ACK_MESSAGE);
if ( listener->profile->debug >= 10 ) {
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Sending Keep Alive Ack%s\n", "");
}
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_register_ack(listener_t *listener,
char *reserved2)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reg_ack));
- message->type = REGISTER_ACK_MESSAGE;
- message->length = 4 + sizeof(message->data.reg_ack);
+
+ skinny_create_message(message, REGISTER_ACK_MESSAGE, reg_ack);
+
message->data.reg_ack.keep_alive = keep_alive;
strncpy(message->data.reg_ack.date_format, date_format, 6);
strncpy(message->data.reg_ack.reserved, reserved, 2);
"Sending Register Ack with Keep Alive (%d), Date Format (%s), Secondary Keep Alive (%d)\n",
keep_alive, date_format, secondary_keep_alive);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_speed_dial_stat_res(listener_t *listener,
char *speed_label)
{
skinny_message_t *message;
- 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_create_message(message, SPEED_DIAL_STAT_RES_MESSAGE, speed_dial_res);
message->data.speed_dial_res.number = number;
strncpy(message->data.speed_dial_res.line, speed_line, 24);
"Sending Speed Dial Stat Res with Number (%d), Line (%s), Label (%s)\n",
number, speed_line, speed_label);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_start_tone(listener_t *listener,
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.start_tone));
- message->type = START_TONE_MESSAGE;
- message->length = 4 + sizeof(message->data.start_tone);
+
+ skinny_create_message(message, START_TONE_MESSAGE, start_tone);
+
message->data.start_tone.tone = tone;
message->data.start_tone.reserved = reserved;
message->data.start_tone.line_instance = line_instance;
"Sending Start Tone with Tone (%s), Line Instance (%d), Call ID (%d)\n",
skinny_tone2str(tone), line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_stop_tone(listener_t *listener,
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.stop_tone));
- message->type = STOP_TONE_MESSAGE;
- message->length = 4 + sizeof(message->data.stop_tone);
+
+ skinny_create_message(message, STOP_TONE_MESSAGE, stop_tone);
+
message->data.stop_tone.line_instance = line_instance;
message->data.stop_tone.call_id = call_id;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Sending Stop Tone with Line Instance (%d), Call ID (%d)\n", line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_set_ringer(listener_t *listener,
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.ringer));
- message->type = SET_RINGER_MESSAGE;
- message->length = 4 + sizeof(message->data.ringer);
+
+ skinny_create_message(message, SET_RINGER_MESSAGE, ringer);
+
message->data.ringer.ring_type = ring_type;
message->data.ringer.ring_mode = ring_mode;
message->data.ringer.line_instance = line_instance;
"Sending SetRinger with Ring Type (%s), Mode (%s), Line Instance (%d), Call ID (%d)\n",
skinny_ring_type2str(ring_type), skinny_ring_mode2str(ring_mode), line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_set_lamp(listener_t *listener,
uint32_t mode)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.lamp));
- message->type = SET_LAMP_MESSAGE;
- message->length = 4 + sizeof(message->data.lamp);
+
+ skinny_create_message(message, SET_LAMP_MESSAGE, lamp);
+
message->data.lamp.stimulus = stimulus;
message->data.lamp.stimulus_instance = stimulus_instance;
message->data.lamp.mode = mode;
"Sending Set Lamp with Stimulus (%s), Stimulus Instance (%d), Mode (%s)\n",
skinny_button2str(stimulus), stimulus_instance, skinny_lamp_mode2str(mode));
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_set_speaker_mode(listener_t *listener,
uint32_t mode)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.speaker_mode));
- message->type = SET_SPEAKER_MODE_MESSAGE;
- message->length = 4 + sizeof(message->data.speaker_mode);
+
+ skinny_create_message(message, SET_SPEAKER_MODE_MESSAGE, speaker_mode);
+
message->data.speaker_mode.mode = mode;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Sending Set Speaker Mode with Mode (%s)\n", skinny_speaker_mode2str(mode));
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_srvreq_response(listener_t *listener,
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.serv_res_mess));
- message->type = SERVER_RESPONSE_MESSAGE;
- message->length = 4 + sizeof(message->data.serv_res_mess);
+ skinny_create_message(message, SERVER_RESPONSE_MESSAGE, serv_res_mess);
message->data.serv_res_mess.serverListenPort[0] = port;
switch_inet_pton(AF_INET,ip, &message->data.serv_res_mess.serverIpAddr[0]);
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Sending Server Request Response with IP (%s) and Port (%d)\n", ip, port);
- return skinny_send_reply(listener, message);
+ return skinny_send_reply(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_start_media_transmission(listener_t *listener,
uint32_t g723_bitrate)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.start_media));
- message->type = START_MEDIA_TRANSMISSION_MESSAGE;
- message->length = 4 + sizeof(message->data.start_media);
+
+ skinny_create_message(message, START_MEDIA_TRANSMISSION_MESSAGE, start_media);
+
message->data.start_media.conference_id = conference_id;
message->data.start_media.pass_thru_party_id = pass_thru_party_id;
message->data.start_media.remote_ip = remote_ip;
"Send Start Media Transmission with Conf ID(%d), Passthrough Party ID (%d), ...\n",
conference_id, pass_thru_party_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_stop_media_transmission(listener_t *listener,
uint32_t conference_id2)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.stop_media));
- message->type = STOP_MEDIA_TRANSMISSION_MESSAGE;
- message->length = 4 + sizeof(message->data.stop_media);
+
+ skinny_create_message(message, STOP_MEDIA_TRANSMISSION_MESSAGE, stop_media);
+
message->data.stop_media.conference_id = conference_id;
message->data.stop_media.pass_thru_party_id = pass_thru_party_id;
message->data.stop_media.conference_id2 = conference_id2;
"Send Stop Media Transmission with Conf ID (%d), Passthrough Party ID (%d), Conf ID2 (%d)\n",
conference_id, pass_thru_party_id, conference_id2);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_call_info(listener_t *listener,
uint32_t party_pi_restriction_bits)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.call_info));
- message->type = CALL_INFO_MESSAGE;
- message->length = 4 + sizeof(message->data.call_info);
+
+ skinny_create_message(message, CALL_INFO_MESSAGE, call_info);
+
strncpy(message->data.call_info.calling_party_name, calling_party_name, 40);
strncpy(message->data.call_info.calling_party, calling_party, 24);
strncpy(message->data.call_info.called_party_name, called_party_name, 40);
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Call Info with Line Instance (%d)...\n", line_instance);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_define_time_date(listener_t *listener,
uint32_t timestamp)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.define_time_date));
- message->type = DEFINE_TIME_DATE_MESSAGE;
- message->length = 4+sizeof(message->data.define_time_date);
+
+ skinny_create_message(message, DEFINE_TIME_DATE_MESSAGE, define_time_date);
+
message->data.define_time_date.year = year;
message->data.define_time_date.month = month;
message->data.define_time_date.day_of_week = day_of_week;
"Send Define Time Date with %.4d-%.2d-%.2d %.2d:%.2d:%.2d.%d, Timestamp (%d), DOW (%d)\n",
year, month, day, hour, minute, seconds, milliseconds, timestamp, day_of_week);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_define_current_time_date(listener_t *listener,
const char *file, const char *func, int line)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12);
- message->type = CAPABILITIES_REQ_MESSAGE;
- message->length = 4;
+
+ skinny_create_empty_message(message, CAPABILITIES_REQ_MESSAGE);
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Capabilities Req%s\n", "");
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_version(listener_t *listener,
char *version)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.version));
- message->type = VERSION_MESSAGE;
- message->length = 4+ sizeof(message->data.version);
+
+ skinny_create_message(message, VERSION_MESSAGE, version);
+
strncpy(message->data.version.version, version, 16);
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Version with Version(%s)\n", version);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_register_reject(listener_t *listener,
char *error)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reg_rej));
- message->type = REGISTER_REJECT_MESSAGE;
- message->length = 4 + sizeof(message->data.reg_rej);
+
+ skinny_create_message(message, REGISTER_REJECT_MESSAGE, reg_rej);
+
strncpy(message->data.reg_rej.error, error, 33);
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Register Reject with Error (%s)\n", error);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_open_receive_channel(listener_t *listener,
uint32_t reserved[10])
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.open_receive_channel));
- message->type = OPEN_RECEIVE_CHANNEL_MESSAGE;
- message->length = 4 + sizeof(message->data.open_receive_channel);
+
+ skinny_create_message(message, OPEN_RECEIVE_CHANNEL_MESSAGE, open_receive_channel);
+
message->data.open_receive_channel.conference_id = conference_id;
message->data.open_receive_channel.pass_thru_party_id = pass_thru_party_id;
message->data.open_receive_channel.ms_per_packet = ms_per_packet;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Open Receive Channel with Conf ID (%d), ...\n", conference_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_close_receive_channel(listener_t *listener,
uint32_t conference_id2)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.close_receive_channel));
- message->type = CLOSE_RECEIVE_CHANNEL_MESSAGE;
- message->length = 4 + sizeof(message->data.close_receive_channel);
+
+ skinny_create_message(message, CLOSE_RECEIVE_CHANNEL_MESSAGE, close_receive_channel);
+
message->data.close_receive_channel.conference_id = conference_id;
message->data.close_receive_channel.pass_thru_party_id = pass_thru_party_id;
message->data.close_receive_channel.conference_id2 = conference_id2;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Close Receive Channel with Conf ID (%d), ...\n", conference_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_select_soft_keys(listener_t *listener,
uint32_t valid_key_mask)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.select_soft_keys));
- message->type = SELECT_SOFT_KEYS_MESSAGE;
- message->length = 4 + sizeof(message->data.select_soft_keys);
+
+ skinny_create_message(message, SELECT_SOFT_KEYS_MESSAGE, select_soft_keys);
+
message->data.select_soft_keys.line_instance = line_instance;
message->data.select_soft_keys.call_id = call_id;
message->data.select_soft_keys.soft_key_set = soft_key_set;
"Send Select Soft Keys with Line Instance (%d), Call ID (%d), Soft Key Set (%d), Valid Key Mask (%x)\n",
line_instance, call_id, soft_key_set, valid_key_mask);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_call_state(listener_t *listener,
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.call_state));
- message->type = CALL_STATE_MESSAGE;
- message->length = 4 + sizeof(message->data.call_state);
+
+ skinny_create_message(message, CALL_STATE_MESSAGE, call_state);
+
message->data.call_state.call_state = call_state;
message->data.call_state.line_instance = line_instance;
message->data.call_state.call_id = call_id;
"Send Call State with State (%s), Line Instance (%d), Call ID (%d)\n",
skinny_call_state2str(call_state), line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_display_prompt_status(listener_t *listener,
skinny_message_t *message;
char *tmp;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_prompt_status));
- message->type = DISPLAY_PROMPT_STATUS_MESSAGE;
- message->length = 4 + sizeof(message->data.display_prompt_status);
+ skinny_create_message(message, DISPLAY_PROMPT_STATUS_MESSAGE, display_prompt_status);
+
message->data.display_prompt_status.timeout = timeout;
strncpy(message->data.display_prompt_status.display, display, 32);
message->data.display_prompt_status.line_instance = line_instance;
switch_safe_free(tmp);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_display_prompt_status_textid(listener_t *listener,
{
skinny_message_t *message;
char *label;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_prompt_status));
- message->type = DISPLAY_PROMPT_STATUS_MESSAGE;
- message->length = 4 + sizeof(message->data.display_prompt_status);
+
+ skinny_create_message(message, DISPLAY_PROMPT_STATUS_MESSAGE, display_prompt_status);
+
message->data.display_prompt_status.timeout = timeout;
label = skinny_textid2raw(display_textid);
"Send Display Prompt Status with Timeout (%d), Display (%s), Line Instance (%d), Call ID (%d)\n",
timeout, skinny_textid2str(display_textid), line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_clear_prompt_status(listener_t *listener,
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.clear_prompt_status));
- message->type = CLEAR_PROMPT_STATUS_MESSAGE;
- message->length = 4 + sizeof(message->data.clear_prompt_status);
+
+ skinny_create_message(message, CLEAR_PROMPT_STATUS_MESSAGE, clear_prompt_status);
+
message->data.clear_prompt_status.line_instance = line_instance;
message->data.clear_prompt_status.call_id = call_id;
"Send Clear Prompt Status with Line Instance (%d), Call ID (%d)\n",
line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_activate_call_plane(listener_t *listener,
uint32_t line_instance)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.activate_call_plane));
- message->type = ACTIVATE_CALL_PLANE_MESSAGE;
- message->length = 4 + sizeof(message->data.activate_call_plane);
+
+ skinny_create_message(message, ACTIVATE_CALL_PLANE_MESSAGE, activate_call_plane);
+
message->data.activate_call_plane.line_instance = line_instance;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Activate Call Plane with Line Instance (%d)\n", line_instance);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_back_space_request(listener_t *listener,
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.back_space_req));
- message->type = BACK_SPACE_REQ_MESSAGE;
- message->length = 4 + sizeof(message->data.back_space_req);
+
+ skinny_create_message(message, BACK_SPACE_REQ_MESSAGE, back_space_req);
+
message->data.back_space_req.line_instance = line_instance;
message->data.back_space_req.call_id = call_id;
"Send Back Space Request with Line Instance (%d), Call ID (%d)\n",
line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
uint32_t call_id)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.dialed_number));
- message->type = DIALED_NUMBER_MESSAGE;
- message->length = 4 + sizeof(message->data.dialed_number);
+
+ skinny_create_message(message, DIALED_NUMBER_MESSAGE, dialed_number);
+
strncpy(message->data.dialed_number.called_party, called_party, 24);
message->data.dialed_number.line_instance = line_instance;
message->data.dialed_number.call_id = call_id;
"Send Dialed Number with Number (%s), Line Instance (%d), Call ID (%d)\n",
called_party, line_instance, call_id);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_display_pri_notify(listener_t *listener,
char *notify)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.display_pri_notify));
- message->type = DISPLAY_PRI_NOTIFY_MESSAGE;
- message->length = 4 + sizeof(message->data.display_pri_notify);
+
+ skinny_create_message(message, DISPLAY_PRI_NOTIFY_MESSAGE, display_pri_notify);
+
message->data.display_pri_notify.message_timeout = message_timeout;
message->data.display_pri_notify.priority = priority;
strncpy(message->data.display_pri_notify.notify, notify, 32);
"Send Display Pri Notify with Timeout (%d), Priority (%d), Message (%s)\n",
message_timeout, priority, notify);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
uint32_t reset_type)
{
skinny_message_t *message;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.reset));
- message->type = RESET_MESSAGE;
- message->length = 4 + sizeof(message->data.reset);
+
+ skinny_create_message(message, RESET_MESSAGE, reset);
+
message->data.reset.reset_type = reset_type;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Reset with Type (%s)\n", skinny_device_reset_type2str(reset_type));
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_data(listener_t *listener,
{
skinny_message_t *message;
switch_assert(data_length == strlen(data));
+
/* data_length should be a multiple of 4 */
if ((data_length % 4) != 0) {
data_length = (data_length / 4 + 1) * 4;
}
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.data)+data_length-1);
+
+ /* This one needs explicit allocation */
+ message = calloc(12+sizeof(message->data.data)+data_length-1, 1);
message->type = message_type;
message->length = 4 + sizeof(message->data.data)+data_length-1;
+
message->data.data.application_id = application_id;
message->data.data.line_instance = line_instance;
message->data.data.call_id = call_id;
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
"Send Data with Data Length (%d)\n", data_length);
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
switch_status_t perform_send_extended_data(listener_t *listener,
{
skinny_message_t *message;
switch_assert(data_length == strlen(data));
+
/* data_length should be a multiple of 4 */
if ((data_length % 4) != 0) {
data_length = (data_length / 4 + 1) * 4;
}
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.extended_data)+data_length-1);
+
+ /* This one needs explicit allocation */
+ message = calloc(12+sizeof(message->data.extended_data)+data_length-1, 1);
message->type = message_type;
message->length = 4 + sizeof(message->data.extended_data)+data_length-1;
+
message->data.extended_data.application_id = application_id;
message->data.extended_data.line_instance = line_instance;
message->data.extended_data.call_id = call_id;
"Send Extended Data with Application ID (%d), Line Instance (%d), Call ID (%d), ...\n",
application_id, line_instance, call_id );
- return skinny_send_reply_quiet(listener, message);
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
}
-switch_status_t skinny_perform_send_reply_quiet(listener_t *listener, const char *file, const char *func, int line, skinny_message_t *reply)
+switch_status_t skinny_perform_send_reply_quiet(listener_t *listener, const char *file, const char *func, int line, skinny_message_t *reply,
+ switch_bool_t discard)
{
char *ptr;
switch_size_t len;
+ switch_status_t res;
+
switch_assert(reply != NULL);
+
len = reply->length+8;
ptr = (char *) reply;
if (listener_is_ready(listener)) {
- return switch_socket_send(listener->sock, ptr, &len);
+ res = switch_socket_send(listener->sock, ptr, &len);
+
+ if ( discard ) { switch_safe_free(reply); }
+ return res;
} else {
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_WARNING,
"Not sending %s (type=%x,length=%d) while not ready.\n",
skinny_message_type2str(reply->type), reply->type, reply->length);
+
+ if ( discard ) { switch_safe_free(reply); }
return SWITCH_STATUS_FALSE;
}
}
-switch_status_t skinny_perform_send_reply(listener_t *listener, const char *file, const char *func, int line, skinny_message_t *reply)
+switch_status_t skinny_perform_send_reply(listener_t *listener, const char *file, const char *func, int line, skinny_message_t *reply,
+ switch_bool_t discard)
{
char *ptr;
switch_size_t len;
+ switch_status_t res;
+
switch_assert(reply != NULL);
+
len = reply->length+8;
ptr = (char *) reply;
"Sending %s (type=%x,length=%d).\n",
skinny_message_type2str(reply->type), reply->type, reply->length);
}
- return switch_socket_send(listener->sock, ptr, &len);
+ res = switch_socket_send(listener->sock, ptr, &len);
+
+ if ( discard ) { switch_safe_free(reply); }
+ return res;
} else {
skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_WARNING,
"Not sending %s (type=%x,length=%d) while not ready.\n",
skinny_message_type2str(reply->type), reply->type, reply->length);
+
+ if ( discard ) { switch_safe_free(reply); }
return SWITCH_STATUS_FALSE;
}
}
SKINNY_TEXTID_IDIVERT
};
-#define TEXT_ID_LEN 20
-
uint32_t soft_key_template_default_events[] = {
SOFTKEY_REDIAL,
SOFTKEY_NEWCALL,
skinny_check_data_length(request, sizeof(request->data.forward_stat_req));
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.forward_stat));
- message->type = FORWARD_STAT_MESSAGE;
- message->length = 4 + sizeof(message->data.forward_stat);
+ skinny_create_message(message, FORWARD_STAT_MESSAGE, forward_stat);
message->data.forward_stat.line_instance = request->data.forward_stat_req.line_instance;
skinny_log_l(listener, SWITCH_LOG_DEBUG, "Handle Forward Stat Req Message with Line Instance (%d)\n",
request->data.forward_stat_req.line_instance);
- skinny_send_reply_quiet(listener, message);
+ skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
return SWITCH_STATUS_SUCCESS;
}
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_create_message(message, LINE_STAT_RES_MESSAGE, 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);
+ skinny_send_reply(listener, message, SWITCH_TRUE);
return SWITCH_STATUS_SUCCESS;
}
profile = listener->profile;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.config_res));
- message->type = CONFIG_STAT_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.config_res);
+ skinny_create_message(message, CONFIG_STAT_RES_MESSAGE, config_res);
if ((sql = switch_mprintf(
"SELECT name, user_id, instance, '' AS user_name, '' AS server_name, "
skinny_execute_sql_callback(profile, profile->sql_mutex, sql, skinny_config_stat_res_callback, message);
switch_safe_free(sql);
}
- skinny_send_reply(listener, message);
+ skinny_send_reply(listener, message, SWITCH_TRUE);
return SWITCH_STATUS_SUCCESS;
}
profile = listener->profile;
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.button_template));
- message->type = BUTTON_TEMPLATE_RES_MESSAGE;
- message->length = 4 + sizeof(message->data.button_template);
+ skinny_create_message(message, BUTTON_TEMPLATE_RES_MESSAGE, button_template);
message->data.button_template.button_offset = 0;
message->data.button_template.button_count = 0;
}
}
-
-
- return skinny_send_reply(listener, message);;
+ return skinny_send_reply(listener, message, SWITCH_TRUE);
}
switch_status_t skinny_handle_version_request(listener_t *listener, skinny_message_t *request)
skinny_log_l(listener, SWITCH_LOG_DEBUG, "Handle Soft Key Set Request with Set (%s)\n", "default");
}
if (message) {
- skinny_send_reply(listener, message);
+ skinny_send_reply_quiet(listener, message, SWITCH_FALSE);
} else {
skinny_log_l(listener, SWITCH_LOG_ERROR, "Profile %s doesn't have a default <soft-key-set-set>.\n",
listener->profile->name);
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);
+ skinny_create_message(message, UNREGISTER_ACK_MESSAGE, unregister_ack);
+
message->data.unregister_ack.unregister_status = 0; /* OK */
skinny_log_l(listener, SWITCH_LOG_DEBUG, "Handle Unregister with Status (%d)\n", message->data.unregister_ack.unregister_status);
- skinny_send_reply_quiet(listener, message);
+ skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
/* Close socket */
switch_clear_flag_locked(listener, LFLAG_RUNNING);
switch_assert(listener->profile);
switch_assert(listener->device_name);
- 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);
+ skinny_create_message(message, SOFT_KEY_TEMPLATE_RES_MESSAGE, soft_key_template);
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;
- memset(message->data.soft_key_template.soft_key, 0, sizeof(message->data.soft_key_template));
- for (i=0; i< TEXT_ID_LEN; i++) {
+ for (i=0; i < sizeof(soft_key_template_default_textids)/4; i++) {
char *label = skinny_textid2raw(soft_key_template_default_textids[i]);
- strcpy(message->data.soft_key_template.soft_key[i].soft_key_label, skinny_textid2raw(soft_key_template_default_textids[i]));
+ strncpy(message->data.soft_key_template.soft_key[i].soft_key_label, label, sizeof(message->data.soft_key_template.soft_key[i].soft_key_label));
switch_safe_free(label);
message->data.soft_key_template.soft_key[i].soft_key_event = soft_key_template_default_events[i];
skinny_log_l_msg(listener, SWITCH_LOG_DEBUG, "Handle Soft Key Template Request with Default Template\n");
- skinny_send_reply_quiet(listener, message);
+ skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
return SWITCH_STATUS_SUCCESS;
}
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Call-Id", "%d", request->data.data.call_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Transaction-Id", "%d", request->data.data.transaction_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Data-Length", "%d", request->data.data.data_length);
- /* Ensure that the body is null-terminated */
+
tmp = malloc(request->data.data.data_length + 1);
memcpy(tmp, request->data.data.data, request->data.data.data_length);
+
+ /* Ensure that the body is null-terminated */
tmp[request->data.data.data_length] = '\0';
switch_event_add_body(event, "%s", tmp);
+
switch_safe_free(tmp);
+
switch_event_fire(&event);
return SWITCH_STATUS_SUCCESS;
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_create_message(message, SERVICE_URL_STAT_RES_MESSAGE, 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);
+ skinny_send_reply(listener, message, SWITCH_TRUE);
return SWITCH_STATUS_SUCCESS;
}
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_create_message(message, FEATURE_STAT_RES_MESSAGE, 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);
+ skinny_send_reply(listener, message, SWITCH_TRUE);
return SWITCH_STATUS_SUCCESS;
}
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Conference-Id", "%d", request->data.extended_data.conference_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-App-Instance-Id", "%d", request->data.extended_data.app_instance_id);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Routing-Id", "%d", request->data.extended_data.routing_id);
- /* Ensure that the body is null-terminated */
+
tmp = malloc(request->data.data.data_length + 1);
memcpy(tmp, request->data.data.data, request->data.data.data_length);
+
+ /* Ensure that the body is null-terminated */
tmp[request->data.data.data_length] = '\0';
switch_event_add_body(event, "%s", tmp);
+
switch_safe_free(tmp);
switch_event_fire(&event);
return SWITCH_STATUS_SUCCESS;
}
+
switch_status_t skinny_handle_dialed_phone_book_message(listener_t *listener, skinny_message_t *request)
{
skinny_message_t *message;
skinny_check_data_length(request, sizeof(request->data.dialed_phone_book));
- message = switch_core_alloc(listener->pool, 12+sizeof(message->data.dialed_phone_book_ack));
- message->type = DIALED_PHONE_BOOK_ACK_MESSAGE;
- message->length = 4 + sizeof(message->data.dialed_phone_book_ack);
+ skinny_create_message(message, DIALED_PHONE_BOOK_ACK_MESSAGE, dialed_phone_book_ack);
+
message->data.dialed_phone_book_ack.number_index = request->data.dialed_phone_book.number_index;
message->data.dialed_phone_book_ack.line_instance = request->data.dialed_phone_book.line_instance;
message->data.dialed_phone_book_ack.unknown = request->data.dialed_phone_book.unknown;
message->data.dialed_phone_book_ack.unknown2 = 0;
+#if 0
+ /* Not sure why this isn't being sent at this point, need to investigate */
+ skinny_log_l_ffl(listener, file, func, line, SWITCH_LOG_DEBUG,
+ "Sending Handle Dialed Phone Book Ack Message with Number Index (%d), Line Instance (%d)\n",
+ request->data.dialed_phone_book.number_index, request->data.dialed_phone_book.line_instance);
+
+ return skinny_send_reply_quiet(listener, message, SWITCH_TRUE);
+#else
+ switch_safe_free(message);
return SWITCH_STATUS_SUCCESS;
+#endif
}
+
switch_status_t skinny_handle_accessory_status_message(listener_t *listener, skinny_message_t *request)
{
char *sql;
projects / thirdparty / freeswitch.git / commitdiff
