kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-02-05 02:34:18 +00:00
Code Issues Projects Releases Wiki Activity

merged 956:1023 (partial merge - boost related stuff)

Browse Source 
git-svn-id: http://svn.openzap.org/svn/openzap/branches/sangoma_boost@1028 a93c3328-9c30-0410-af19-c9cd2b2d52af
This commit is contained in:
Moises Silva 2010-02-11 20:51:00 +00:00
parent 0d392527dc
commit 2858411559
6 changed files with 191 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/freetdm/src/ftdm_io.c
View File

@ -977,7 +977,7 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(ftdm_channel_t *ftdmchan, ftdm_
} }
if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
ftdm_log(FTDM_LOG_WARNING, "Ignored state change request from %s to %s, the previous state change has not been processed yet\n", ftdm_log(FTDM_LOG_CRIT, "Ignored state change request from %s to %s, the previous state change has not been processed yet\n",
ftdm_channel_state2str(ftdmchan->state), ftdm_channel_state2str(state)); ftdm_channel_state2str(ftdmchan->state), ftdm_channel_state2str(state));
return FTDM_FAIL; return FTDM_FAIL;
} }

1
libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftdm_sangoma_boost.h
View File

@ -49,7 +49,6 @@ typedef struct ftdm_sangoma_boost_data {
fd_set rfds; fd_set rfds;
fd_set efds; fd_set efds;
int iteration; int iteration;
fio_signal_cb_t signal_cb;
uint32_t flags; uint32_t flags;
boost_sigmod_interface_t *sigmod; boost_sigmod_interface_t *sigmod;
ftdm_queue_t *boost_queue; ftdm_queue_t *boost_queue;

330
libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c
View File

@ -72,7 +72,10 @@ static ftdm_sangoma_boost_trunkgroup_t *g_trunkgroups[MAX_TRUNK_GROUPS];
typedef enum { typedef enum {
SFLAG_FREE_REQ_ID = (1 << 0), SFLAG_FREE_REQ_ID = (1 << 0),
SFLAG_SENT_FINAL_MSG = (1 << 1), SFLAG_SENT_FINAL_MSG = (1 << 1),
SFLAG_SENT_ACK = (1 << 2) SFLAG_SENT_ACK = (1 << 2),
SFLAG_RECVD_ACK = (1 << 3),
SFLAG_HANGUP = (1 << 4),
SFLAG_TERMINATING = (1 << 5)
} sflag_t; } sflag_t;
typedef uint16_t sangoma_boost_request_id_t; typedef uint16_t sangoma_boost_request_id_t;
@ -96,6 +99,8 @@ typedef struct {
sangomabc_short_event_t event; sangomabc_short_event_t event;
ftdm_span_t *span; ftdm_span_t *span;
ftdm_channel_t *ftdmchan; ftdm_channel_t *ftdmchan;
int hangup_cause;
int flags;
} sangoma_boost_request_t; } sangoma_boost_request_t;
//#define MAX_REQ_ID FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN * FTDM_MAX_CHANNELS_PHYSICAL_SPAN //#define MAX_REQ_ID FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN * FTDM_MAX_CHANNELS_PHYSICAL_SPAN
@ -252,30 +257,6 @@ static int check_congestion(int trunk_group)
return 0; return 0;
} }
/**
* \brief determines whether media is ready
* \param event boost event
* \return 1 true, 0 for false
*/
static int boost_media_ready(sangomabc_event_t *event)
{
/* FORMAT is of type: SMG003-EVI-1-MEDIA-# */
char* p = NULL;
p = strstr(event->isup_in_rdnis, "MEDIA");
if (p) {
int media_ready = 0;
if ((sscanf(p, "MEDIA-%d", &media_ready)) == 1) {
if (media_ready) {
return 1;
} else {
}
} else {
ftdm_log(FTDM_LOG_ERROR, "Invalid boost isup_rdnis MEDIA format %s\n", p);
}
}
return 0;
}
/** /**
* \brief Requests an sangoma boost channel on a span (outgoing call) * \brief Requests an sangoma boost channel on a span (outgoing call)
@ -400,38 +381,14 @@ static FIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request)
if (!sangoma_boost_data->sigmod) { if (!sangoma_boost_data->sigmod) {
*ftdmchan = NULL; *ftdmchan = NULL;
} }
ftdm_log(FTDM_LOG_CRIT, "Timed out waiting for boost channel request response, current status: BST_WAITING\n");
ftdm_log(FTDM_LOG_CRIT, "s%dc%d: Csid:%d Timed out waiting for boost channel request response, current status: BST_WAITING\n", (*ftdmchan)->physical_span_id, (*ftdmchan)->physical_chan_id, r); ftdm_log(FTDM_LOG_CRIT, "s%dc%d: Csid:%d Timed out waiting for boost channel request response, current status: BST_WAITING\n", (*ftdmchan)->physical_span_id, (*ftdmchan)->physical_chan_id, r);
goto done; goto done;
} }
} }
if (OUTBOUND_REQUESTS[r].status == BST_ACK && OUTBOUND_REQUESTS[r].ftdmchan) {
*ftdmchan = OUTBOUND_REQUESTS[r].ftdmchan;
status = FTDM_SUCCESS;
(*ftdmchan)->init_state = FTDM_CHANNEL_STATE_PROGRESS;
ftdm_log(FTDM_LOG_DEBUG, "Channel state changed to PROGRESS [Csid:%d]\n", r);
}
boost_request_timeout = 5000;
while(ftdm_running() && OUTBOUND_REQUESTS[r].status == BST_ACK) {
ftdm_sleep(1);
if (--boost_request_timeout <= 0) {
status = FTDM_FAIL;
if (!sangoma_boost_data->sigmod) {
*ftdmchan = NULL;
}
ftdm_log(FTDM_LOG_CRIT, "Timed out waiting for boost channel request response, current status: BST_ACK\n");
goto done;
}
//printf("WTF %d\n", sanity);
}
if (OUTBOUND_REQUESTS[r].status == BST_READY && OUTBOUND_REQUESTS[r].ftdmchan) { if (OUTBOUND_REQUESTS[r].status == BST_READY && OUTBOUND_REQUESTS[r].ftdmchan) {
*ftdmchan = OUTBOUND_REQUESTS[r].ftdmchan; *ftdmchan = OUTBOUND_REQUESTS[r].ftdmchan;
status = FTDM_SUCCESS; status = FTDM_SUCCESS;
(*ftdmchan)->init_state = FTDM_CHANNEL_STATE_PROGRESS_MEDIA;
ftdm_log(FTDM_LOG_DEBUG, "Channel state changed to PROGRESS_MEDIA [Csid:%d]\n", r);
} else { } else {
status = FTDM_FAIL; status = FTDM_FAIL;
if (!sangoma_boost_data->sigmod) { if (!sangoma_boost_data->sigmod) {
@ -444,10 +401,18 @@ static FIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request)
st = OUTBOUND_REQUESTS[r].status; st = OUTBOUND_REQUESTS[r].status;
OUTBOUND_REQUESTS[r].status = BST_FREE; OUTBOUND_REQUESTS[r].status = BST_FREE;
if (status == FTDM_FAIL) {
if (st == BST_FAIL) {
caller_data->hangup_cause = OUTBOUND_REQUESTS[r].hangup_cause;
} else {
caller_data->hangup_cause = FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
}
}
if (st == BST_FAIL) { if (st == BST_FAIL) {
release_request_id(r); release_request_id(r);
} else if (st != BST_READY) { } else if (st != BST_READY) {
assert(r <= MAX_REQ_ID); ftdm_assert_return(r <= MAX_REQ_ID, FTDM_FAIL, "Invalid index\n");
nack_map[r] = 1; nack_map[r] = 1;
if (sangoma_boost_data->sigmod) { if (sangoma_boost_data->sigmod) {
sangomabc_exec_command(&sangoma_boost_data->mcon, sangomabc_exec_command(&sangoma_boost_data->mcon,
@ -455,14 +420,14 @@ static FIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request)
BOOST_CHAN((*ftdmchan)), BOOST_CHAN((*ftdmchan)),
r, r,
SIGBOOST_EVENT_CALL_START_NACK, SIGBOOST_EVENT_CALL_START_NACK,
0); 0, 0);
} else { } else {
sangomabc_exec_command(&sangoma_boost_data->mcon, sangomabc_exec_command(&sangoma_boost_data->mcon,
0, 0,
0, 0,
r, r,
SIGBOOST_EVENT_CALL_START_NACK, SIGBOOST_EVENT_CALL_START_NACK,
0); 0, 0);
} }
} }
@ -486,62 +451,35 @@ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(sangoma_boost_outgoing_call)
* \param mcon sangoma boost connection * \param mcon sangoma boost connection
* \param event Event to handle * \param event Event to handle
*/ */
static void handle_call_progress(sangomabc_connection_t *mcon, sangomabc_short_event_t *event) static void handle_call_progress(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event)
{ {
ftdm_channel_t *ftdmchan; ftdm_channel_t *ftdmchan;
if (nack_map[event->call_setup_id]) {
return;
}
//if we received a progress for this device already if ((ftdmchan = find_ftdmchan(span, event, 1))) {
if (OUTBOUND_REQUESTS[event->call_setup_id].status == BST_ACK) { ftdm_mutex_lock(ftdmchan->mutex);
if (boost_media_ready((sangomabc_event_t*) event)) { if (ftdmchan->state == FTDM_CHANNEL_STATE_HOLD) {
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY; if ((event->flags & SIGBOOST_PROGRESS_MEDIA)) {
ftdm_log(FTDM_LOG_DEBUG, "chan media ready %d:%d CSid:%d\n", event->span+1, event->chan+1, event->call_setup_id); ftdmchan->init_state = FTDM_CHANNEL_STATE_PROGRESS_MEDIA;
} ftdm_log(FTDM_LOG_DEBUG, "Channel init state updated to PROGRESS_MEDIA [Csid:%d]\n", event->call_setup_id);
return; } else if ((event->flags & SIGBOOST_PROGRESS_RING)) {
} ftdmchan->init_state = FTDM_CHANNEL_STATE_PROGRESS;
ftdm_log(FTDM_LOG_DEBUG, "Channel init state updated to PROGRESS [Csid:%d]\n", event->call_setup_id);
OUTBOUND_REQUESTS[event->call_setup_id].event = *event;
SETUP_GRID[event->span][event->chan] = event->call_setup_id;
if ((ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, (sangomabc_short_event_t*) event, 0))) {
if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error);
} else { } else {
ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); ftdmchan->init_state = FTDM_CHANNEL_STATE_IDLE;
ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INUSE); ftdm_log(FTDM_LOG_DEBUG, "Channel init state updated to IDLE [Csid:%d]\n", event->call_setup_id);
ftdmchan->extra_id = event->call_setup_id; }
ftdm_log(FTDM_LOG_DEBUG, "Assign chan %d:%d (%d:%d) CSid=%d\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id);
ftdmchan->sflags = 0;
OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan = ftdmchan;
if (boost_media_ready((sangomabc_event_t*)event)) {
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY;
} else { } else {
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_ACK; if ((event->flags & SIGBOOST_PROGRESS_MEDIA)) {
} ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
return; } else if ((event->flags & SIGBOOST_PROGRESS_RING)) {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS);
} else {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE);
} }
} }
ftdm_mutex_unlock(ftdmchan->mutex);
//printf("WTF BAD ACK CSid=%d span=%d chan=%d\n", event->call_setup_id, event->span+1,event->chan+1);
if ((ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 1))) {
//printf("WTF BAD ACK2 %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, ftdmchan->extra_id, ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), ftdm_channel_state2str(ftdmchan->state));
} }
ftdm_log(FTDM_LOG_CRIT, "START PROGRESS CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1);
if (ftdmchan) {
ftdm_set_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG);
}
sangomabc_exec_command(mcon,
event->span,
event->chan,
event->call_setup_id,
SIGBOOST_EVENT_CALL_STOPPED,
FTDM_CAUSE_DESTINATION_OUT_OF_ORDER);
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL;
} }
/** /**
@ -570,8 +508,6 @@ static void handle_call_start_ack(sangomabc_connection_t *mcon, sangomabc_short_
if (mcon->sigmod) { if (mcon->sigmod) {
ftdmchan = OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan; ftdmchan = OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan;
ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND);
ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INUSE);
} else { } else {
ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 0); ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 0);
} }
@ -581,20 +517,30 @@ static void handle_call_start_ack(sangomabc_connection_t *mcon, sangomabc_short_
if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error); ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error);
} else { } else {
ftdmchan->extra_id = event->call_setup_id; ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND);
ftdm_log(FTDM_LOG_DEBUG, "Assign chan %d:%d (%d:%d) CSid=%d\n", ftdmchan->span_id, ftdmchan->chan_id, event_span, event_chan, event->call_setup_id); ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INUSE);
ftdmchan->sflags = 0; ftdmchan->sflags = SFLAG_RECVD_ACK;
if ((event->flags & SIGBOOST_PROGRESS_MEDIA)) {
ftdmchan->init_state = FTDM_CHANNEL_STATE_PROGRESS_MEDIA;
ftdm_log(FTDM_LOG_DEBUG, "Channel init state changed to PROGRESS_MEDIA [Csid:%d]\n", event->call_setup_id);
} else if ((event->flags & SIGBOOST_PROGRESS_RING)) {
ftdmchan->init_state = FTDM_CHANNEL_STATE_PROGRESS;
ftdm_log(FTDM_LOG_DEBUG, "Channel init state changed to PROGRESS [Csid:%d]\n", event->call_setup_id);
} else {
ftdmchan->init_state = FTDM_CHANNEL_STATE_IDLE;
ftdm_log(FTDM_LOG_DEBUG, "Channel init state changed to IDLE [Csid:%d]\n", event->call_setup_id);
}
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HOLD);
OUTBOUND_REQUESTS[event->call_setup_id].flags = event->flags;
OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan = ftdmchan; OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan = ftdmchan;
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY; OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY;
ftdm_log(FTDM_LOG_DEBUG, "Assigned chan %d:%d (%d:%d) to CSid=%d\n",
ftdmchan->span_id, ftdmchan->chan_id, event_span, event_chan, event->call_setup_id);
return; return;
} }
} }
//printf("WTF BAD ACK CSid=%d span=%d chan=%d\n", event->call_setup_id, event->span+1,event->chan+1);
if ((ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 1))) {
//printf("WTF BAD ACK2 %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, ftdmchan->extra_id, ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), ftdm_channel_state2str(ftdmchan->state));
}
ftdm_set_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG); ftdm_set_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG);
ftdm_log(FTDM_LOG_CRIT, "START ACK CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); ftdm_log(FTDM_LOG_CRIT, "START ACK CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1);
sangomabc_exec_command(mcon, sangomabc_exec_command(mcon,
@ -602,8 +548,9 @@ static void handle_call_start_ack(sangomabc_connection_t *mcon, sangomabc_short_
event->chan, event->chan,
event->call_setup_id, event->call_setup_id,
SIGBOOST_EVENT_CALL_STOPPED, SIGBOOST_EVENT_CALL_STOPPED,
FTDM_CAUSE_DESTINATION_OUT_OF_ORDER); FTDM_CAUSE_DESTINATION_OUT_OF_ORDER, 0);
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL; OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL;
OUTBOUND_REQUESTS[event->call_setup_id].hangup_cause = FTDM_CAUSE_DESTINATION_OUT_OF_ORDER;
} }
/** /**
@ -629,10 +576,10 @@ static void handle_call_done(ftdm_span_t *span, sangomabc_connection_t *mcon, sa
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_RELEASED, SIGBOOST_EVENT_CALL_RELEASED,
0); 0, 0);
} }
if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN || ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP_COMPLETE) { if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN || ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP_COMPLETE || ftdm_test_sflag(ftdmchan, SFLAG_TERMINATING)) {
goto done; goto done;
} }
@ -695,22 +642,30 @@ static void handle_call_start_nack(ftdm_span_t *span, sangomabc_connection_t *mc
event->release_cause = 17; event->release_cause = 17;
} }
ftdm_log(FTDM_LOG_DEBUG, "setting event->call_setup_id:%d to BST_FAIL\n", event->call_setup_id); if (event->call_setup_id) {
OUTBOUND_REQUESTS[event->call_setup_id].event = *event; int span = 0;
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL; int chan = 0;
if (!sangoma_boost_data->sigmod) { if (sangoma_boost_data->sigmod) {
span = BOOST_SPAN(OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan);
chan = BOOST_CHAN(OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan);
}
sangomabc_exec_command(mcon, sangomabc_exec_command(mcon,
0, span,
0, chan,
event->call_setup_id, event->call_setup_id,
SIGBOOST_EVENT_CALL_START_NACK_ACK, SIGBOOST_EVENT_CALL_START_NACK_ACK,
0); 0, 0);
OUTBOUND_REQUESTS[event->call_setup_id].event = *event;
OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL;
OUTBOUND_REQUESTS[event->call_setup_id].hangup_cause = event->release_cause;
ftdm_log(FTDM_LOG_DEBUG, "setting outbound request status %d to BST_FAIL\n", event->call_setup_id);
return; return;
} else { } else {
if ((ftdmchan = find_ftdmchan(span, event, 1))) { if ((ftdmchan = find_ftdmchan(span, event, 1))) {
int r = 0; int r = 0;
assert(!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND));
/* if there is no call setup id this should not be an outbound channel for sure */
ftdm_assert(!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), "Yay, outbound flag should not be set here!\n");
ftdmchan->call_data = (void*)(intptr_t)event->event_id; ftdmchan->call_data = (void*)(intptr_t)event->event_id;
@ -726,7 +681,6 @@ static void handle_call_start_nack(ftdm_span_t *span, sangomabc_connection_t *mc
} }
} }
#if 0
if (ftdmchan) { if (ftdmchan) {
ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG);
} }
@ -737,8 +691,7 @@ static void handle_call_start_nack(ftdm_span_t *span, sangomabc_connection_t *mc
event->chan, event->chan,
0, 0,
SIGBOOST_EVENT_CALL_START_NACK_ACK, SIGBOOST_EVENT_CALL_START_NACK_ACK,
0); 0, 0);
#endif
} }
static void handle_call_released(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) static void handle_call_released(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event)
@ -768,7 +721,7 @@ static void handle_call_stop(ftdm_span_t *span, sangomabc_connection_t *mcon, sa
ftdm_mutex_lock(ftdmchan->mutex); ftdm_mutex_lock(ftdmchan->mutex);
if (ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP) { if (ftdm_test_sflag(ftdmchan, SFLAG_HANGUP)) {
/* racing condition where both sides initiated a hangup /* racing condition where both sides initiated a hangup
* Do not change current state as channel is already clearing * Do not change current state as channel is already clearing
* itself through local initiated hangup */ * itself through local initiated hangup */
@ -778,7 +731,14 @@ static void handle_call_stop(ftdm_span_t *span, sangomabc_connection_t *mcon, sa
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_STOPPED_ACK, SIGBOOST_EVENT_CALL_STOPPED_ACK,
0); 0, 0);
ftdm_mutex_unlock(ftdmchan->mutex);
return;
} else if (ftdmchan->state == FTDM_CHANNEL_STATE_HOLD) {
ftdmchan->init_state = FTDM_CHANNEL_STATE_TERMINATING;
ftdm_log(FTDM_LOG_DEBUG, "Channel init state updated to TERMINATING [Csid:%d]\n", event->call_setup_id);
OUTBOUND_REQUESTS[event->call_setup_id].hangup_cause = event->release_cause;
ftdmchan->caller_data.hangup_cause = event->release_cause;
ftdm_mutex_unlock(ftdmchan->mutex); ftdm_mutex_unlock(ftdmchan->mutex);
return; return;
} else { } else {
@ -794,6 +754,7 @@ static void handle_call_stop(ftdm_span_t *span, sangomabc_connection_t *mcon, sa
} }
ftdm_mutex_unlock(ftdmchan->mutex); ftdm_mutex_unlock(ftdmchan->mutex);
if (r) { if (r) {
return; return;
} }
@ -814,25 +775,22 @@ static void handle_call_answer(ftdm_span_t *span, sangomabc_connection_t *mcon,
ftdm_channel_t *ftdmchan; ftdm_channel_t *ftdmchan;
if ((ftdmchan = find_ftdmchan(span, event, 1))) { if ((ftdmchan = find_ftdmchan(span, event, 1))) {
int r = 0;
if (ftdmchan->extra_id == event->call_setup_id && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
ftdm_mutex_lock(ftdmchan->mutex); ftdm_mutex_lock(ftdmchan->mutex);
if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN && ftdmchan->init_state != FTDM_CHANNEL_STATE_UP) { if (ftdmchan->state == FTDM_CHANNEL_STATE_HOLD) {
ftdmchan->init_state = FTDM_CHANNEL_STATE_UP; ftdmchan->init_state = FTDM_CHANNEL_STATE_UP;
r = 1;
} else { } else {
int r = 0;
ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_UP, 0, r); ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_UP, 0, r);
} }
ftdm_mutex_unlock(ftdmchan->mutex); ftdm_mutex_unlock(ftdmchan->mutex);
}
#if 0
if (!r) {
printf("WTF BAD ANSWER %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, ftdmchan->extra_id, ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), ftdm_channel_state2str(ftdmchan->state));
}
#endif
} else { } else {
ftdm_log(FTDM_LOG_CRIT, "ANSWER CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); ftdm_log(FTDM_LOG_CRIT, "ANSWER CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1);
sangomabc_exec_command(mcon,
event->span,
event->chan,
event->call_setup_id,
SIGBOOST_EVENT_CALL_STOPPED,
FTDM_CAUSE_DESTINATION_OUT_OF_ORDER, 0);
} }
} }
@ -912,7 +870,7 @@ static void handle_call_start(ftdm_span_t *span, sangomabc_connection_t *mcon, s
event->chan, event->chan,
0, 0,
SIGBOOST_EVENT_CALL_START_NACK, SIGBOOST_EVENT_CALL_START_NACK,
0); 0, 0);
} }
@ -1015,7 +973,7 @@ static int parse_sangoma_event(ftdm_span_t *span, sangomabc_connection_t *mcon,
goto end; goto end;
} }
assert(event->call_setup_id <= MAX_REQ_ID); ftdm_assert_return(event->call_setup_id <= MAX_REQ_ID, -1, "Unexpected call setup id\n");
switch(event->event_id) { switch(event->event_id) {
case SIGBOOST_EVENT_CALL_START: case SIGBOOST_EVENT_CALL_START:
handle_call_start(span, mcon, (sangomabc_event_t*)event); handle_call_start(span, mcon, (sangomabc_event_t*)event);
@ -1030,7 +988,7 @@ static int parse_sangoma_event(ftdm_span_t *span, sangomabc_connection_t *mcon,
handle_call_start_ack(mcon, event); handle_call_start_ack(mcon, event);
break; break;
case SIGBOOST_EVENT_CALL_PROGRESS: case SIGBOOST_EVENT_CALL_PROGRESS:
handle_call_progress(mcon, event); handle_call_progress(span, mcon, event);
break; break;
case SIGBOOST_EVENT_CALL_START_NACK: case SIGBOOST_EVENT_CALL_START_NACK:
handle_call_start_nack(span, mcon, event); handle_call_start_nack(span, mcon, event);
@ -1102,9 +1060,6 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
{ {
int call_stopped_ack_sent = 0; int call_stopped_ack_sent = 0;
ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data;
if (ftdmchan->extra_id) {
ftdmchan->extra_id = 0;
}
if (ftdm_test_sflag(ftdmchan, SFLAG_FREE_REQ_ID)) { if (ftdm_test_sflag(ftdmchan, SFLAG_FREE_REQ_ID)) {
release_request_id_span_chan(ftdmchan->physical_span_id-1, ftdmchan->physical_chan_id-1); release_request_id_span_chan(ftdmchan->physical_span_id-1, ftdmchan->physical_chan_id-1);
@ -1119,7 +1074,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_START_NACK_ACK, SIGBOOST_EVENT_CALL_START_NACK_ACK,
0); 0, 0);
} else { } else {
/* we got a call stop msg, time to reply with call stopped ack */ /* we got a call stop msg, time to reply with call stopped ack */
@ -1128,7 +1083,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_STOPPED_ACK, SIGBOOST_EVENT_CALL_STOPPED_ACK,
0); 0, 0);
call_stopped_ack_sent = 1; call_stopped_ack_sent = 1;
} }
} }
@ -1144,11 +1099,10 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
} }
break; break;
case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
case FTDM_CHANNEL_STATE_PROGRESS:
{ {
if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA; sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA;
if ((status = sangoma_boost_data->signal_cb(&sig) != FTDM_SUCCESS)) { if ((status = ftdm_span_send_signal(ftdmchan->span, &sig) != FTDM_SUCCESS)) {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP);
} }
} else { } else {
@ -1159,16 +1113,42 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_START_ACK, SIGBOOST_EVENT_CALL_START_ACK,
0); 0, SIGBOOST_PROGRESS_MEDIA);
} }
} }
} }
break; break;
case FTDM_CHANNEL_STATE_PROGRESS:
{
if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
sig.event_id = FTDM_SIGEVENT_PROGRESS;
if ((status = ftdm_span_send_signal(ftdmchan->span, &sig) != FTDM_SUCCESS)) {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP);
}
} else {
if (!ftdm_test_sflag(ftdmchan, SFLAG_SENT_ACK)) {
ftdm_set_sflag(ftdmchan, SFLAG_SENT_ACK);
sangomabc_exec_command(mcon,
BOOST_SPAN(ftdmchan),
BOOST_CHAN(ftdmchan),
0,
SIGBOOST_EVENT_CALL_START_ACK,
0, SIGBOOST_PROGRESS_RING);
}
}
}
break;
case FTDM_CHANNEL_STATE_IDLE:
case FTDM_CHANNEL_STATE_HOLD:
{
/* twiddle */
}
break;
case FTDM_CHANNEL_STATE_RING: case FTDM_CHANNEL_STATE_RING:
{ {
if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
sig.event_id = FTDM_SIGEVENT_START; sig.event_id = FTDM_SIGEVENT_START;
if ((status = sangoma_boost_data->signal_cb(&sig) != FTDM_SUCCESS)) { if ((status = ftdm_span_send_signal(ftdmchan->span, &sig) != FTDM_SUCCESS)) {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP);
} }
} }
@ -1177,7 +1157,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
case FTDM_CHANNEL_STATE_RESTART: case FTDM_CHANNEL_STATE_RESTART:
{ {
sig.event_id = FTDM_SIGEVENT_RESTART; sig.event_id = FTDM_SIGEVENT_RESTART;
status = sangoma_boost_data->signal_cb(&sig); status = ftdm_span_send_signal(ftdmchan->span, &sig);
ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG);
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
} }
@ -1186,7 +1166,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
{ {
if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
sig.event_id = FTDM_SIGEVENT_UP; sig.event_id = FTDM_SIGEVENT_UP;
if ((status = sangoma_boost_data->signal_cb(&sig) != FTDM_SUCCESS)) { if ((status = ftdm_span_send_signal(ftdmchan->span, &sig) != FTDM_SUCCESS)) {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP);
} }
} else { } else {
@ -1196,7 +1176,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_START_ACK, SIGBOOST_EVENT_CALL_START_ACK,
0); 0, 0);
} }
sangomabc_exec_command(mcon, sangomabc_exec_command(mcon,
@ -1204,7 +1184,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_ANSWERED, SIGBOOST_EVENT_CALL_ANSWERED,
0); 0, 0);
} }
} }
break; break;
@ -1219,34 +1199,38 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
break; break;
case FTDM_CHANNEL_STATE_HANGUP: case FTDM_CHANNEL_STATE_HANGUP:
{ {
if (ftdmchan->last_state == FTDM_CHANNEL_STATE_TERMINATING || ftdm_set_sflag_locked(ftdmchan, SFLAG_HANGUP);
ftdm_test_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG)) {
if (ftdm_test_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG) || ftdm_test_sflag(ftdmchan, SFLAG_TERMINATING)) {
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE);
} else { } else {
ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG);
if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_ANSWERED) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MEDIA)) { if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_ANSWERED) ||
ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS) ||
ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MEDIA) ||
ftdm_test_sflag(ftdmchan, SFLAG_RECVD_ACK)) {
sangomabc_exec_command(mcon, sangomabc_exec_command(mcon,
BOOST_SPAN(ftdmchan), BOOST_SPAN(ftdmchan),
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_STOPPED, SIGBOOST_EVENT_CALL_STOPPED,
ftdmchan->caller_data.hangup_cause); ftdmchan->caller_data.hangup_cause, 0);
} else { } else {
sangomabc_exec_command(mcon, sangomabc_exec_command(mcon,
BOOST_SPAN(ftdmchan), BOOST_SPAN(ftdmchan),
BOOST_CHAN(ftdmchan), BOOST_CHAN(ftdmchan),
0, 0,
SIGBOOST_EVENT_CALL_START_NACK, SIGBOOST_EVENT_CALL_START_NACK,
ftdmchan->caller_data.hangup_cause); ftdmchan->caller_data.hangup_cause, 0);
} }
} }
} }
break; break;
case FTDM_CHANNEL_STATE_TERMINATING: case FTDM_CHANNEL_STATE_TERMINATING:
{ {
ftdm_set_sflag_locked(ftdmchan, SFLAG_TERMINATING);
sig.event_id = FTDM_SIGEVENT_STOP; sig.event_id = FTDM_SIGEVENT_STOP;
status = sangoma_boost_data->signal_cb(&sig); status = ftdm_span_send_signal(ftdmchan->span, &sig);
} }
break; break;
default: default:
@ -1311,7 +1295,7 @@ static __inline__ void check_state(ftdm_span_t *span)
0, 0,
-1, -1,
SIGBOOST_EVENT_SYSTEM_RESTART_ACK, SIGBOOST_EVENT_SYSTEM_RESTART_ACK,
0); 0, 0);
ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RESTARTING); ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RESTARTING);
ftdm_clear_flag_locked(span, FTDM_SPAN_SUSPENDED); ftdm_clear_flag_locked(span, FTDM_SPAN_SUSPENDED);
ftdm_clear_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); ftdm_clear_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN);
@ -1351,7 +1335,7 @@ static __inline__ ftdm_status_t check_events(ftdm_span_t *span, int ms_timeout)
if (sangoma_boost_data->sigmod) { if (sangoma_boost_data->sigmod) {
sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, FTDM_HW_LINK_DISCONNECTED); sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, FTDM_HW_LINK_DISCONNECTED);
} }
sangoma_boost_data->signal_cb(&sigmsg); ftdm_span_send_signal(span, &sigmsg);
break; break;
case FTDM_OOB_ALARM_CLEAR: case FTDM_OOB_ALARM_CLEAR:
sigmsg.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; sigmsg.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED;
@ -1359,7 +1343,7 @@ static __inline__ ftdm_status_t check_events(ftdm_span_t *span, int ms_timeout)
if (sangoma_boost_data->sigmod) { if (sangoma_boost_data->sigmod) {
sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, FTDM_HW_LINK_CONNECTED); sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, FTDM_HW_LINK_CONNECTED);
} }
sangoma_boost_data->signal_cb(&sigmsg); ftdm_span_send_signal(span, &sigmsg);
break; break;
} }
} }
@ -1717,12 +1701,25 @@ static ftdm_state_map_t boost_state_map = {
ZSD_OUTBOUND, ZSD_OUTBOUND,
ZSM_UNACCEPTABLE, ZSM_UNACCEPTABLE,
{FTDM_CHANNEL_STATE_DOWN, FTDM_END}, {FTDM_CHANNEL_STATE_DOWN, FTDM_END},
{FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_IDLE, FTDM_CHANNEL_STATE_HOLD, FTDM_END}
},
{
ZSD_OUTBOUND,
ZSM_UNACCEPTABLE,
{FTDM_CHANNEL_STATE_HOLD, FTDM_END},
{FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS,
FTDM_CHANNEL_STATE_IDLE, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END}
},
{
ZSD_OUTBOUND,
ZSM_UNACCEPTABLE,
{FTDM_CHANNEL_STATE_IDLE, FTDM_END},
{FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END} {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END}
}, },
{ {
ZSD_OUTBOUND, ZSD_OUTBOUND,
ZSM_UNACCEPTABLE, ZSM_UNACCEPTABLE,
{FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END}, {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_IDLE, FTDM_END},
{FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END} {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END}
}, },
{ {
@ -1826,7 +1823,6 @@ static BOOST_WRITE_MSG_FUNCTION(ftdm_boost_write_msg)
static BOOST_SIG_STATUS_CB_FUNCTION(ftdm_boost_sig_status_change) static BOOST_SIG_STATUS_CB_FUNCTION(ftdm_boost_sig_status_change)
{ {
ftdm_sigmsg_t sig; ftdm_sigmsg_t sig;
ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data;
ftdm_log(FTDM_LOG_NOTICE, "%d:%d Signaling link status changed to %s\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_signaling_status2str(status)); ftdm_log(FTDM_LOG_NOTICE, "%d:%d Signaling link status changed to %s\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_signaling_status2str(status));
memset(&sig, 0, sizeof(sig)); memset(&sig, 0, sizeof(sig));
@ -1835,7 +1831,7 @@ static BOOST_SIG_STATUS_CB_FUNCTION(ftdm_boost_sig_status_change)
sig.channel = ftdmchan; sig.channel = ftdmchan;
sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED; sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
sig.raw_data = &status; sig.raw_data = &status;
sangoma_boost_data->signal_cb(&sig); ftdm_span_send_signal(ftdmchan->span, &sig);
return; return;
} }
@ -2006,7 +2002,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_boost_configure_span)
ftdm_set_string(sangoma_boost_data->mcon.cfg.remote_ip, remote_ip); ftdm_set_string(sangoma_boost_data->mcon.cfg.remote_ip, remote_ip);
sangoma_boost_data->mcon.cfg.remote_port = remote_port; sangoma_boost_data->mcon.cfg.remote_port = remote_port;
} }
sangoma_boost_data->signal_cb = sig_cb; span->signal_cb = sig_cb;
span->start = ftdm_sangoma_boost_start; span->start = ftdm_sangoma_boost_start;
span->stop = ftdm_sangoma_boost_stop; span->stop = ftdm_sangoma_boost_stop;
span->signal_data = sangoma_boost_data; span->signal_data = sangoma_boost_data;

3
libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.c
View File

@ -221,13 +221,14 @@ int sangomabc_connection_open(sangomabc_connection_t *mcon, char *local_ip, int
} }
int sangomabc_exec_command(sangomabc_connection_t *mcon, int span, int chan, int id, int cmd, int cause) int sangomabc_exec_command(sangomabc_connection_t *mcon, int span, int chan, int id, int cmd, int cause, int flags)
{ {
sangomabc_short_event_t oevent; sangomabc_short_event_t oevent;
int retry = 5; int retry = 5;
sangomabc_event_init(&oevent, cmd, chan, span); sangomabc_event_init(&oevent, cmd, chan, span);
oevent.release_cause = (uint8_t)cause; oevent.release_cause = (uint8_t)cause;
oevent.flags = flags;
if (cmd == SIGBOOST_EVENT_SYSTEM_RESTART || cmd == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) { if (cmd == SIGBOOST_EVENT_SYSTEM_RESTART || cmd == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) {
mcon->rxseq_reset = 1; mcon->rxseq_reset = 1;

2
libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.h
View File

@ -141,7 +141,7 @@ int __sangomabc_connection_writep(sangomabc_connection_t *mcon, sangomabc_event_
void sangomabc_event_init(sangomabc_short_event_t *event, sangomabc_event_id_t event_id, int chan, int span); void sangomabc_event_init(sangomabc_short_event_t *event, sangomabc_event_id_t event_id, int chan, int span);
void sangomabc_call_init(sangomabc_event_t *event, const char *calling, const char *called, int setup_id); void sangomabc_call_init(sangomabc_event_t *event, const char *calling, const char *called, int setup_id);
const char *sangomabc_event_id_name(uint32_t event_id); const char *sangomabc_event_id_name(uint32_t event_id);
int sangomabc_exec_command(sangomabc_connection_t *mcon, int span, int chan, int id, int cmd, int cause); int sangomabc_exec_command(sangomabc_connection_t *mcon, int span, int chan, int id, int cmd, int cause, int flags);
int sangomabc_exec_commandp(sangomabc_connection_t *pcon, int span, int chan, int id, int cmd, int cause); int sangomabc_exec_commandp(sangomabc_connection_t *pcon, int span, int chan, int id, int cmd, int cause);
#endif #endif

2
libs/freetdm/src/include/freetdm.h
View File

@ -334,7 +334,7 @@ typedef enum {
int st = obj->state; \ int st = obj->state; \
r = (ftdm_channel_set_state(obj, s, l) == FTDM_SUCCESS) ? FTDM_STATE_CHANGE_SUCCESS : FTDM_STATE_CHANGE_FAIL; \ r = (ftdm_channel_set_state(obj, s, l) == FTDM_SUCCESS) ? FTDM_STATE_CHANGE_SUCCESS : FTDM_STATE_CHANGE_FAIL; \
if (obj->state == s) {ftdm_log(FTDM_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s));} \ if (obj->state == s) {ftdm_log(FTDM_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s));} \
else { if (!((obj->state == FTDM_CHANNEL_STATE_HANGUP && s == FTDM_CHANNEL_STATE_TERMINATING) || (obj->state == FTDM_CHANNEL_STATE_HANGUP_COMPLETE && s == FTDM_CHANNEL_STATE_HANGUP) || (obj->state == FTDM_CHANNEL_STATE_TERMINATING && s == FTDM_CHANNEL_STATE_HANGUP))) ftdm_log(FTDM_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); } \ else ftdm_log(FTDM_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); \
} }