Author: anthm Date: Fri Jan 4 20:03:08 2008 New Revision: 7083 Modified: freeswitch/trunk/conf/sip_profiles/default.xml freeswitch/trunk/src/include/switch_ivr.h freeswitch/trunk/src/include/switch_types.h freeswitch/trunk/src/mod/endpoints/mod_sofia/mod_sofia.c freeswitch/trunk/src/switch_core_state_machine.c freeswitch/trunk/src/switch_ivr.c freeswitch/trunk/src/switch_ivr_bridge.c freeswitch/trunk/src/switch_ivr_originate.c Log: support crazy transfer crap Modified: freeswitch/trunk/conf/sip_profiles/default.xml ============================================================================== --- freeswitch/trunk/conf/sip_profiles/default.xml (original) +++ freeswitch/trunk/conf/sip_profiles/default.xml Fri Jan 4 20:03:08 2008 @@ -32,7 +32,7 @@ <!--<param name="dtmf-type" value="info"/>--> <param name="record-template" value="$${base_dir}/recordings/${caller_id_number}.${strftime(%Y-%m-%d-%H-%M-%S)}.wav"/> <!--enable to use presense and mwi --> - <param name="manage-presence" value="true"/> + <param name="manage-presence" value="false"/> <!-- This setting is for AAL2 bitpacking on G726 --> <!-- <param name="bitpacking" value="aal2"/> --> <!--max number of open dialogs in proceeding --> Modified: freeswitch/trunk/src/include/switch_ivr.h ============================================================================== --- freeswitch/trunk/src/include/switch_ivr.h (original) +++ freeswitch/trunk/src/include/switch_ivr.h Fri Jan 4 20:03:08 2008 @@ -727,6 +727,7 @@ SWITCH_DECLARE(void) switch_ivr_delay_echo(switch_core_session_t *session, uint32_t delay_ms); SWITCH_DECLARE(void) switch_ivr_intercept_session(switch_core_session_t *session, const char *uuid); SWITCH_DECLARE(void) switch_ivr_park_session(switch_core_session_t *session); +SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t *session, switch_core_session_t *peer_session); /** @} */ Modified: freeswitch/trunk/src/include/switch_types.h ============================================================================== --- freeswitch/trunk/src/include/switch_types.h (original) +++ freeswitch/trunk/src/include/switch_types.h Fri Jan 4 20:03:08 2008 @@ -628,6 +628,7 @@ CF_VIDEO = (1 << 22) - Channel has video CF_EVENT_LOCK = (1 << 23) - Don't parse events CF_RESET = (1 << 24) - Tell extension parser to reset +CF_ORIGINATING = (1 << 25) - Channel is originating </pre> */ @@ -656,7 +657,8 @@ CF_UNICAST = (1 << 21), CF_VIDEO = (1 << 22), CF_EVENT_LOCK = (1 << 23), - CF_RESET = (1 << 24) + CF_RESET = (1 << 24), + CF_ORIGINATING = (1 << 25) } switch_channel_flag_t; Modified: freeswitch/trunk/src/mod/endpoints/mod_sofia/mod_sofia.c ============================================================================== --- freeswitch/trunk/src/mod/endpoints/mod_sofia/mod_sofia.c (original) +++ freeswitch/trunk/src/mod/endpoints/mod_sofia/mod_sofia.c Fri Jan 4 20:03:08 2008 @@ -1685,6 +1685,7 @@ switch_channel_set_variable(nchannel, "sip_destination_url", tech_pvt->dest); caller_profile = switch_caller_profile_clone(nsession, outbound_profile); + caller_profile->destination_number = switch_core_strdup(caller_profile->pool, dest); switch_channel_set_caller_profile(nchannel, caller_profile); switch_channel_set_flag(nchannel, CF_OUTBOUND); switch_set_flag_locked(tech_pvt, TFLAG_OUTBOUND); Modified: freeswitch/trunk/src/switch_core_state_machine.c ============================================================================== --- freeswitch/trunk/src/switch_core_state_machine.c (original) +++ freeswitch/trunk/src/switch_core_state_machine.c Fri Jan 4 20:03:08 2008 @@ -132,7 +132,7 @@ char *expanded = NULL; int nomedia = 0; - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Execute %s(%s)\n", + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Execute %s(%s)\n", switch_channel_get_name(session->channel), extension->current_application->application_name, switch_str_nil(extension->current_application->application_data)); if ((application_interface = switch_loadable_module_get_application_interface(extension->current_application->application_name)) == 0) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Application %s\n", extension->current_application->application_name); @@ -156,8 +156,9 @@ if ((expanded = switch_channel_expand_variables(session->channel, extension->current_application->application_data)) != extension->current_application->application_data) { - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Expanded String %s(%s)\n", extension->current_application->application_name, - expanded); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Expanded String %s(%s)\n", switch_channel_get_name(session->channel), + extension->current_application->application_name, expanded); + } if (switch_channel_get_variable(session->channel, "presence_id")) { Modified: freeswitch/trunk/src/switch_ivr.c ============================================================================== --- freeswitch/trunk/src/switch_ivr.c (original) +++ freeswitch/trunk/src/switch_ivr.c Fri Jan 4 20:03:08 2008 @@ -852,6 +852,8 @@ channel = switch_core_session_get_channel(session); switch_assert(channel != NULL); + switch_channel_clear_flag(channel, CF_ORIGINATING); + /* clear all state handlers */ switch_channel_clear_state_handler(channel, NULL); Modified: freeswitch/trunk/src/switch_ivr_bridge.c ============================================================================== --- freeswitch/trunk/src/switch_ivr_bridge.c (original) +++ freeswitch/trunk/src/switch_ivr_bridge.c Fri Jan 4 20:03:08 2008 @@ -596,7 +596,8 @@ switch_channel_answer(caller_channel); } - if (switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) { + if (switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA) || + switch_channel_test_flag(peer_channel, CF_RING_READY)) { switch_event_t *event; switch_core_session_message_t msg = { 0 }; const switch_application_interface_t *application_interface; @@ -627,7 +628,29 @@ } } - + if (!(switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA))) { + if ((status = switch_ivr_wait_for_answer(session, peer_session)) != SWITCH_STATUS_SUCCESS) { + switch_channel_state_t w_state = switch_channel_get_state(caller_channel); + switch_channel_hangup(peer_channel, SWITCH_CAUSE_ALLOTTED_TIMEOUT); + if (w_state < CS_HANGUP && w_state != CS_RING && w_state != CS_PARK && !switch_channel_test_flag(caller_channel, CF_TRANSFER) && + w_state != CS_EXECUTE) { + const char *ext = switch_channel_get_variable(peer_channel, "original_destination_number"); + if (!ext) { + ext = switch_channel_get_variable(peer_channel, "destination_number"); + } + + if (ext) { + switch_ivr_session_transfer(session, ext, NULL, NULL); + } else { + switch_channel_hangup(caller_channel, SWITCH_CAUSE_ALLOTTED_TIMEOUT); + } + } + switch_core_session_rwunlock(peer_session); + goto done; + } + } + + msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE; msg.from = __FILE__; msg.string_arg = switch_core_session_strdup(peer_session, switch_core_session_get_uuid(session)); @@ -707,8 +730,8 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_uuid_bridge(const char *originator_uuid, const char *originatee_uuid) { - switch_core_session_t *originator_session, *originatee_session; - switch_channel_t *originator_channel, *originatee_channel; + switch_core_session_t *originator_session, *originatee_session, *swap_session; + switch_channel_t *originator_channel, *originatee_channel, *swap_channel; switch_status_t status = SWITCH_STATUS_FALSE; switch_caller_profile_t *cp, *originator_cp, *originatee_cp; @@ -717,6 +740,23 @@ originator_channel = switch_core_session_get_channel(originator_session); originatee_channel = switch_core_session_get_channel(originatee_session); + if (!switch_channel_test_flag(originator_channel, CF_ANSWERED)) { + if (switch_channel_test_flag(originatee_channel, CF_ANSWERED)) { + swap_session = originator_session; + originator_session = originatee_session; + originatee_session = swap_session; + + swap_channel = originator_channel; + originator_channel = originatee_channel; + originatee_channel = swap_channel; + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "reversing order of channels so this will work!\n"); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Neither channel is answered, cannot bridge them.\n"); + return SWITCH_STATUS_FALSE; + } + } + + /* override transmit state for originator_channel to bridge to originatee_channel * install pointer to originatee_session into originator_channel * set CF_TRANSFER on both channels and change state to CS_TRANSMIT to @@ -726,12 +766,13 @@ switch_channel_clear_state_handler(originator_channel, NULL); switch_channel_clear_state_handler(originatee_channel, NULL); - switch_channel_set_flag(originator_channel, CF_ORIGINATOR); + switch_channel_set_state_flag(originator_channel, CF_ORIGINATOR); switch_channel_clear_flag(originatee_channel, CF_ORIGINATOR); switch_channel_add_state_handler(originator_channel, &uuid_bridge_state_handlers); switch_channel_add_state_handler(originatee_channel, &uuid_bridge_state_handlers); switch_channel_set_variable(originator_channel, SWITCH_UUID_BRIDGE, switch_core_session_get_uuid(originatee_session)); + switch_channel_set_variable(originator_channel, SWITCH_BRIDGE_CHANNEL_VARIABLE, switch_channel_get_name(originatee_channel)); switch_channel_set_variable(originator_channel, SWITCH_BRIDGE_UUID_VARIABLE, switch_core_session_get_uuid(originatee_session)); @@ -743,6 +784,16 @@ originator_cp = switch_channel_get_caller_profile(originator_channel); originatee_cp = switch_channel_get_caller_profile(originatee_channel); + + + switch_channel_set_variable(originatee_channel, "original_destination_number", originatee_cp->destination_number); + switch_channel_set_variable(originatee_channel, "original_caller_id_name", originatee_cp->caller_id_name); + switch_channel_set_variable(originatee_channel, "original_caller_id_number", originatee_cp->caller_id_number); + + switch_channel_set_variable(originator_channel, "original_destination_number", originator_cp->destination_number); + switch_channel_set_variable(originator_channel, "original_caller_id_name", originator_cp->caller_id_name); + switch_channel_set_variable(originator_channel, "original_caller_id_number", originator_cp->caller_id_number); + cp = switch_caller_profile_clone(originatee_session, originatee_cp); cp->destination_number = switch_core_strdup(cp->pool, originator_cp->caller_id_number); @@ -750,7 +801,7 @@ cp->caller_id_name = switch_core_strdup(cp->pool, originator_cp->caller_id_name); switch_channel_set_caller_profile(originatee_channel, cp); switch_channel_set_originator_caller_profile(originatee_channel, switch_caller_profile_clone(originatee_session, originator_cp)); - + cp = switch_caller_profile_clone(originator_session, originator_cp); cp->destination_number = switch_core_strdup(cp->pool, originatee_cp->caller_id_number); cp->caller_id_number = switch_core_strdup(cp->pool, originatee_cp->caller_id_number); @@ -763,6 +814,9 @@ switch_channel_set_flag(originator_channel, CF_TRANSFER); switch_channel_set_flag(originatee_channel, CF_TRANSFER); + + switch_channel_clear_flag(originator_channel, CF_ORIGINATING); + switch_channel_clear_flag(originatee_channel, CF_ORIGINATING); /* change the states and let the chips fall where they may */ switch_channel_set_state(originator_channel, CS_RESET); Modified: freeswitch/trunk/src/switch_ivr_originate.c ============================================================================== --- freeswitch/trunk/src/switch_ivr_originate.c (original) +++ freeswitch/trunk/src/switch_ivr_originate.c Fri Jan 4 20:03:08 2008 @@ -165,13 +165,19 @@ *idx = IDX_NADA; for (i = 0; i < len; i++) { + switch_channel_state_t state; if (!peer_channels[i]) { continue; } if (!*ring_ready && switch_channel_test_flag(peer_channels[i], CF_RING_READY)) { *ring_ready = 1; } - if (switch_channel_get_state(peer_channels[i]) >= CS_HANGUP) { + + state = switch_channel_get_state(peer_channels[i]); + if (state >= CS_HANGUP || state == CS_RESET || switch_channel_test_flag(peer_channels[i], CF_TRANSFER) || + switch_channel_test_flag(peer_channels[i], CF_BRIDGED) || + !switch_channel_test_flag(peer_channels[i], CF_ORIGINATING) + ) { (*hups)++; } else if ((switch_channel_test_flag(peer_channels[i], CF_ANSWERED) || (early_ok && len == 1 && switch_channel_test_flag(peer_channels[i], CF_EARLY_MEDIA))) && @@ -233,6 +239,284 @@ return 0; } + +SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t *session, switch_core_session_t *peer_session) +{ + switch_channel_t *caller_channel; + switch_channel_t *peer_channel; + const char *ringback_data = NULL; + switch_frame_t write_frame = { 0 }; + switch_codec_t write_codec = { 0 }; + switch_codec_t *read_codec = NULL; + uint8_t pass = 0; + ringback_t ringback = { 0 }; + switch_core_session_message_t *message = NULL; + switch_frame_t *read_frame = NULL; + switch_status_t status = SWITCH_STATUS_SUCCESS; + uint8_t abuf[1024]; + int timelimit = 60; + const char *var; + switch_time_t start = 0; + + caller_channel = switch_core_session_get_channel(session); + peer_channel = switch_core_session_get_channel(peer_session); + + switch_assert(caller_channel && peer_channel); + + if ((var = switch_channel_get_variable(caller_channel, "call_timeout"))) { + timelimit = atoi(var); + if (timelimit < 0) { + timelimit = 60; + } + } + + timelimit *= 1000000; + start = switch_timestamp_now(); + + if ((switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA))) { + return SWITCH_STATUS_SUCCESS; + } + + read_codec = switch_core_session_get_read_codec(session); + + if (switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)) { + ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback"); + } + + if (!ringback_data) { + ringback_data = switch_channel_get_variable(caller_channel, "ringback"); + } + + switch_channel_set_variable(caller_channel, "originate_disposition", "failure"); + + + if (ringback_data) { + char *tmp_data = NULL; + ringback_t ringback = { 0 }; + + switch_buffer_create_dynamic(&ringback.audio_buffer, 512, 1024, 0); + switch_buffer_set_loops(ringback.audio_buffer, -1); + + if (switch_is_file_path(ringback_data)) { + char *ext; + + if (strrchr(ringback_data, '.') || strstr(ringback_data, SWITCH_URL_SEPARATOR)) { + switch_core_session_set_read_codec(session, &write_codec); + } else { + ringback.asis++; + write_frame.codec = read_codec; + ext = read_codec->implementation->iananame; + tmp_data = switch_mprintf("%s.%s", ringback_data, ext); + ringback_data = tmp_data; + } + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Play Ringback File [%s]\n", ringback_data); + + ringback.fhb.channels = read_codec->implementation->number_of_channels; + ringback.fhb.samplerate = read_codec->implementation->actual_samples_per_second; + if (switch_core_file_open(&ringback.fhb, + ringback_data, + read_codec->implementation->number_of_channels, + read_codec->implementation->actual_samples_per_second, + SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, + switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Playing File\n"); + switch_safe_free(tmp_data); + goto done; + } + ringback.fh = &ringback.fhb; + + + } else { + teletone_init_session(&ringback.ts, 0, teletone_handler, &ringback); + ringback.ts.rate = read_codec->implementation->actual_samples_per_second; + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Play Ringback Tone [%s]\n", ringback_data); + //ringback.ts.debug = 1; + //ringback.ts.debug_stream = switch_core_get_console(); + if (teletone_run(&ringback.ts, ringback_data)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Playing Tone\n"); + teletone_destroy_session(&ringback.ts); + switch_buffer_destroy(&ringback.audio_buffer); + ringback_data = NULL; + } + } + switch_safe_free(tmp_data); + + } + + + if (ringback_data && !switch_channel_test_flag(caller_channel, CF_ANSWERED) && !switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)) { + switch_channel_pre_answer(caller_channel); + } + + if ((read_codec = switch_core_session_get_read_codec(session)) && (ringback_data || !switch_channel_test_flag(caller_channel, CF_BYPASS_MEDIA))) { + if (!(pass = (uint8_t) switch_test_flag(read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH))) { + if (switch_core_codec_init(&write_codec, + "L16", + NULL, + read_codec->implementation->actual_samples_per_second, + read_codec->implementation->microseconds_per_frame / 1000, + 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, + switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) { + + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, + "Raw Codec Activation Success L16@%uhz 1 channel %dms\n", + read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_frame / 1000); + write_frame.data = abuf; + write_frame.buflen = sizeof(abuf); + + write_frame.codec = &write_codec; + write_frame.datalen = read_codec->implementation->bytes_per_frame; + write_frame.samples = write_frame.datalen / 2; + memset(write_frame.data, 255, write_frame.datalen); + + if (ringback_data) { + char *tmp_data = NULL; + + switch_buffer_create_dynamic(&ringback.audio_buffer, 512, 1024, 0); + switch_buffer_set_loops(ringback.audio_buffer, -1); + + if (switch_is_file_path(ringback_data)) { + char *ext; + + if (strrchr(ringback_data, '.') || strstr(ringback_data, SWITCH_URL_SEPARATOR)) { + switch_core_session_set_read_codec(session, &write_codec); + } else { + ringback.asis++; + write_frame.codec = read_codec; + ext = read_codec->implementation->iananame; + tmp_data = switch_mprintf("%s.%s", ringback_data, ext); + ringback_data = tmp_data; + } + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Play Ringback File [%s]\n", ringback_data); + + ringback.fhb.channels = read_codec->implementation->number_of_channels; + ringback.fhb.samplerate = read_codec->implementation->actual_samples_per_second; + if (switch_core_file_open(&ringback.fhb, + ringback_data, + read_codec->implementation->number_of_channels, + read_codec->implementation->actual_samples_per_second, + SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, + switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Playing File\n"); + switch_safe_free(tmp_data); + goto done; + } + ringback.fh = &ringback.fhb; + + + } else { + teletone_init_session(&ringback.ts, 0, teletone_handler, &ringback); + ringback.ts.rate = read_codec->implementation->actual_samples_per_second; + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Play Ringback Tone [%s]\n", ringback_data); + //ringback.ts.debug = 1; + //ringback.ts.debug_stream = switch_core_get_console(); + if (teletone_run(&ringback.ts, ringback_data)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Playing Tone\n"); + teletone_destroy_session(&ringback.ts); + switch_buffer_destroy(&ringback.audio_buffer); + ringback_data = NULL; + } + } + switch_safe_free(tmp_data); + } + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec Error!\n"); + switch_channel_hangup(caller_channel, SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE); + read_codec = NULL; + } + } + } + + while (!(switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA))) { + int diff = (int)(switch_timestamp_now() - start); + + if (diff > timelimit) { + status = SWITCH_STATUS_TIMEOUT; + goto done; + } + + if (switch_core_session_dequeue_message(peer_session, &message) == SWITCH_STATUS_SUCCESS) { + switch_core_session_receive_message(session, message); + + if (switch_test_flag(message, SCSMF_DYNAMIC)) { + switch_safe_free(message); + } else { + message = NULL; + } + } + status = switch_core_session_read_frame(session, &read_frame, 1000, 0); + if (!SWITCH_READ_ACCEPTABLE(status)) { + break; + } + + + if (read_frame && !pass) { + if (ringback.fh) { + uint8_t abuf[1024]; + switch_size_t mlen, olen; + unsigned int pos = 0; + + if (ringback.asis) { + mlen = write_frame.codec->implementation->encoded_bytes_per_frame; + } else { + mlen = write_frame.codec->implementation->samples_per_frame; + } + + olen = mlen; + switch_core_file_read(ringback.fh, abuf, &olen); + + if (olen == 0) { + olen = mlen; + ringback.fh->speed = 0; + switch_core_file_seek(ringback.fh, &pos, 0, SEEK_SET); + switch_core_file_read(ringback.fh, abuf, &olen); + if (olen == 0) { + break; + } + } + write_frame.data = abuf; + write_frame.datalen = (uint32_t) (ringback.asis ? olen : olen * 2); + } else if (ringback.audio_buffer) { + if ((write_frame.datalen = (uint32_t) switch_buffer_read_loop(ringback.audio_buffer, + write_frame.data, + write_frame.codec->implementation->bytes_per_frame)) <= 0) { + break; + } + } + + if (switch_core_session_write_frame(session, &write_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) { + break; + } + } else { + switch_yield(1000); + } + } + + done: + + if (ringback.fh) { + switch_core_file_close(ringback.fh); + ringback.fh = NULL; + } else if (ringback.audio_buffer) { + teletone_destroy_session(&ringback.ts); + switch_buffer_destroy(&ringback.audio_buffer); + } + + if (!pass && write_codec.implementation) { + if (read_codec && !ringback.asis) { + switch_core_session_set_read_codec(session, read_codec); + switch_core_session_reset(session); + } + switch_core_codec_destroy(&write_codec); + } + + return status; + +} + #define MAX_PEERS 128 SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *session, switch_core_session_t **bleg, @@ -608,8 +892,8 @@ peer_sessions[i] = new_session; peer_channels[i] = switch_core_session_get_channel(new_session); switch_assert(peer_channels[i] != NULL); - - + switch_channel_set_flag(peer_channels[i], CF_ORIGINATING); + if (var_event) { switch_event_t *event; switch_event_header_t *header; @@ -888,6 +1172,14 @@ if (!peer_channels[i]) { continue; } + + if (switch_channel_test_flag(peer_channels[i], CF_TRANSFER) || switch_channel_test_flag(peer_channels[i], CF_BRIDGED) || + switch_channel_get_state(peer_channels[i]) == CS_RESET || + !switch_channel_test_flag(peer_channels[i], CF_ORIGINATING) + ) { + continue; + } + if (i != idx) { if (idx == IDX_CANCEL) { if (to) { @@ -916,6 +1208,7 @@ peer_channel = peer_channels[idx]; } else { status = SWITCH_STATUS_FALSE; + peer_channel = NULL; goto done; } @@ -968,6 +1261,10 @@ } } + if (*cause == SWITCH_CAUSE_SUCCESS || *cause == SWITCH_CAUSE_UNALLOCATED) { + *cause = SWITCH_CAUSE_ORIGINATOR_CANCEL; + } + if (idx == IDX_CANCEL) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Originate Cancelled by originator termination Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause)); @@ -982,26 +1279,28 @@ switch_channel_set_variable(caller_channel, "originate_disposition", switch_channel_cause2str(*cause)); } - if (!pass && write_codec.implementation) { - switch_core_codec_destroy(&write_codec); - } - if (ringback.fh) { switch_core_file_close(ringback.fh); ringback.fh = NULL; + } else if (ringback.audio_buffer) { + teletone_destroy_session(&ringback.ts); + switch_buffer_destroy(&ringback.audio_buffer); + } + + if (!pass && write_codec.implementation) { if (read_codec && !ringback.asis) { switch_core_session_set_read_codec(session, read_codec); switch_core_session_reset(session); } - } else if (ringback.audio_buffer) { - teletone_destroy_session(&ringback.ts); - switch_buffer_destroy(&ringback.audio_buffer); + switch_core_codec_destroy(&write_codec); } + for (i = 0; i < and_argc; i++) { if (!peer_channels[i]) { continue; } + switch_channel_clear_flag(peer_channels[i], CF_ORIGINATING); if (status == SWITCH_STATUS_SUCCESS && bleg && *bleg && *bleg == peer_sessions[i]) { continue; }