static void
dp_int_message (line_t line, callid_t call_id, char digit,
char *digit_str, boolean collect_more, void *tmr_data,
int msg_id, char *g_call_id, monitor_mode_t monitor_mode)
{
char fname[] = "dp_int_message";
dp_int_t *pmsg;
pmsg = (dp_int_t *) cc_get_msg_buf(sizeof(dp_int_t));
if (!pmsg) {
err_msg(get_debug_string(CC_NO_MSG_BUFFER), fname);
return;
}
pmsg->line = line;
pmsg->call_id = call_id;
pmsg->digit = digit;
if (digit_str) {
sstrncpy(pmsg->digit_str, digit_str, MAX_DIALSTRING);
}
pmsg->collect_more = collect_more;
pmsg->tmr_ptr = tmr_data;
if (digit_str) {
sstrncpy(pmsg->global_call_id, g_call_id, CC_GCID_LEN);
}
pmsg->monitor_mode = monitor_mode;
if (gsm_send_msg(msg_id, (cprBuffer_t) pmsg, sizeof(dp_int_t)) !=
CPR_SUCCESS) {
err_msg(get_debug_string(CC_SEND_FAILURE), fname);
}
}
int
sip_platform_udp_channel_send (cpr_socket_t s, char *buf, uint16_t len)
{
static const char *fname = "sip_platform_udp_channel_send";
ssize_t bytesSent;
/*
* Check not exceeding max allowed payload size
*/
if (len >= PKTBUF_SIZ) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_UDP_PAYLOAD_TOO_LARGE),
fname, len, PKTBUF_SIZ);
return SIP_ERROR;
}
while (len > 0) {
bytesSent = sipSocketSend(s, (void *)buf, (size_t)len, 0, FALSE);
if (bytesSent == SOCKET_ERROR) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_GENERAL_SYSTEMCALL_FAILED),
fname, "cprSend", cpr_errno);
return SIP_ERROR;
}
len -= bytesSent;
buf += bytesSent;
}
return SIP_OK;
}
int
sip_platform_udp_channel_sendto (cpr_socket_t s, char *buf, uint32_t len,
cpr_ip_addr_t *dst_ipaddr, uint16_t dst_port)
{
static const char *fname = "sip_platform_udp_channel_sendto";
ssize_t bytesSent;
cpr_sockaddr_storage sock_addr;
uint16_t addr_len;
cpr_ip_addr_t dest_ip_addr;
/*
* Connect to remote address
*/
dest_ip_addr = *dst_ipaddr;
(void) sip_set_sockaddr(&sock_addr, af_family_connect, dest_ip_addr,
dst_port, &addr_len);
/*
* Check not exceeding max allowed payload size
*/
if (len >= PKTBUF_SIZ) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_UDP_PAYLOAD_TOO_LARGE),
fname, len, PKTBUF_SIZ);
return SIP_ERROR;
}
while (len > 0) {
bytesSent = cprSendTo(s, (void *)buf, (size_t)len, 0,
(cpr_sockaddr_t *)&sock_addr, addr_len);
if ((bytesSent == SOCKET_ERROR) && (cpr_errno == CPR_ECONNREFUSED)) {
/*
* Will get socket error ECONNREFUSED after an ICMP message
* resend the message
*/
CCSIP_DEBUG_TASK(DEB_F_PREFIX"UDP send to error %d\n", DEB_F_PREFIX_ARGS(SIP_SOCK, fname), cpr_errno);
bytesSent = cprSendTo(s, (void *)buf, (size_t)len, 0,
(cpr_sockaddr_t *)&sock_addr, addr_len);
}
if (bytesSent == SOCKET_ERROR) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_GENERAL_SYSTEMCALL_FAILED),
fname, "cprSendTo", cpr_errno);
return SIP_ERROR;
}
len -= bytesSent;
buf += bytesSent;
}
return SIP_OK;
}
void
fsm_sm_ignore_ftr (fsm_fcb_t *fcb, int fname, cc_features_t ftr_id)
{
FSM_DEBUG_SM(get_debug_string(FSM_DBG_IGNORE_FTR),
fsm_type_name(fcb->fsm_type), fcb->call_id, fname,
cc_feature_name(ftr_id));
}
void
fsm_sm_ignore_src (fsm_fcb_t *fcb, int fname, cc_srcs_t src_id)
{
FSM_DEBUG_SM(get_debug_string(FSM_DBG_IGNORE_SRC),
fsm_type_name(fcb->fsm_type), fcb->call_id, fname,
cc_src_name(src_id));
}
/*
* DESCRIPTION: return the fcb referenced by the given call_id and type
*
* PARAMETERS: fsm_id
*
* @return void
* !NULL: fcb found
* NULL: fcb not found
*
*/
void
fsm_get_fcb_by_selected_or_connected_call_fcb (callid_t call_id, fsm_fcb_t **con_fcb_found,
fsm_fcb_t **sel_fcb_found)
{
static const char fname[] = "fsm_get_fcb_by_selected_or_connected_call_fcb";
fsm_fcb_t *fcb;
*con_fcb_found = NULL;
*sel_fcb_found = NULL;
FSM_FOR_ALL_CBS(fcb, fsm_fcbs, FSM_MAX_FCBS) {
if (fcb->call_id == call_id) {
/* Do not count current call_id */
continue;
}
if (fcb->fsm_type == FSM_TYPE_DEF &&
(fcb->state == FSMDEF_S_CONNECTED ||
fcb->state == FSMDEF_S_CONNECTED_MEDIA_PEND ||
fcb->state == FSMDEF_S_OUTGOING_ALERTING)) {
*con_fcb_found = fcb;
} else if (fcb->fsm_type == FSM_TYPE_DEF && fcb->dcb->selected) {
*sel_fcb_found = fcb;
break;
}
}
FSM_DEBUG_SM(get_debug_string(GSM_DBG_PTR), "FSM", call_id,
fname, "fcb", con_fcb_found);
}
/********************************************************
*
* Local Expires timer support functions for SIP SM
*
********************************************************/
int
sip_platform_localexpires_timer_start (uint32_t msec,
int idx,
cpr_ip_addr_t *ipaddr,
uint16_t port)
{
static const char fname[] = "sip_platform_localexpires_timer_start";
if (sip_platform_localexpires_timer_stop(idx) == SIP_ERROR) {
return SIP_ERROR;
}
sipPlatformUISMLocalExpiresTimers[idx].ipaddr = *ipaddr;
sipPlatformUISMLocalExpiresTimers[idx].port = port;
//sip_platform_localexpires_timer_callback
if (cprStartTimer(sipPlatformUISMLocalExpiresTimers[idx].timer, msec,
(void *)(long) idx) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
idx, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
return SIP_OK;
}
/********************************************************
*
* Message timer support functions for SIP SM
*
********************************************************/
void
sip_platform_msg_timers_init (void)
{
static const char fname[] = "sip_platform_msg_timers_init";
static long timer_init_complete = 0;
int i;
cprTimer_t timer, reg_timer;
for (i = 0; i < MAX_CCBS; i++) {
if (timer_init_complete) {
if ((cprCancelTimer(sipPlatformUISMTimers[i].timer)
== CPR_FAILURE) ||
(cprCancelTimer(sipPlatformUISMTimers[i].reg_timer)
== CPR_FAILURE)) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_GENERAL_FUNCTIONCALL_FAILED),
fname, "cprCancelTimer");
}
}
timer = sipPlatformUISMTimers[i].timer;
reg_timer = sipPlatformUISMTimers[i].reg_timer;
if (sipPlatformUISMTimers[i].message_buffer != NULL) {
cpr_free(sipPlatformUISMTimers[i].message_buffer);
sipPlatformUISMTimers[i].message_buffer = NULL;
sipPlatformUISMTimers[i].message_buffer_len = 0;
}
memset(&sipPlatformUISMTimers[i], 0, sizeof(sipPlatformUITimer_t));
sipPlatformUISMTimers[i].timer = timer;
sipPlatformUISMTimers[i].reg_timer = reg_timer;
}
timer_init_complete = 1;
return;
}
const char *
fsm_type_name (fsm_types_t type)
{
if ((type <= FSM_TYPE_MIN) || (type >= FSM_TYPE_MAX)) {
return (get_debug_string(GSM_UNDEFINED));
}
return (fsm_type_names[type]);
}
const char *
fsmb2bcnf_state_name (int state)
{
if ((state <= FSMB2BCNF_S_MIN) || (state >= FSMB2BCNF_S_MAX)) {
return (get_debug_string(GSM_UNDEFINED));
}
return (fsmb2bcnf_state_names[state]);
}
void
sip_platform_msg_timer_stop (int idx)
{
static const char fname[] = "sip_platform_msg_timer_stop";
if ((idx < MIN_TEL_LINES) || (idx >= MAX_CCBS)) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_LINE_NUMBER_INVALID),
fname, idx);
return;
}
if ((cprCancelTimer(sipPlatformUISMTimers[idx].timer) == CPR_FAILURE) ||
(cprCancelTimer(sipPlatformUISMTimers[idx].reg_timer) == CPR_FAILURE)) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
idx, 0, fname, "cprCancelTimer");
return;
}
sipPlatformUISMTimers[idx].outstanding = FALSE;
}
int
sip_platform_supervision_disconnect_timer_stop (int idx)
{
static const char fname[] = "sip_platform_supervision_disconnect_timer_stop";
if ((idx < TEL_CCB_START) || (idx > TEL_CCB_END)) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_LINE_NUMBER_INVALID), fname, idx);
return SIP_ERROR;
}
if (cprCancelTimer(sipPlatformSupervisionTimers[idx].timer)
== CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
idx, 0, fname, "cprCancelTimer");
return SIP_ERROR;
}
return SIP_OK;
}
int
sip_platform_localexpires_timer_stop (int idx)
{
static const char fname[] = "sip_platform_localexpires_timer_stop";
if ((idx < MIN_TEL_LINES) || (idx >= MAX_CCBS)) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_LINE_NUMBER_INVALID),
fname, idx);
return SIP_ERROR;
}
if (cprCancelTimer(sipPlatformUISMLocalExpiresTimers[idx].timer)
== CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
idx, 0, fname, "cprCancelTimer");
return SIP_ERROR;
}
return SIP_OK;
}
/**
** sip_platform_reg_all_fail_timer_stop
* Stops the Reg-All Fail timer
*
* @param none
*
* @return SIP_OK if timer could be stopped; else SIP_ERROR
*
*/
int
sip_platform_reg_all_fail_timer_stop (void)
{
static const char fname[] = "sip_platform_reg_all_fail_timer_stop";
if (cprCancelTimer(sipPlatformRegAllFailedTimer) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
0, 0, fname, "cprCancelTimer");
return SIP_ERROR;
}
return SIP_OK;
}
int
sip_platform_notify_timer_stop ()
{
static const char fname[] = "sip_platform_notify_timer_stop";
if (cprCancelTimer(sipPlatformNotifyTimer) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
0, 0, fname, "cprCancelTimer");
return SIP_ERROR;
}
return SIP_OK;
}
/**
** sip_platform_pass_through_timer_stop
* Stops the Pass Through timer
*
* @param none
*
* @return SIP_OK if timer could be stopped; else SIP_ERROR
*
*/
int
sip_platform_pass_through_timer_stop (void)
{
static const char fname[] = "sip_platform_pass_through_timer_stop";
if (cprCancelTimer(sipPassThroughTimer) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
0, 0, fname, "cprCancelTimer");
return SIP_ERROR;
}
return SIP_OK;
}
int
sip_platform_msg_timer_subnot_start (uint32_t msec,
sipPlatformUITimer_t *timer_p,
uint32_t id,
char *message_buffer,
int message_buffer_len,
int message_type,
cpr_ip_addr_t *ipaddr,
uint16_t port)
{
static const char fname[] = "sip_platform_msg_timer_start_subnot";
sip_platform_msg_timer_subnot_stop(timer_p);
if (message_buffer_len > SIP_UDP_MESSAGE_SIZE) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_MSG_BUFFER_TOO_BIG),
fname, message_buffer_len);
return SIP_ERROR;
}
if (timer_p->message_buffer == NULL) {
timer_p->message_buffer = (char *)cpr_malloc(message_buffer_len+1);
if (timer_p->message_buffer == NULL) return SIP_ERROR;
}
else if (timer_p->message_buffer != message_buffer) {
cpr_free(timer_p->message_buffer);
timer_p->message_buffer = (char *)cpr_malloc(message_buffer_len+1);
if (timer_p->message_buffer == NULL) return SIP_ERROR;
}
timer_p->message_buffer_len = message_buffer_len;
timer_p->message_buffer[message_buffer_len] = '\0';
memcpy(timer_p->message_buffer, message_buffer,
message_buffer_len);
timer_p->message_type =
(sipMethod_t) message_type;
timer_p->ipaddr = *ipaddr;
timer_p->port = port;
if (cprStartTimer(timer_p->timer, msec, (void *)(long)id) == CPR_FAILURE) {
CCSIP_DEBUG_ERROR(SIP_F_PREFIX "%s failed\n",
fname, "cprStartTimer");
cpr_free(timer_p->message_buffer);
timer_p->message_buffer = NULL;
timer_p->message_buffer_len = 0;
return SIP_ERROR;
}
return SIP_OK;
}
int
sip_platform_udp_channel_read (cpr_socket_t s,
cprBuffer_t buf,
uint16_t *len,
cpr_sockaddr_t *soc_addr,
cpr_socklen_t *soc_addr_len)
{
static const char *fname = "sip_platform_udp_channel_read";
int bytes_read;
// NOT USED: cpr_sockaddr_in_t *addr = (cpr_sockaddr_in_t *)soc_addr;
bytes_read = cprRecvFrom(s, buf, CPR_MAX_MSG_SIZE, 0, soc_addr,
soc_addr_len);
switch (bytes_read) {
case SOCKET_ERROR:
/*
* If no data is available to read (CPR_EWOULDBLOCK),
* for non-blocking socket, it is not an error.
*/
cpr_free(buf);
*len = 0;
if (cpr_errno != CPR_EWOULDBLOCK) {
CCSIP_DEBUG_ERROR(SIP_F_PREFIX"fd[%d]\n", fname, s);
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_GENERAL_SYSTEMCALL_FAILED),
fname, "cprRecvFrom", cpr_errno);
return SIP_ERROR;
}
/*
* Will continue reading when data arrives at socket
*/
break;
case 0:
/*
* Return value 0 is OK. This does NOT mean the connection
* has closed by the peer, as with TCP sockets. With UDP
* sockets, there is no such thing as closing a connection.
*/
CCSIP_DEBUG_MESSAGE(DEB_F_PREFIX"No data on fd %d\n", DEB_F_PREFIX_ARGS(SIP_SDP, fname), s);
cpr_free(buf);
*len = 0;
break;
default:
/* PKT has been read */
CCSIP_DEBUG_MESSAGE(DEB_F_PREFIX"Recvd on fd %d\n", DEB_F_PREFIX_ARGS(SIP_SDP, fname), s);
*len = (uint16_t) bytes_read;
break;
}
return SIP_OK;
}
int
sip_platform_udp_channel_destroy (cpr_socket_t s)
{
static const char fname[] = "sip_platform_udp_channel_destroy";
if (s != INVALID_SOCKET) {
if (sipSocketClose(s, FALSE) == CPR_FAILURE) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_GENERAL_SYSTEMCALL_FAILED),
fname, "sipSocketClose", cpr_errno);
return SIP_ERROR;
}
}
return SIP_OK;
}
int
sip_platform_subnot_periodic_timer_stop (void)
{
static const char fname[] = "sip_platform_subnot_periodic_timer_stop";
if (sipPlatformSubNotPeriodicTimer.started == TRUE) {
if (cprCancelTimer(sipPlatformSubNotPeriodicTimer.timer)
== CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
-1, 0, fname, "cprCancelTimer");
return SIP_ERROR;
}
}
sipPlatformSubNotPeriodicTimer.started = FALSE;
return SIP_OK;
}
/***********************************************
* PassThrough Timer
***********************************************
** sip_platform_pass_through_timer_start
* Starts a timer when all registrations fail.
*
* @param sec Value of the timer to be started
*
* @return SIP_OK if timer could be started; else SIP_ERROR
*
*/
int
sip_platform_pass_through_timer_start (uint32_t sec)
{
static const char fname[] = "sip_platform_pass_through_timer_start";
if (sip_platform_pass_through_timer_stop() == SIP_ERROR) {
return SIP_ERROR;
}
if (cprStartTimer(sipPassThroughTimer, sec*1000, NULL) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
0, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
CCSIP_DEBUG_REG_STATE("%s: Regmgr Pass Through Timer started for %lu secs\n", fname, sec);
return SIP_OK;
}
/*
* Call disconnect timer
*/
int
sip_platform_supervision_disconnect_timer_start (uint32_t msec, int idx)
{
static const char fname[] = "sip_platform_supervision_disconnect_timer_start";
if (sip_platform_supervision_disconnect_timer_stop(idx) == SIP_ERROR) {
return SIP_ERROR;
}
if (cprStartTimer(sipPlatformSupervisionTimers[idx].timer, msec,
(void *)(long) idx) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
idx, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
return SIP_OK;
}
int
sip_platform_notify_timer_start (uint32_t msec)
{
static const char fname[] = "sip_platform_notify_timer_start";
if (sip_platform_notify_timer_stop() == SIP_ERROR) {
return SIP_ERROR;
}
if (cprStartTimer(sipPlatformNotifyTimer, msec, NULL) == CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
0, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
CCSIP_DEBUG_STATE(DEB_F_PREFIX
"Timer started for %lu msecs\n", DEB_F_PREFIX_ARGS(SIP_TIMER, fname), msec);
return SIP_OK;
}
int
sip_platform_register_expires_timer_start (uint32_t msec, int idx)
{
static const char fname[] = "sip_platform_register_expires_timer_start";
if (sip_platform_register_expires_timer_stop(idx) == SIP_ERROR) {
return SIP_ERROR;
}
if (cprStartTimer(sipPlatformUISMRegExpiresTimers[idx].timer, msec,
(void *)(long) idx) == CPR_FAILURE) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
idx, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
return SIP_OK;
}
int
sip_platform_subnot_periodic_timer_start (uint32_t msec)
{
static const char fname[] = "sip_platform_subnot_periodic_timer_start";
if (sip_platform_subnot_periodic_timer_stop() == SIP_ERROR) {
return SIP_ERROR;
}
if (cprStartTimer(sipPlatformSubNotPeriodicTimer.timer, msec, (void *) 0)
== CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
-1, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
sipPlatformSubNotPeriodicTimer.started = TRUE;
return SIP_OK;
}
int
sip_platform_unregistration_timer_start (uint32_t msec, boolean external)
{
static const char fname[] = "sip_platform_unregistration_timer_start";
if (sip_platform_unregistration_timer_stop() == SIP_ERROR) {
return SIP_ERROR;
}
if (cprStartTimer(sipPlatformUnRegistrationTimer, msec, (void *)(long)external)
== CPR_FAILURE) {
CCSIP_DEBUG_STATE(get_debug_string(DEBUG_SIP_FUNCTIONCALL_FAILED),
0, 0, fname, "cprStartTimer");
return SIP_ERROR;
}
CCSIP_DEBUG_STATE(DEB_F_PREFIX
"Timer started for %lu msecs\n", DEB_F_PREFIX_ARGS(SIP_TIMER, fname), msec);
return SIP_OK;
}
/*
* ROUTINE: fsm_get_fcb_by_call_id
*
* DESCRIPTION: return the fcb referenced by the given call_id
*
* PARAMETERS: fsm_id
*
* RETURNS: fcb
* !NULL: fcb found
* NULL: fcb not found
*
* NOTES:
*/
fsm_fcb_t *
fsm_get_fcb_by_call_id (callid_t call_id)
{
static const char fname[] = "fsm_get_fcb_by_call_id";
fsm_fcb_t *fcb;
fsm_fcb_t *fcb_found = NULL;
FSM_FOR_ALL_CBS(fcb, fsm_fcbs, FSM_MAX_FCBS) {
if (fcb->call_id == call_id) {
fcb_found = fcb;
break;
}
}
FSM_DEBUG_SM(get_debug_string(GSM_DBG_PTR), "FSM", call_id,
fname, "fcb", fcb_found);
return (fcb_found);
}
/*
* ROUTINE: fsm_get_new_fcb
*
* DESCRIPTION: return a new fcb initialized with the given data
*
* PARAMETERS:
* call_id: call_id
* type: feature type
*
* RETURNS:
* fcb: the new fcb
*/
fsm_fcb_t *
fsm_get_new_fcb (callid_t call_id, fsm_types_t fsm_type)
{
static const char fname[] = "fsm_get_new_fcb";
fsm_fcb_t *fcb;
/*
* Get free fcb by using CC_NO_CALL_ID as the call_id because a free fcb
* will have a call_id of CC_NO_CALL_ID.
*/
fcb = fsm_get_fcb_by_call_id(CC_NO_CALL_ID);
if (fcb != NULL) {
fsm_init_fcb(fcb, call_id, FSMDEF_NO_DCB, fsm_type);
}
FSM_DEBUG_SM(get_debug_string(GSM_DBG_PTR), "FSM", call_id,
fname, "fcb", fcb);
return (fcb);
}
void
sip_platform_post_timer (uint32_t cmd, void *data)
{
static const char fname[] = "sip_platform_post_timer";
uint32_t *timer_msg = NULL;
/* grab msg buffer */
timer_msg = (uint32_t *) SIPTaskGetBuffer(sizeof(uint32_t));
if (!timer_msg) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_SYSBUF_UNAVAILABLE), fname);
return;
}
*timer_msg = (long) data;
/* Put it on the SIP message queue */
if (SIPTaskSendMsg(cmd, (cprBuffer_t) timer_msg, sizeof(uint32_t), NULL)
== CPR_FAILURE) {
cpr_free(timer_msg);
CCSIP_DEBUG_ERROR(SIP_F_PREFIX "Send msg failed.\n", fname);
}
return;
}
int
sip_platform_msg_timer_update_destination (int idx,
cpr_ip_addr_t *ipaddr,
uint16_t port)
{
static const char fname[] = "sip_platform_msg_timer_update_destination";
if ((idx < TEL_CCB_START) || (idx > REG_BACKUP_CCB)) {
CCSIP_DEBUG_ERROR(get_debug_string(DEBUG_LINE_NUMBER_INVALID),
fname, idx);
return SIP_ERROR;
}
if (ipaddr == NULL) {
sipPlatformUISMExpiresTimers[idx].ipaddr = ip_addr_invalid;
} else {
sipPlatformUISMTimers[idx].ipaddr = *ipaddr;
}
sipPlatformUISMTimers[idx].port = port;
return SIP_OK;
}
