update

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@426 a93c3328-9c30-0410-af19-c9cd2b2d52af

diff --git a/libs/freetdm/mod_openzap/mod_openzap.c b/libs/freetdm/mod_openzap/mod_openzap.c
index 4763a52b8629eaad131819462430680da4bed608..64d19abdecac33a8266178b7b41c460c6ca40624 100644 (file)
--- a/libs/freetdm/mod_openzap/mod_openzap.c
+++ b/libs/freetdm/mod_openzap/mod_openzap.c
@@ -666,21 +666,28 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session,
        switch (msg->message_id) {
        case SWITCH_MESSAGE_INDICATE_RINGING:
                {
-                       if (!switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                       if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                               zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS);
+                       } else {
                                zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS);
                        }
                }
                break;
        case SWITCH_MESSAGE_INDICATE_PROGRESS:
                {
-                       if (!switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                       if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                               zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS);
+                               zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_MEDIA);
+                       } else {
                                zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA);
                        }
                }
                break;
        case SWITCH_MESSAGE_INDICATE_ANSWER:
                {
-                       if (!switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                       if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                               zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED);
+                       } else {
                                zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP);
                        }
                }
@@ -706,7 +713,11 @@ static switch_status_t channel_receive_message_fxo(switch_core_session_t *sessio
        switch (msg->message_id) {
        case SWITCH_MESSAGE_INDICATE_PROGRESS:
        case SWITCH_MESSAGE_INDICATE_ANSWER:
-               if (!switch_channel_test_flag(channel, CF_OUTBOUND)) {
+               if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                       zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED);
+                       zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS);
+                       zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_MEDIA);
+               } else {
                        zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP);
                }
                break;
@@ -731,7 +742,11 @@ static switch_status_t channel_receive_message_fxs(switch_core_session_t *sessio
        switch (msg->message_id) {
        case SWITCH_MESSAGE_INDICATE_PROGRESS:
        case SWITCH_MESSAGE_INDICATE_ANSWER:
-               if (!switch_channel_test_flag(channel, CF_OUTBOUND)) {
+               if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
+                       zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED);
+                       zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS);
+                       zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_MEDIA);
+               } else {
                        zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP);
                }
                break;

diff --git a/libs/freetdm/src/include/zap_types.h b/libs/freetdm/src/include/zap_types.h
index 84b0243eca61e7626c859c0e440d7096f3fd41c5..c4f477e6252fc41431f2909fc3e8ce9757cc96f3 100644 (file)
--- a/libs/freetdm/src/include/zap_types.h
+++ b/libs/freetdm/src/include/zap_types.h
@@ -284,7 +284,6 @@ typedef enum {
 
 typedef enum {
        ZAP_CHANNEL_STATE_DOWN,
-       ZAP_CHANNEL_STATE_HANGUP,
        ZAP_CHANNEL_STATE_HOLD,
        ZAP_CHANNEL_STATE_SUSPENDED,
        ZAP_CHANNEL_STATE_DIALTONE,
@@ -296,17 +295,18 @@ typedef enum {
        ZAP_CHANNEL_STATE_DIALING,
        ZAP_CHANNEL_STATE_GET_CALLERID,
        ZAP_CHANNEL_STATE_CALLWAITING,
-       ZAP_CHANNEL_STATE_TERMINATING,
        ZAP_CHANNEL_STATE_RESTART,
-       ZAP_CHANNEL_STATE_PROGRESS_MEDIA,
        ZAP_CHANNEL_STATE_PROGRESS,
-       ZAP_CHANNEL_STATE_IDLE,
+       ZAP_CHANNEL_STATE_PROGRESS_MEDIA,
        ZAP_CHANNEL_STATE_UP,
+       ZAP_CHANNEL_STATE_IDLE,
+       ZAP_CHANNEL_STATE_TERMINATING,
+       ZAP_CHANNEL_STATE_HANGUP,
        ZAP_CHANNEL_STATE_INVALID
 } zap_channel_state_t;
-#define CHANNEL_STATE_STRINGS "DOWN", "HANGUP", "HOLD", "SUSPENDED", "DIALTONE", "COLLECT", \
+#define CHANNEL_STATE_STRINGS "DOWN", "HOLD", "SUSPENDED", "DIALTONE", "COLLECT", \
                "RING", "BUSY", "ATTN", "GENRING", "DIALING", "GET_CALLERID", "CALLWAITING", \
-               "TERMINATING", "RESTART", "PROGRESS_MEDIA", "PROGRESS", "IDLE", "UP", "INVALID"
+               "RESTART", "PROGRESS", "PROGRESS_MEDIA", "UP", "IDLE", "TERMINATING", "HANGUP", "INVALID"
 ZAP_STR2ENUM_P(zap_str2zap_channel_state, zap_channel_state2str, zap_channel_state_t)
 
 typedef enum {

diff --git a/libs/freetdm/src/zap_io.c b/libs/freetdm/src/zap_io.c
index f5b4bc1b675dceaa6c2dc5702dad6f92aa7443be..13c68f0956b299189991ac9970928fa8792803bd 100644 (file)
--- a/libs/freetdm/src/zap_io.c
+++ b/libs/freetdm/src/zap_io.c
@@ -979,16 +979,17 @@ zap_status_t zap_channel_close(zap_channel_t **zchan)
                return ZAP_FAIL;
        }
 
-       zap_mutex_lock(check->mutex);
-       if (zap_test_flag(check, ZAP_CHANNEL_OPEN)) {
-               status = check->zio->close(check);
-               if (status == ZAP_SUCCESS) {
-                       zap_channel_reset(check);
-                       *zchan = NULL;
+       if (zap_test_flag(check, ZAP_CHANNEL_CONFIGURED)) {
+               zap_mutex_lock(check->mutex);
+               if (zap_test_flag(check, ZAP_CHANNEL_OPEN)) {
+                       status = check->zio->close(check);
+                       if (status == ZAP_SUCCESS) {
+                               zap_channel_reset(check);
+                               *zchan = NULL;
+                       }
                }
+               zap_mutex_unlock(check->mutex);
        }
-
-       zap_mutex_unlock(check->mutex);
        
        return status;
 }

diff --git a/libs/freetdm/src/zap_ss7_boost.c b/libs/freetdm/src/zap_ss7_boost.c
index a44b8bb0bad1086dac28770b04ee4979a09f2752..b131d6a1ba4666579fcbea33d8bb662ceb250d06 100644 (file)
--- a/libs/freetdm/src/zap_ss7_boost.c
+++ b/libs/freetdm/src/zap_ss7_boost.c
@@ -77,21 +77,38 @@ static zap_channel_t *find_zchan(zap_span_t *span, ss7bc_event_t *event)
        int i;
        zap_channel_t *zchan = NULL;
 
+       zap_mutex_lock(signal_mutex);
        for(i = 0; i <= span->chan_count; i++) {
                if (span->channels[i].physical_span_id == event->span+1 && span->channels[i].physical_chan_id == event->chan+1) {
                        zchan = &span->channels[i];
                        if (zap_test_flag(zchan, ZAP_CHANNEL_INUSE)) {
-                               zchan = NULL;
-                               zap_log(ZAP_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use.\n",
-                                               span->channels[i].span_id,
-                                               span->channels[i].chan_id,
-                                               span->channels[i].physical_span_id,
-                                               span->channels[i].physical_chan_id
-                                               );
+                               if (zchan->state == ZAP_CHANNEL_STATE_DOWN || zchan->state >= ZAP_CHANNEL_STATE_TERMINATING) {
+                                       int x = 0;
+                                       zap_log(ZAP_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n");
+
+                                       zap_mutex_unlock(signal_mutex);
+                                       for (x = 0; x < 200; x++) {
+                                               if (!zap_test_flag(zchan, ZAP_CHANNEL_INUSE)) {
+                                                       break;
+                                               }
+                                               zap_sleep(5);
+                                       }
+                                       zap_mutex_lock(signal_mutex);
+                               }
+                               if (zap_test_flag(zchan, ZAP_CHANNEL_INUSE)) {
+                                       zchan = NULL;
+                                       zap_log(ZAP_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n",
+                                                       span->channels[i].span_id,
+                                                       span->channels[i].chan_id,
+                                                       span->channels[i].physical_span_id,
+                                                       span->channels[i].physical_chan_id
+                                                       );
+                               }
                        }
                        break;
                }
        }
+       zap_mutex_unlock(signal_mutex);
 
        return zchan;
 }
@@ -247,13 +264,6 @@ static void handle_call_start(zap_span_t *span, ss7bc_connection_t *mcon, ss7bc_
                goto error;
        }
 
-       ss7bc_exec_command(mcon,
-                                          event->span,
-                                          event->chan,
-                                          0,
-                                          SIGBOOST_EVENT_CALL_START_ACK,
-                                          0);
-
        zap_set_string(zchan->caller_data.cid_num.digits, (char *)event->calling_number_digits);
        zap_set_string(zchan->caller_data.cid_name, (char *)event->calling_number_digits);
        zap_set_string(zchan->caller_data.ani.digits, (char *)event->calling_number_digits);
@@ -454,6 +464,13 @@ static __inline__ void state_advance(zap_channel_t *zchan)
                                        zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP);
                                }
                        } else {
+                               ss7bc_exec_command(mcon,
+                                                                  zchan->physical_span_id-1,
+                                                                  zchan->physical_chan_id-1,                                                              
+                                                                  0,
+                                                                  SIGBOOST_EVENT_CALL_START_ACK,
+                                                                  0);
+                               
                                ss7bc_exec_command(mcon,
                                                                   zchan->physical_span_id-1,
                                                                   zchan->physical_chan_id-1,                                                              
@@ -469,12 +486,21 @@ static __inline__ void state_advance(zap_channel_t *zchan)
                break;
        case ZAP_CHANNEL_STATE_HANGUP:
                {
-                       ss7bc_exec_command(mcon,
-                                                          zchan->physical_span_id-1,
-                                                          zchan->physical_chan_id-1,
-                                                          0,
-                                                          SIGBOOST_EVENT_CALL_STOPPED,
-                                                          zchan->caller_data.hangup_cause);
+                       if (zap_test_flag(zchan, ZAP_CHANNEL_ANSWERED)) {
+                               ss7bc_exec_command(mcon,
+                                                                  zchan->physical_span_id-1,
+                                                                  zchan->physical_chan_id-1,
+                                                                  0,
+                                                                  SIGBOOST_EVENT_CALL_STOPPED,
+                                                                  zchan->caller_data.hangup_cause);
+                       } else {
+                               ss7bc_exec_command(mcon,
+                                                                  zchan->physical_span_id-1,
+                                                                  zchan->physical_chan_id-1,                                                              
+                                                                  0,
+                                                                  SIGBOOST_EVENT_CALL_START_NACK,
+                                                                  zchan->caller_data.hangup_cause);
+                       }
                        zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN);
                        
                }