redecorating

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@2301 d0543943-73ff-0310-b7d9-9358b9ac24b2

diff --git a/src/mod/applications/mod_bridgecall/mod_bridgecall.c b/src/mod/applications/mod_bridgecall/mod_bridgecall.c
index c08f4af92afcff3adf37fae6cc7f49bd6ac37537..3c8729b541155bcd52179645fba383af22a6e99f 100644 (file)
--- a/src/mod/applications/mod_bridgecall/mod_bridgecall.c
+++ b/src/mod/applications/mod_bridgecall/mod_bridgecall.c
@@ -40,42 +40,17 @@ static void audio_bridge_function(switch_core_session_t *session, char *data)
 {
        switch_channel_t *caller_channel;
        switch_core_session_t *peer_session;
-       switch_caller_profile_t *caller_profile, *caller_caller_profile;
-       char chan_type[128] = { '\0' }, *chan_data;
-       unsigned int timelimit = 60;                    /* probably a useful option to pass in when there's time */
+       unsigned int timelimit = 60; /* probably a useful option to pass in when there's time */
+
        caller_channel = switch_core_session_get_channel(session);
        assert(caller_channel != NULL);
 
-
-       strncpy(chan_type, data, sizeof(chan_type));
-
-       if ((chan_data = strchr(chan_type, '/')) != 0) {
-               *chan_data = '\0';
-               chan_data++;
-       }
-
-       caller_caller_profile = switch_channel_get_caller_profile(caller_channel);
-       caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
-                                                                                          caller_caller_profile->username,
-                                                                                          caller_caller_profile->dialplan,
-                                                                                          caller_caller_profile->caller_id_name,
-                                                                                          caller_caller_profile->caller_id_number,
-                                                                                          caller_caller_profile->network_addr, 
-                                                                                          NULL, 
-                                                                                          NULL, 
-                                                                                          caller_caller_profile->rdnis,
-                                                                                          caller_caller_profile->source,
-                                                                                          caller_caller_profile->context,
-                                                                                          chan_data);
-
-
-
-       if (switch_core_session_outgoing_channel(session, chan_type, caller_profile, &peer_session, NULL) !=
-               SWITCH_STATUS_SUCCESS) {
+       if (switch_ivr_outcall(session, &peer_session, data) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot Create Outgoing Channel!\n");
                switch_channel_hangup(caller_channel, SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL);
                return;
        } else {
+               /* peer channel is read locked now the bridge func will unlock it for us */
                switch_ivr_multi_threaded_bridge(session, peer_session, timelimit, NULL, NULL, NULL);
        }
 }

diff --git a/src/switch.c b/src/switch.c
index 20ffc3d38bbad4cb71bff2ab044902df296a1d2c..6b540385df5d5f798f672cf6b8317e9ed8e7ff8b 100644 (file)
--- a/src/switch.c
+++ b/src/switch.c
@@ -220,7 +220,6 @@ int main(int argc, char *argv[])
 
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "End existing sessions\n");
        switch_core_session_hupall();
-       switch_yield(10000);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clean up modules.\n");
        switch_loadable_module_shutdown();
        switch_core_destroy();

diff --git a/src/switch_channel.c b/src/switch_channel.c
index fda2965e6075982addddb9a156fe6fdb6667182c..01d5d7c69f300f3f0964de89f0bf6c7e8fd1cab7 100644 (file)
--- a/src/switch_channel.c
+++ b/src/switch_channel.c
@@ -762,9 +762,14 @@ SWITCH_DECLARE(switch_caller_profile_t *) switch_channel_get_originatee_caller_p
 SWITCH_DECLARE(int) switch_channel_add_state_handler(switch_channel_t *channel,
                                                                                                         const switch_state_handler_table_t *state_handler)
 {
-       int index;
+       int x, index;
 
        assert(channel != NULL);
+       for (x = 0; x < SWITCH_MAX_STATE_HANDLERS; x++) {
+               if (channel->state_handlers[x] == state_handler) {
+                       return x;
+               }
+       }
        index = channel->state_handler_index++;
 
        if (channel->state_handler_index >= SWITCH_MAX_STATE_HANDLERS) {

diff --git a/src/switch_core.c b/src/switch_core.c
index e133b2dd469bd7e9cb63d607d46d2747a9aeee79..b23d0681ea4190aa729e79c931b841f2ed5ce5e2 100644 (file)
--- a/src/switch_core.c
+++ b/src/switch_core.c
@@ -233,7 +233,15 @@ SWITCH_DECLARE(const switch_state_handler_table_t *) switch_core_get_state_handl
 
 SWITCH_DECLARE(switch_status_t) switch_core_session_read_lock(switch_core_session_t *session)
 {
-       return (switch_status_t) switch_thread_rwlock_tryrdlock(session->rwlock);
+       switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+       if (!switch_channel_test_flag(session->channel, CF_LOCK_THREAD)) {
+               if ((status = (switch_status_t) switch_thread_rwlock_tryrdlock(session->rwlock)) == SWITCH_STATUS_SUCCESS) {
+                       switch_channel_set_flag(session->channel, CF_LOCK_THREAD);
+               }
+       }
+       
+       return status;
 }
 
 SWITCH_DECLARE(void) switch_core_session_write_lock(switch_core_session_t *session)
@@ -243,6 +251,7 @@ SWITCH_DECLARE(void) switch_core_session_write_lock(switch_core_session_t *sessi
 
 SWITCH_DECLARE(void) switch_core_session_rwunlock(switch_core_session_t *session)
 {
+       switch_channel_clear_flag(session->channel, CF_LOCK_THREAD);
        switch_thread_rwlock_unlock(session->rwlock);
 }
 
@@ -283,7 +292,7 @@ SWITCH_DECLARE(void) switch_core_session_hupall(void)
        switch_mutex_unlock(runtime.session_table_mutex);
 
        while(runtime.session_count) {
-               switch_yield(1000);
+               switch_yield(10000);
        }
 }
 
@@ -3116,15 +3125,13 @@ SWITCH_DECLARE(switch_time_t) switch_core_uptime(void)
 SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
 {
 
-
-
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Closing Event Engine.\n");
        switch_event_shutdown();
        
        switch_queue_push(runtime.sql_queue, NULL);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Waiting for unfinished SQL transactions\n");
        while (switch_queue_size(runtime.sql_queue) > 0) {
-               switch_yield(1000);
+               switch_yield(10000);
        }
        switch_core_db_close(runtime.db);
        switch_core_db_close(runtime.event_db);
@@ -3132,16 +3139,16 @@ SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
 
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Finalizing Shutdown.\n");
        switch_log_shutdown();
-
-       if (runtime.memory_pool) {
-               apr_pool_destroy(runtime.memory_pool);
-               apr_terminate();
-       }
        
        if(runtime.console != stdout && runtime.console != stderr) {
                fclose(runtime.console);
                runtime.console = NULL;
        }
 
+       if (runtime.memory_pool) {
+               apr_pool_destroy(runtime.memory_pool);
+               apr_terminate();
+       }
+
        return SWITCH_STATUS_SUCCESS;
 }

diff --git a/src/switch_ivr.c b/src/switch_ivr.c
index d1bc77584686227a4d704aed70ba40ae56ddc6f5..80b2aacf0e7db0eb314f77cc61880ef354b815f2 100644 (file)
--- a/src/switch_ivr.c
+++ b/src/switch_ivr.c
@@ -1177,7 +1177,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_outcall(switch_core_session_t *sessio
                                                                                                   caller_caller_profile->caller_id_name,
                                                                                                   caller_caller_profile->caller_id_number,
                                                                                                   caller_caller_profile->network_addr, 
-                                                                                                  NULL, 
+                                                                                                  NULL,
                                                                                                   NULL, 
                                                                                                   caller_caller_profile->rdnis,
                                                                                                   caller_caller_profile->source,
@@ -1207,6 +1207,8 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_outcall(switch_core_session_t *sessio
                goto done;
        } 
 
+       switch_core_session_read_lock(peer_session);
+
        peer_channel = switch_core_session_get_channel(peer_session);
        assert(peer_channel != NULL);
                
@@ -1294,12 +1296,9 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(switch_core_ses
 {
        switch_core_thread_session_t *this_audio_thread, *other_audio_thread;
        switch_channel_t *caller_channel, *peer_channel;
-       time_t start;
        int stream_id = 0;
-       switch_frame_t *read_frame = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        
-
        caller_channel = switch_core_session_get_channel(session);
        assert(caller_channel != NULL);
 
@@ -1329,59 +1328,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(switch_core_ses
 
        switch_channel_add_state_handler(peer_channel, &audio_bridge_peer_state_handlers);
 
-       if (switch_core_session_runing(peer_session)) {
-               switch_channel_set_state(peer_channel, CS_RING);
-       } else {
-               switch_core_session_thread_launch(peer_session);
-       }
-
-       time(&start);
-
-       for (;;) {
-               int state = switch_channel_get_state(peer_channel);
-               if (state >= CS_RING) {
-                       break;
-               }
-               
-               if (!switch_channel_ready(caller_channel)) {
-                       break;
-               }
-               
-               if ((time(NULL) - start) > (time_t)timelimit) {
-                       break;
-               }
-               switch_yield(1000);
-       }
-
-       switch_channel_pre_answer(caller_channel);
-       
-
-       while (switch_channel_ready(caller_channel) &&
-                  switch_channel_ready(peer_channel) &&
-                  !switch_channel_test_flag(peer_channel, CF_ANSWERED) &&
-                  !switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA) &&
-                  ((time(NULL) - start) < (time_t)timelimit)) {
-               
-               /* read from the channel while we wait if the audio is up on it */
-               if (switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)) {
-                       switch_status_t status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
-                       
-                       if (!SWITCH_READ_ACCEPTABLE(status)) {
-                               break;
-                       }
-                       if (read_frame) {
-                               //memset(read_frame->data, 0, read_frame->datalen);
-                               if (switch_core_session_write_frame(session, read_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) {
-                                       break;
-                               }
-                       }
-
-               } else {
-                       switch_yield(1000);
-               }
-
-       }
-
        if (switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
                switch_channel_answer(caller_channel);
        }