#define SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE "execute_on_ring"
#define SWITCH_CALL_TIMEOUT_VARIABLE "call_timeout"
#define SWITCH_HOLDING_UUID_VARIABLE "holding_uuid"
+#define SWITCH_SOFT_HOLDING_UUID_VARIABLE "soft_holding_uuid"
#define SWITCH_API_BRIDGE_END_VARIABLE "api_after_bridge"
#define SWITCH_API_HANGUP_HOOK_VARIABLE "api_hangup_hook"
#define SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE "session_in_hangup_hook"
CF_ANSWERED = 1,
CF_OUTBOUND,
CF_EARLY_MEDIA,
- CF_ORIGINATOR,
+ CF_BRIDGE_ORIGINATOR,
CF_TRANSFER,
CF_ACCEPT_CNG,
CF_REDIRECT,
CF_REPORTING,
CF_PARK,
CF_TIMESTAMP_SET,
+ CF_ORIGINATOR,
+ CF_XFER_ZOMBIE,
/* WARNING: DO NOT ADD ANY FLAGS BELOW THIS LINE */
CF_FLAG_MAX
} switch_channel_flag_t;
switch_caller_extension_t *extension = NULL;
const char *app = "three_way";
const char *app_arg = switch_core_session_get_uuid(session);
- const char *holding = switch_channel_get_variable(channel, SWITCH_HOLDING_UUID_VARIABLE);
+ const char *holding = switch_channel_get_variable(channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE);
switch_core_session_t *b_session;
if (holding && (b_session = switch_core_session_locate(holding))) {
bond = switch_core_session_strdup(session, bond);
}
- switch_channel_set_variable(channel, SWITCH_HOLDING_UUID_VARIABLE, bond);
-
+ switch_channel_set_variable(channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, bond);
+ switch_channel_set_flag(channel, CF_XFER_ZOMBIE);
if ((var = switch_channel_get_variable(channel, SWITCH_CALL_TIMEOUT_VARIABLE))) {
timelimit = atoi(var);
switch_core_session_rwunlock(peer_session);
end:
- switch_channel_set_variable(channel, SWITCH_HOLDING_UUID_VARIABLE, NULL);
+ switch_channel_set_variable(channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL);
+ switch_channel_clear_flag(channel, CF_XFER_ZOMBIE);
}
SWITCH_STANDARD_APP(read_function)
}
+
+
+SWITCH_STANDARD_APP(endless_playback_function)
+{
+ switch_channel_t *channel = switch_core_session_get_channel(session);
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ const char *file = data;
+
+ while(switch_channel_ready(channel)) {
+ if ((status = switch_ivr_play_file(session, NULL, file, NULL)) == SWITCH_STATUS_NOTFOUND) {
+ break;
+ }
+ }
+
+ switch (status) {
+ case SWITCH_STATUS_SUCCESS:
+ case SWITCH_STATUS_BREAK:
+ switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, "FILE PLAYED");
+ break;
+ case SWITCH_STATUS_NOTFOUND:
+ switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, "FILE NOT FOUND");
+ break;
+ default:
+ switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, "PLAYBACK ERROR");
+ break;
+ }
+
+}
+
SWITCH_STANDARD_APP(gentones_function)
{
char *tone_script = NULL;
SWITCH_ADD_APP(app_interface, "park_state", "Park State", "Park State", park_state_function, "", SAF_NONE);
SWITCH_ADD_APP(app_interface, "gentones", "Generate Tones", "Generate tones to the channel", gentones_function, "<tgml_script>[|<loops>]", SAF_NONE);
SWITCH_ADD_APP(app_interface, "playback", "Playback File", "Playback a file to the channel", playback_function, "<path>", SAF_NONE);
+ SWITCH_ADD_APP(app_interface, "endless_playback", "Playback File Endlessly", "Endlessly Playback a file to the channel",
+ endless_playback_function, "<path>", SAF_NONE);
SWITCH_ADD_APP(app_interface, "att_xfer", "Attended Transfer", "Attended Transfer", att_xfer_function, "<channel_url>", SAF_NONE);
SWITCH_ADD_APP(app_interface, "read", "Read Digits", "Read Digits", read_function, "<min> <max> <file> <var_name> <timeout> <terminators>", SAF_NONE);
SWITCH_ADD_APP(app_interface, "play_and_get_digits", "Play and get Digits", "Play and get Digits",
const char *consumer_exit_key = switch_channel_get_variable(channel, "fifo_consumer_exit_key");
- if (switch_channel_test_flag(switch_core_session_get_channel(session), CF_ORIGINATOR)) {
+ if (switch_channel_test_flag(switch_core_session_get_channel(session), CF_BRIDGE_ORIGINATOR)) {
if ( consumer_exit_key && dtmf->digit == *consumer_exit_key ) {
switch_channel_hangup(bchan, SWITCH_CAUSE_NORMAL_CLEARING);
return SWITCH_STATUS_BREAK;
br_a = switch_channel_get_variable(channel_a, SWITCH_SIGNAL_BOND_VARIABLE);
br_b = switch_channel_get_variable(channel_b, SWITCH_SIGNAL_BOND_VARIABLE);
+
+ if (switch_channel_test_flag(channel_b, CF_ORIGINATOR)) {
+ switch_core_session_t *a_session;
+
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE,
+ "Attended Transfer on originating session %s\n", switch_core_session_get_uuid(b_session));
+
+
+
+ switch_channel_set_variable(channel_b, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "ATTENDED_TRANSFER");
+
+
+ sofia_clear_flag_locked(b_tech_pvt, TFLAG_SIP_HOLD);
+ sofia_clear_flag_locked(tech_pvt, TFLAG_HOLD_LOCK);
+
+ switch_channel_set_variable(channel_b, SWITCH_HOLDING_UUID_VARIABLE, br_a);
+ switch_channel_set_flag(channel_b, CF_XFER_ZOMBIE);
- if (br_a && br_b) {
+ if ((a_session = switch_core_session_locate(br_a))) {
+ const char *moh = profile->hold_music;
+ switch_channel_t *a_channel = switch_core_session_get_channel(a_session);
+ const char *tmp;
+
+ if ((tmp = switch_channel_get_variable(a_channel, SWITCH_HOLD_MUSIC_VARIABLE))) {
+ moh = tmp;
+ }
+ //switch_channel_set_variable(a_channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, "true");
+ switch_channel_set_variable_printf(a_channel, SWITCH_TRANSFER_AFTER_BRIDGE_VARIABLE, "'endless_playback:%s':inline", moh);
+ //switch_channel_set_variable_printf(a_channel, "park_command", "moh");
+ switch_core_session_rwunlock(a_session);
+ }
+
+ nua_notify(tech_pvt->nh, NUTAG_NEWSUB(1), SIPTAG_CONTENT_TYPE_STR("message/sipfrag"),
+ NUTAG_SUBSTATE(nua_substate_terminated), SIPTAG_PAYLOAD_STR("SIP/2.0 200 OK"), SIPTAG_EVENT_STR(etmp), TAG_END());
+
+ //switch_channel_set_variable(channel_b, "park_timeout", "2");
+ //switch_channel_set_state(channel_b, CS_PARK);
+
+
+ } else if (br_a && br_b) {
switch_core_session_t *new_b_session = NULL, *a_session = NULL, *tmp = NULL;
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Attended Transfer [%s][%s]\n",
sofia_clear_flag_locked(b_tech_pvt, TFLAG_SIP_HOLD);
sofia_clear_flag_locked(tech_pvt, TFLAG_HOLD_LOCK);
- switch_channel_set_variable(switch_core_session_get_channel(b_session), "park_timeout", "2");
- switch_channel_set_state(switch_core_session_get_channel(b_session), CS_PARK);
+ switch_channel_set_variable(channel_b, "park_timeout", "2");
+ switch_channel_set_state(channel_b, CS_PARK);
+
new_b_session = switch_core_session_locate(br_b);
a_session = switch_core_session_locate(br_a);
switch_channel_clear_flag(channel, CF_BLOCK_STATE);
if (channel->state < CS_HANGUP) {
- switch_channel_state_t last_state = channel->state;
+ switch_channel_state_t last_state;
switch_event_t *event;
switch_mutex_lock(channel->state_mutex);
+ last_state = channel->state;
channel->state = CS_HANGUP;
switch_mutex_unlock(channel->state_mutex);
expires = switch_epoch_time_now(NULL) + timeout;
}
switch_channel_set_variable(channel, "park_timeout", NULL);
+ switch_channel_set_variable(channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, NULL);
}
switch_channel_set_flag(channel, CF_CONTROLLED);
if ((session = switch_core_session_locate(uuid))) {
channel = switch_core_session_get_channel(session);
- if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_ORIGINATOR)) {
+ if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
swap = 1;
}
status = SWITCH_STATUS_SUCCESS;
channel = switch_core_session_get_channel(session);
- if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_ORIGINATOR)) {
+ if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
swap = 1;
}
chan_b = switch_core_session_get_channel(session_b);
ans_a = switch_channel_test_flag(chan_a, CF_ANSWERED);
- if ((originator = switch_channel_test_flag(chan_a, CF_ORIGINATOR))) {
+ if ((originator = switch_channel_test_flag(chan_a, CF_BRIDGE_ORIGINATOR))) {
pre_b = switch_channel_test_flag(chan_a, CF_EARLY_MEDIA);
ans_b = switch_channel_test_flag(chan_b, CF_ANSWERED);
}
int argc;
char *argv[4] = { 0 };
char *mydata;
-
+
+ switch_channel_set_variable(switch_core_session_get_channel(session), SWITCH_TRANSFER_AFTER_BRIDGE_VARIABLE, NULL);
+
if (!switch_strlen_zero(where) && (mydata = switch_core_session_strdup(session, where))) {
if ((argc = switch_separate_string(mydata, ':', argv, (sizeof(argv) / sizeof(argv[0])))) >= 1) {
switch_ivr_session_transfer(session, argv[0], argv[1], argv[2]);
switch_channel_clear_flag(channel, CF_ORIGINATING);
- if (switch_channel_test_flag(channel, CF_ORIGINATOR)) {
+ if (switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
switch_channel_set_state(channel, CS_SOFT_EXECUTE);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM SOFT_EXECUTE\n", switch_channel_get_name(channel));
switch_channel_clear_state_handler(channel, &uuid_bridge_state_handlers);
- if (!switch_channel_test_flag(channel, CF_ORIGINATOR)) {
+ if (!switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
return SWITCH_STATUS_SUCCESS;
}
- switch_channel_clear_flag(channel, CF_ORIGINATOR);
+ switch_channel_clear_flag(channel, CF_BRIDGE_ORIGINATOR);
if ((other_uuid = switch_channel_get_variable(channel, SWITCH_UUID_BRIDGE)) && (other_session = switch_core_session_locate(other_uuid))) {
switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
switch_core_session_rwunlock(other_session);
}
- if (switch_channel_test_flag(channel, CF_ORIGINATOR)) {
- switch_channel_clear_flag(channel, CF_ORIGINATOR);
+ if (switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
+ switch_channel_clear_flag(channel, CF_BRIDGE_ORIGINATOR);
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_UNBRIDGE) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event);
switch_event_fire(&event);
switch_channel_set_variable(caller_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, switch_core_session_get_uuid(peer_session));
switch_channel_set_variable(peer_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, switch_core_session_get_uuid(session));
- switch_channel_set_flag(caller_channel, CF_ORIGINATOR);
+ switch_channel_set_flag(caller_channel, CF_BRIDGE_ORIGINATOR);
switch_channel_clear_state_handler(caller_channel, NULL);
switch_channel_clear_state_handler(peer_channel, NULL);
return switch_ivr_signal_bridge(session, peer_session);
}
- switch_channel_set_flag(caller_channel, CF_ORIGINATOR);
+ switch_channel_set_flag(caller_channel, CF_BRIDGE_ORIGINATOR);
b_leg->session = peer_session;
switch_copy_string(b_leg->b_uuid, switch_core_session_get_uuid(session), sizeof(b_leg->b_uuid));
switch_channel_set_state(peer_channel, CS_EXCHANGE_MEDIA);
audio_bridge_thread(NULL, (void *) a_leg);
- switch_channel_clear_flag(caller_channel, CF_ORIGINATOR);
+ switch_channel_clear_flag(caller_channel, CF_BRIDGE_ORIGINATOR);
while (switch_channel_get_state(peer_channel) == CS_EXCHANGE_MEDIA) {
switch_cond_next();
switch_channel_clear_flag(originatee_channel, CF_ORIGINATING);
/* change the states and let the chips fall where they may */
+
+ switch_channel_set_variable(originator_channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, NULL);
+ switch_channel_set_variable(originatee_channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, NULL);
switch_channel_clear_state_handler(originator_channel, NULL);
switch_channel_clear_state_handler(originatee_channel, NULL);
- switch_channel_set_state_flag(originator_channel, CF_ORIGINATOR);
- switch_channel_clear_flag(originatee_channel, CF_ORIGINATOR);
+ switch_channel_set_state_flag(originator_channel, CF_BRIDGE_ORIGINATOR);
+ switch_channel_clear_flag(originatee_channel, CF_BRIDGE_ORIGINATOR);
switch_channel_add_state_handler(originator_channel, &uuid_bridge_state_handlers);
switch_channel_add_state_handler(originatee_channel, &uuid_bridge_state_handlers);
typedef enum {
+ IDX_KEY_CANCEL = -4,
IDX_TIMEOUT = -3,
IDX_CANCEL = -2,
IDX_NADA = -1
const char *var;
switch_time_t start = 0;
const char *cancel_key = NULL;
+ switch_channel_state_t wait_state = 0;
switch_assert(peer_channel);
+ if (switch_channel_get_state(peer_channel) == CS_RESET) {
+ switch_channel_set_state(peer_channel, CS_SOFT_EXECUTE);
+ }
+
if (session) {
caller_channel = switch_core_session_get_channel(session);
}
no_ringback:
- while (switch_channel_ready(peer_channel)
- && !(switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA))) {
+ if (caller_channel) {
+ wait_state = switch_channel_get_state(caller_channel);
+ }
+
+ while (switch_channel_ready(peer_channel) && !switch_channel_media_ready(peer_channel)) {
int diff = (int) (switch_micro_time_now() - start);
if (caller_channel && cancel_key) {
}
}
+ if (caller_channel && switch_channel_get_state(caller_channel) != wait_state) {
+ goto done;
+ }
+
if (diff > timelimit) {
status = SWITCH_STATUS_TIMEOUT;
goto done;
end:
- return (!caller_channel || switch_channel_ready(caller_channel)) ? status : SWITCH_STATUS_FALSE;
+ if (!switch_channel_media_ready(peer_channel)) {
+ if (switch_channel_up(peer_channel)) {
+ switch_channel_hangup(peer_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+ }
+ status = SWITCH_STATUS_FALSE;
+ }
+
+ if (caller_channel && !switch_channel_ready(caller_channel)) {
+ status = SWITCH_STATUS_FALSE;
+ }
+
+ return status;
}
SWITCH_DECLARE(void) switch_process_import(switch_core_session_t *session, switch_channel_t *peer_channel, const char *varname)
}
+#define peer_eligible(_peer) (_peer && !(switch_channel_test_flag(_peer, CF_TRANSFER) || \
+ switch_channel_test_flag(_peer, CF_REDIRECT) || \
+ switch_channel_test_flag(_peer, CF_BRIDGED) || \
+ switch_channel_get_state(_peer) == CS_RESET || \
+ !switch_channel_test_flag(_peer, CF_ORIGINATING)))
+
#define MAX_PEERS 128
SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *session,
switch_core_session_t **bleg,
uint8_t pass = 0;
char *odata, *var;
switch_call_cause_t reason = SWITCH_CAUSE_NONE;
+ switch_call_cause_t force_reason = SWITCH_CAUSE_NONE;
uint8_t to = 0;
char *var_val, *vars = NULL;
int var_block_count = 0;
int cdr_total = 0;
int local_clobber = 0;
const char *cancel_key = NULL;
+ const char *holding = NULL;
+ switch_channel_state_t wait_state = 0;
if (session) {
caller_channel = switch_core_session_get_channel(session);
+ switch_channel_set_flag(caller_channel, CF_ORIGINATOR);
oglobals.session = session;
if (switch_true(switch_channel_get_variable(caller_channel, SWITCH_PROXY_MEDIA_VARIABLE))) {
oglobals.early_ok = 0;
}
#endif
- while ((!caller_channel || switch_channel_ready(caller_channel)) && check_channel_status(&oglobals, originate_status, and_argc)) {
+
+ if (caller_channel) {
+ wait_state = switch_channel_get_state(caller_channel);
+ }
+
+ while ((!caller_channel || switch_channel_ready(caller_channel) || switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) &&
+ check_channel_status(&oglobals, originate_status, and_argc)) {
time_t elapsed = switch_epoch_time_now(NULL) - start;
if (caller_channel && !oglobals.sent_ring && oglobals.ring_ready && !oglobals.return_ring_ready) {
switch_channel_ring_ready(caller_channel);
switch_ivr_parse_all_events(oglobals.session);
}
+ if (caller_channel && switch_channel_get_state(caller_channel) != wait_state && !switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
+ oglobals.idx = IDX_NADA;
+ goto notready;
+ }
+
if (!oglobals.sent_ring && !oglobals.progress && (progress_timelimit_sec && elapsed > (time_t) progress_timelimit_sec)) {
oglobals.idx = IDX_TIMEOUT;
goto notready;
if (oglobals.session &&
!switch_channel_test_flag(caller_channel, CF_PROXY_MODE) &&
!switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA) &&
+ !switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE) &&
(ringback_data
|| (switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)))) {
-
+
switch_status_t tstatus = SWITCH_STATUS_SUCCESS;
int silence = 0;
switch_dtmf_t dtmf = { 0, 0 };
if (switch_channel_dequeue_dtmf(caller_channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
if (dtmf.digit == *cancel_key) {
- oglobals.idx = IDX_CANCEL;
+ oglobals.idx = IDX_KEY_CANCEL;
goto notready;
}
}
notready:
+ if (caller_channel) {
+ const char *soft_holding = switch_channel_get_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE);
+ holding = switch_channel_get_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE);
+ switch_channel_set_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE, NULL);
+
+ if (soft_holding && switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
+ holding = soft_holding;
+ switch_channel_set_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL);
+ }
+ }
+
if (caller_channel && !switch_channel_ready(caller_channel)) {
oglobals.idx = IDX_CANCEL;
}
switch_core_session_reset(oglobals.session, SWITCH_FALSE, SWITCH_TRUE);
}
- for (i = 0; i < and_argc; i++) {
- if (!originate_status[i].peer_channel) {
- continue;
+ if ((oglobals.idx == IDX_TIMEOUT || oglobals.idx == IDX_KEY_CANCEL) && switch_channel_ready(caller_channel)) {
+ holding = NULL;
+ }
+
+ if (holding) {
+ if (oglobals.idx > IDX_NADA) {
+ peer_session = originate_status[oglobals.idx].peer_session;
+ peer_channel = originate_status[oglobals.idx].peer_channel;
+ originate_status[oglobals.idx].peer_channel = NULL;
+ } else if (and_argc == 1) {
+ peer_session = originate_status[0].peer_session;
+ peer_channel = originate_status[0].peer_channel;
+ originate_status[0].peer_channel = NULL;
+ } else {
+ for (i = 0; i < and_argc; i++) {
+ if (!peer_eligible(originate_status[i].peer_channel)) {
+ continue;
+ }
+ if (switch_channel_media_ready(originate_status[i].peer_channel)) {
+ peer_session = originate_status[i].peer_session;
+ peer_channel = originate_status[i].peer_channel;
+ originate_status[i].peer_channel = NULL;
+ goto end_search;
+ }
+ }
+ for (i = 0; i < and_argc; i++) {
+ if (!peer_eligible(originate_status[i].peer_channel)) {
+ continue;
+ }
+ if (switch_channel_up(originate_status[i].peer_channel)) {
+ peer_session = originate_status[i].peer_session;
+ peer_channel = originate_status[i].peer_channel;
+ originate_status[i].peer_channel = NULL;
+ break;
+ }
+ }
}
- //switch_channel_clear_flag(originate_status[i].peer_channel, CF_BLOCK_STATE);
+ end_search:
- if (switch_channel_test_flag(originate_status[i].peer_channel, CF_TRANSFER)
- || switch_channel_test_flag(originate_status[i].peer_channel, CF_REDIRECT)
- || switch_channel_test_flag(originate_status[i].peer_channel, CF_BRIDGED) ||
- switch_channel_get_state(originate_status[i].peer_channel) == CS_RESET ||
- !switch_channel_test_flag(originate_status[i].peer_channel, CF_ORIGINATING)
- ) {
- continue;
+
+ if (peer_channel && switch_channel_ready(peer_channel)) {
+ force_reason = SWITCH_CAUSE_ATTENDED_TRANSFER;
+ switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(peer_session));
+ oglobals.idx = IDX_NADA;
+ if (caller_channel) {
+ switch_channel_hangup(caller_channel, SWITCH_CAUSE_ATTENDED_TRANSFER);
+ }
+ switch_core_session_rwunlock(peer_session);
+ } else {
+ switch_core_session_t *holding_session;
+
+ if ((holding_session = switch_core_session_locate(holding))) {
+ switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);
+ if (caller_channel && switch_channel_ready(caller_channel)) {
+ switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(session));
+ } else {
+ switch_channel_hangup(holding_channel, SWITCH_CAUSE_NORMAL_UNSPECIFIED);
+ }
+ switch_core_session_rwunlock(holding_session);
+ }
}
+ peer_session = NULL;
+ peer_channel = NULL;
+
+ }
+
+
+ for (i = 0; i < and_argc; i++) {
+ if (!peer_eligible(originate_status[i].peer_channel)) {
+ continue;
+ }
+
if (i != oglobals.idx) {
- const char *holding = NULL;
+ holding = NULL;
- if (oglobals.idx == IDX_TIMEOUT || to) {
+ if (force_reason != SWITCH_CAUSE_NONE) {
+ reason = force_reason;
+ } else if (oglobals.idx == IDX_TIMEOUT || to) {
reason = SWITCH_CAUSE_NO_ANSWER;
} else {
if (oglobals.idx == IDX_CANCEL) {
}
if (switch_channel_up(originate_status[i].peer_channel)) {
if (caller_channel && i == 0) {
- holding = switch_channel_get_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE);
- switch_channel_set_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE, NULL);
- }
- if (holding && oglobals.idx != IDX_TIMEOUT && oglobals.idx != IDX_CANCEL) {
- switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(originate_status[i].peer_session));
- } else {
+ holding = switch_channel_get_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE);
+ switch_channel_set_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL);
+ }
+
+ if (holding && oglobals.idx != IDX_TIMEOUT && oglobals.idx != IDX_KEY_CANCEL) {
+ switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(originate_status[i].peer_session));
+ } else {
switch_channel_hangup(originate_status[i].peer_channel, reason);
}
}
}
}
-
-
+
if (oglobals.idx > IDX_NADA) {
peer_session = originate_status[oglobals.idx].peer_session;
peer_channel = originate_status[oglobals.idx].peer_channel;
switch_safe_free(write_frame.data);
switch_safe_free(fail_on_single_reject_var);
+ if (caller_channel) {
+ switch_channel_clear_flag(caller_channel, CF_ORIGINATOR);
+ switch_channel_clear_flag(caller_channel, CF_XFER_ZOMBIE);
+ }
+
return status;
}
projects / thirdparty / freeswitch.git / commitdiff
