Bug Summary

File:src/switch_ivr_originate.c
Location:line 1520, column 9
Description:Dereference of null pointer (loaded from variable 'data')

Annotated Source Code

1/*
2 * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
3 * Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
4 *
5 * Version: MPL 1.1
6 *
7 * The contents of this file are subject to the Mozilla Public License Version
8 * 1.1 (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
10 * http://www.mozilla.org/MPL/
11 *
12 * Software distributed under the License is distributed on an "AS IS" basis,
13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14 * for the specific language governing rights and limitations under the
15 * License.
16 *
17 * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
18 *
19 * The Initial Developer of the Original Code is
20 * Anthony Minessale II <anthm@freeswitch.org>
21 * Portions created by the Initial Developer are Copyright (C)
22 * the Initial Developer. All Rights Reserved.
23 *
24 * Contributor(s):
25 *
26 * Anthony Minessale II <anthm@freeswitch.org>
27 * Michael Jerris <mike@jerris.com>
28 * Travis Cross <tc@traviscross.com>
29 *
30 * switch_ivr_originate.c -- IVR Library (originate)
31 *
32 */
33
34#include <switch.h>
35#define QUOTED_ESC_COMMA1 1
36#define UNQUOTED_ESC_COMMA2 2
37
38static const switch_state_handler_table_t originate_state_handlers;
39
40static switch_status_t originate_on_consume_media_transmit(switch_core_session_t *session)
41{
42 switch_channel_t *channel = switch_core_session_get_channel(session);
43
44 if (!switch_channel_test_flag(channel, CF_PROXY_MODE) && switch_channel_test_flag(channel, CF_CONSUME_ON_ORIGINATE)) {
45 while (switch_channel_test_flag(channel, CF_ORIGINATING) &&
46 switch_channel_get_state(channel) == CS_CONSUME_MEDIA && !switch_channel_test_flag(channel, CF_TAGGED)) {
47 if (!switch_channel_media_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_TRUE)) {
48 switch_yield(10000)switch_sleep(10000);;
49 } else {
50 switch_ivr_sleep(session, 10, SWITCH_FALSE, NULL((void*)0));
51 }
52 switch_ivr_parse_all_messages(session);
53 }
54 }
55
56 switch_channel_clear_state_handler(channel, &originate_state_handlers);
57
58 return SWITCH_STATUS_FALSE;
59}
60
61static switch_status_t originate_on_routing(switch_core_session_t *session)
62{
63 switch_channel_t *channel = switch_core_session_get_channel(session);
64
65 if (switch_channel_get_state(channel) == CS_ROUTING) {
66 /* put the channel in a passive state until it is answered */
67 switch_channel_set_state(channel, CS_CONSUME_MEDIA)switch_channel_perform_set_state(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 67, CS_CONSUME_MEDIA);
68 }
69
70 return SWITCH_STATUS_FALSE;
71}
72
73static const switch_state_handler_table_t originate_state_handlers = {
74 /*.on_init */ NULL((void*)0),
75 /*.on_routing */ originate_on_routing,
76 /*.on_execute */ NULL((void*)0),
77 /*.on_hangup */ NULL((void*)0),
78 /*.on_exchange_media */ NULL((void*)0),
79 /*.on_soft_execute */ originate_on_consume_media_transmit,
80 /*.on_consume_media */ originate_on_consume_media_transmit
81};
82
83
84typedef struct {
85 switch_core_session_t *peer_session;
86 switch_channel_t *peer_channel;
87 switch_caller_profile_t *caller_profile;
88 uint8_t ring_ready;
89 uint8_t early_media;
90 uint8_t answered;
91 uint8_t tagged;
92 uint32_t per_channel_timelimit_sec;
93 uint32_t per_channel_progress_timelimit_sec;
94 uint32_t per_channel_delay_start;
95} originate_status_t;
96
97
98typedef struct {
99 switch_core_session_t *session;
100 int32_t idx;
101 uint32_t hups;
102 char *file;
103 char *error_file;
104 int confirm_timeout;
105 char key[80];
106 uint8_t early_ok;
107 uint8_t ring_ready;
108 uint8_t instant_ringback;
109 uint8_t sent_ring;
110 uint8_t progress;
111 uint8_t return_ring_ready;
112 uint8_t monitor_early_media_ring;
113 uint8_t monitor_early_media_fail;
114 uint8_t gen_ringback;
115 uint8_t ignore_early_media;
116 uint8_t ignore_ring_ready;
117 int monitor_early_media_ring_count;
118 int monitor_early_media_ring_total;
119 int cancel_timeout;
120 int continue_on_timeout;
121 int ringback_ok;
122 int sending_ringback;
123 int bridge_early_media;
124 switch_thread_t *ethread;
125 switch_caller_profile_t *caller_profile_override;
126 switch_bool_t check_vars;
127 switch_memory_pool_t *pool;
128} originate_global_t;
129
130
131
132typedef enum {
133 IDX_XFER = -5,
134 IDX_KEY_CANCEL = -4,
135 IDX_TIMEOUT = -3,
136 IDX_CANCEL = -2,
137 IDX_NADA = -1
138} abort_t;
139
140struct key_collect {
141 char *key;
142 char *file;
143 char *error_file;
144 int confirm_timeout;
145 switch_core_session_t *session;
146};
147
148static void *SWITCH_THREAD_FUNC collect_thread_run(switch_thread_t *thread, void *obj)
149{
150 struct key_collect *collect = (struct key_collect *) obj;
151 switch_channel_t *channel = switch_core_session_get_channel(collect->session);
152 char buf[10] = SWITCH_BLANK_STRING"";
153 switch_application_interface_t *application_interface = NULL((void*)0);
154
155 if (collect->session) {
156 if (switch_core_session_read_lock(collect->session) != SWITCH_STATUS_SUCCESS) {
157 return NULL((void*)0);
158 }
159 } else {
160 return NULL((void*)0);
161 }
162
163 switch_ivr_sleep(collect->session, 0, SWITCH_TRUE, NULL((void*)0));
164
165 if (!strcasecmp(collect->key, "exec")) {
166 char *data;
167 char *app_name, *app_data;
168
169 if (!(data = collect->file)) {
170 goto wbreak;
171 }
172
173 app_name = data;
174
175 if ((app_data = strchr(app_name, ' ')(__extension__ (__builtin_constant_p (' ') && !__builtin_constant_p
(app_name) && (' ') == '\0' ? (char *) __rawmemchr (
app_name, ' ') : __builtin_strchr (app_name, ' '))))) {
176 *app_data++ = '\0';
177 }
178
179 if ((application_interface = switch_loadable_module_get_application_interface(app_name)) == 0) {
180 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(collect->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 180, (const char*)(collect->session), SWITCH_LOG_ERROR, "Invalid Application %s\n", app_name);
181 switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 181, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
182 goto wbreak;
183 }
184
185 if (!application_interface->application_function) {
186 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(collect->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 186, (const char*)(collect->session), SWITCH_LOG_ERROR, "No Function for %s\n", app_name);
187 switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 187, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
188 goto wbreak;
189 }
190
191 switch_core_session_exec(collect->session, application_interface, app_data);
192
193 if (switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
194 switch_channel_set_flag(channel, CF_WINNER)switch_channel_set_flag_value(channel, CF_WINNER, 1);
195 switch_channel_set_variable(channel, "group_dial_status", "winner")switch_channel_set_variable_var_check(channel, "group_dial_status"
, "winner", SWITCH_TRUE);
196 }
197 goto wbreak;
198 }
199
200 if (!switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
201 switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 201, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
202 goto wbreak;
203 }
204
205 while (switch_channel_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_FALSE)) {
206 switch_size_t len = strlen(collect->key);
207 const char *file = collect->file;
208 switch_status_t status;
209
210 memset(buf, 0, sizeof(buf));
211
212 if (zstr(file)_zstr(file)) {
213 file = "silence";
214 }
215
216 status = switch_ivr_read(collect->session,
217 (uint32_t)len,
218 (uint32_t)len,
219 collect->file, NULL((void*)0), buf, sizeof(buf), collect->confirm_timeout, NULL((void*)0), 0);
220
221
222 if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK && status != SWITCH_STATUS_TOO_SMALL) {
223 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(collect->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 223, (const char*)(collect->session), SWITCH_LOG_ERROR, "%s Error Playing File!\n",
224 switch_channel_get_name(channel));
225 switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 225, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
226 }
227
228 if (!strcmp(collect->key, buf)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(collect->key) && __builtin_constant_p (buf) &&
(__s1_len = __builtin_strlen (collect->key), __s2_len = __builtin_strlen
(buf), (!((size_t)(const void *)((collect->key) + 1) - (size_t
)(const void *)(collect->key) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)((buf) + 1) - (size_t)(const void *
)(buf) == 1) || __s2_len >= 4)) ? __builtin_strcmp (collect
->key, buf) : (__builtin_constant_p (collect->key) &&
((size_t)(const void *)((collect->key) + 1) - (size_t)(const
void *)(collect->key) == 1) && (__s1_len = __builtin_strlen
(collect->key), __s1_len < 4) ? (__builtin_constant_p (
buf) && ((size_t)(const void *)((buf) + 1) - (size_t)
(const void *)(buf) == 1) ? __builtin_strcmp (collect->key
, buf) : (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (buf); int __result = (((const
unsigned char *) (const char *) (collect->key))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (collect->key)
)[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (collect
->key))[2] - __s2[2]); if (__s1_len > 2 && __result
== 0) __result = (((const unsigned char *) (const char *) (collect
->key))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(buf) && ((size_t)(const void *)((buf) + 1) - (size_t
)(const void *)(buf) == 1) && (__s2_len = __builtin_strlen
(buf), __s2_len < 4) ? (__builtin_constant_p (collect->
key) && ((size_t)(const void *)((collect->key) + 1
) - (size_t)(const void *)(collect->key) == 1) ? __builtin_strcmp
(collect->key, buf) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (collect
->key); int __result = (((const unsigned char *) (const char
*) (buf))[0] - __s2[0]); if (__s2_len > 0 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
buf))[1] - __s2[1]); if (__s2_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (buf
))[2] - __s2[2]); if (__s2_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (buf))[
3] - __s2[3]); } } __result; })))) : __builtin_strcmp (collect
->key, buf)))); })) {
229 switch_channel_set_flag(channel, CF_WINNER)switch_channel_set_flag_value(channel, CF_WINNER, 1);
230 switch_channel_set_variable(channel, "group_dial_status", "winner")switch_channel_set_variable_var_check(channel, "group_dial_status"
, "winner", SWITCH_TRUE);
231 goto wbreak;
232 } else if (collect->error_file) {
233 switch_ivr_play_file(collect->session, NULL((void*)0), collect->error_file, NULL((void*)0));
234 }
235 }
236 wbreak:
237
238 switch_core_session_rwunlock(collect->session);
239
240 UNPROTECT_INTERFACE(application_interface)if (application_interface) {switch_mutex_lock(application_interface
->reflock); switch_thread_rwlock_unlock(application_interface
->rwlock); switch_thread_rwlock_unlock(application_interface
->parent->rwlock); application_interface->refs--; application_interface
->parent->refs--; switch_mutex_unlock(application_interface
->reflock);};
241
242 return NULL((void*)0);
243}
244
245static void launch_collect_thread(struct key_collect *collect)
246{
247 switch_thread_t *thread;
248 switch_threadattr_t *thd_attr = NULL((void*)0);
249
250 switch_threadattr_create(&thd_attr, switch_core_session_get_pool(collect->session));
251 switch_threadattr_detach_set(thd_attr, 1);
252 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE240 * 1024);
253 switch_thread_create(&thread, thd_attr, collect_thread_run, collect, switch_core_session_get_pool(collect->session));
254}
255
256static int check_per_channel_timeouts(originate_global_t *oglobals,
257 originate_status_t *originate_status, int max, time_t start, switch_call_cause_t *force_reason)
258{
259 int x = 0, i, delayed_channels = 0, active_channels = 0;
260 uint32_t early_exit_time = 0, delayed_min = 0;
261
262 time_t elapsed = switch_epoch_time_now(NULL((void*)0)) - start;
263
264 if (oglobals->cancel_timeout > 0) {
265 return 0;
266 }
267 for (i = 0; i < max; i++) {
268 if (originate_status[i].peer_channel && switch_channel_get_state(originate_status[i].peer_channel) != CS_DESTROY &&
269 switch_channel_get_state(originate_status[i].peer_channel) != CS_REPORTING) {
270 if (originate_status[i].per_channel_delay_start) {
271 delayed_channels++;
272 } else {
273 active_channels++;
274 }
275 }
276 }
277
278 if (active_channels == 0 && delayed_channels) {
279 for (i = 0; i < max; i++) {
280 if (originate_status[i].peer_channel && originate_status[i].per_channel_delay_start &&
281 (!delayed_min || delayed_min > originate_status[i].per_channel_delay_start)) {
282 delayed_min = originate_status[i].per_channel_delay_start;
283 }
284 }
285 early_exit_time = delayed_min - (uint32_t) elapsed;
286 }
287 for (i = 0; i < max; i++) {
288 if (originate_status[i].peer_channel && originate_status[i].per_channel_delay_start &&
289 (elapsed > originate_status[i].per_channel_delay_start || active_channels == 0)) {
290 if (active_channels == 0) {
291 if (originate_status[i].per_channel_timelimit_sec) {
292 if (originate_status[i].per_channel_timelimit_sec > early_exit_time) {
293 /* IN theory this check is not needed ( should just be if !0 then -= with no else), if its not 0 it should always be greater.... */
294 originate_status[i].per_channel_timelimit_sec -= early_exit_time;
295 } else {
296 originate_status[i].per_channel_timelimit_sec = 1;
297 }
298 }
299 if (originate_status[i].per_channel_progress_timelimit_sec) {
300 if (originate_status[i].per_channel_progress_timelimit_sec > early_exit_time) {
301 /* IN theory this check is not needed ( should just be if !0 then -= with no else), if its not 0 it should always be greater.... */
302 originate_status[i].per_channel_progress_timelimit_sec -= early_exit_time;
303 } else {
304 originate_status[i].per_channel_progress_timelimit_sec = 1;
305 }
306 }
307 originate_status[i].per_channel_delay_start -= delayed_min;
308 } else {
309 originate_status[i].per_channel_delay_start = 0;
310 }
311
312 if (!originate_status[i].per_channel_delay_start) {
313 switch_channel_clear_flag(originate_status[i].peer_channel, CF_BLOCK_STATE);
314 }
315 }
316
317 if (originate_status[i].peer_channel && switch_channel_up_nosig(originate_status[i].peer_channel)(switch_channel_get_state(originate_status[i].peer_channel) <
CS_HANGUP)) {
318 if (originate_status[i].per_channel_progress_timelimit_sec && elapsed > originate_status[i].per_channel_progress_timelimit_sec &&
319 !(switch_channel_test_flag(originate_status[i].peer_channel, CF_RING_READY) ||
320 switch_channel_test_flag(originate_status[i].peer_channel, CF_ANSWERED) ||
321 (!oglobals->monitor_early_media_ring && switch_channel_test_flag(originate_status[i].peer_channel, CF_EARLY_MEDIA))
322 )
323 ) {
324 switch_channel_hangup(originate_status[i].peer_channel, SWITCH_CAUSE_PROGRESS_TIMEOUT)switch_channel_perform_hangup(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 324, SWITCH_CAUSE_PROGRESS_TIMEOUT
);
325 *force_reason = SWITCH_CAUSE_PROGRESS_TIMEOUT;
326 x++;
327 }
328 if (originate_status[i].per_channel_timelimit_sec && elapsed > originate_status[i].per_channel_timelimit_sec) {
329 switch_channel_hangup(originate_status[i].peer_channel, SWITCH_CAUSE_ALLOTTED_TIMEOUT)switch_channel_perform_hangup(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 329, SWITCH_CAUSE_ALLOTTED_TIMEOUT
);
330 x++;
331 }
332 }
333 }
334
335 return x;
336}
337
338static switch_bool_t monitor_callback(switch_core_session_t *session, const char *app, const char *data)
339{
340 if (app) {
341 switch_channel_t *channel = switch_core_session_get_channel(session);
342 if (!strcmp(app, "fail")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(app) && __builtin_constant_p ("fail") && (__s1_len
= __builtin_strlen (app), __s2_len = __builtin_strlen ("fail"
), (!((size_t)(const void *)((app) + 1) - (size_t)(const void
*)(app) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("fail") + 1) - (size_t)(const void *)("fail") == 1)
|| __s2_len >= 4)) ? __builtin_strcmp (app, "fail") : (__builtin_constant_p
(app) && ((size_t)(const void *)((app) + 1) - (size_t
)(const void *)(app) == 1) && (__s1_len = __builtin_strlen
(app), __s1_len < 4) ? (__builtin_constant_p ("fail") &&
((size_t)(const void *)(("fail") + 1) - (size_t)(const void *
)("fail") == 1) ? __builtin_strcmp (app, "fail") : (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) ("fail"); int __result = (((const unsigned char *) (
const char *) (app))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (app))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (app))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (app))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("fail") && ((size_t)(const void *)(("fail") + 1) - (
size_t)(const void *)("fail") == 1) && (__s2_len = __builtin_strlen
("fail"), __s2_len < 4) ? (__builtin_constant_p (app) &&
((size_t)(const void *)((app) + 1) - (size_t)(const void *)(
app) == 1) ? __builtin_strcmp (app, "fail") : (- (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (app); int __result = (((const unsigned char *) (const
char *) ("fail"))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("fail"))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("fail"))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) ("fail"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(app, "fail")))); })) {
343 const char *bd = switch_channel_get_variable(channel, "monitor_fail_dispo")switch_channel_get_variable_dup(channel, "monitor_fail_dispo"
, SWITCH_TRUE, -1);
344 if (!bd) {
345 bd = "monitor_early_media_fail";
346 }
347 switch_channel_set_variable(channel, "DIALSTATUS", "BUSY")switch_channel_set_variable_var_check(channel, "DIALSTATUS", "BUSY"
, SWITCH_TRUE);
348 switch_channel_set_variable(channel, "originate_disposition", bd)switch_channel_set_variable_var_check(channel, "originate_disposition"
, bd, SWITCH_TRUE);
349 switch_channel_hangup(channel, data ? switch_channel_str2cause(data) : SWITCH_CAUSE_USER_BUSY)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 349, data ? switch_channel_str2cause
(data) : SWITCH_CAUSE_USER_BUSY);
350 } else if (!strcmp(app, "ring")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(app) && __builtin_constant_p ("ring") && (__s1_len
= __builtin_strlen (app), __s2_len = __builtin_strlen ("ring"
), (!((size_t)(const void *)((app) + 1) - (size_t)(const void
*)(app) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("ring") + 1) - (size_t)(const void *)("ring") == 1)
|| __s2_len >= 4)) ? __builtin_strcmp (app, "ring") : (__builtin_constant_p
(app) && ((size_t)(const void *)((app) + 1) - (size_t
)(const void *)(app) == 1) && (__s1_len = __builtin_strlen
(app), __s1_len < 4) ? (__builtin_constant_p ("ring") &&
((size_t)(const void *)(("ring") + 1) - (size_t)(const void *
)("ring") == 1) ? __builtin_strcmp (app, "ring") : (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) ("ring"); int __result = (((const unsigned char *) (
const char *) (app))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (app))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (app))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (app))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("ring") && ((size_t)(const void *)(("ring") + 1) - (
size_t)(const void *)("ring") == 1) && (__s2_len = __builtin_strlen
("ring"), __s2_len < 4) ? (__builtin_constant_p (app) &&
((size_t)(const void *)((app) + 1) - (size_t)(const void *)(
app) == 1) ? __builtin_strcmp (app, "ring") : (- (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (app); int __result = (((const unsigned char *) (const
char *) ("ring"))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("ring"))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("ring"))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) ("ring"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(app, "ring")))); })) {
351 originate_global_t *oglobals = (originate_global_t *) switch_channel_get_private(channel, "_oglobals_");
352 const char *bd = switch_channel_get_variable(channel, "monitor_ring_dispo")switch_channel_get_variable_dup(channel, "monitor_ring_dispo"
, SWITCH_TRUE, -1);
353 if (!bd) {
354 bd = "monitor_early_media_ring";
355 }
356 switch_channel_set_variable(channel, "originate_disposition", bd)switch_channel_set_variable_var_check(channel, "originate_disposition"
, bd, SWITCH_TRUE);
357 switch_channel_set_variable(channel, "DIALSTATUS", "EARLY")switch_channel_set_variable_var_check(channel, "DIALSTATUS", "EARLY"
, SWITCH_TRUE);
358
359 if (oglobals) {
360 if (oglobals->monitor_early_media_ring_total && ++oglobals->monitor_early_media_ring_count < oglobals->monitor_early_media_ring_total) {
361 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 361, (const char*)(session), SWITCH_LOG_DEBUG, "Ring %d/%d\n",
362 oglobals->monitor_early_media_ring_count, oglobals->monitor_early_media_ring_total);
363 return SWITCH_TRUE;
364 }
365
366 switch_channel_set_private(channel, "_oglobals_", NULL((void*)0));
367
368 if (!oglobals->progress) {
369 oglobals->progress = 1;
370 }
371
372 if (!oglobals->ring_ready && !oglobals->ignore_ring_ready) {
373 oglobals->ring_ready = 1;
374 }
375
376 if (!oglobals->ignore_early_media && !oglobals->early_ok) {
377 oglobals->early_ok = 1;
378 }
379 }
380 }
381 }
382
383 return SWITCH_FALSE;
384}
385
386static void inherit_codec(switch_channel_t *caller_channel, switch_core_session_t *session)
387{
388 const char *var = switch_channel_get_variable(caller_channel, "inherit_codec")switch_channel_get_variable_dup(caller_channel, "inherit_codec"
, SWITCH_TRUE, -1);
389 switch_channel_t *channel = switch_core_session_get_channel(session);
390
391 if (!zstr(var)_zstr(var) && !strcasecmp(var, "passthru")) {
392 switch_channel_set_variable(caller_channel, "absolute_codec_string", switch_channel_get_variable(channel, "ep_codec_string"))switch_channel_set_variable_var_check(caller_channel, "absolute_codec_string"
, switch_channel_get_variable_dup(channel, "ep_codec_string",
SWITCH_TRUE, -1), SWITCH_TRUE);
393 } else if (switch_true(var)) {
394 switch_codec_implementation_t impl = { 0 };
395 switch_codec_implementation_t video_impl = { 0 };
396 char tmp[128] = "";
397
398 if (switch_core_session_get_read_impl(session, &impl) == SWITCH_STATUS_SUCCESS) {
399 const char *ep = switch_channel_get_variable(caller_channel, "ep_codec_string")switch_channel_get_variable_dup(caller_channel, "ep_codec_string"
, SWITCH_TRUE, -1);
400
401 if (switch_core_session_get_video_read_impl(session, &video_impl) == SWITCH_STATUS_SUCCESS) {
402 switch_snprintf(tmp, sizeof(tmp), "%s@%uh@%ui,%s",
403 impl.iananame, impl.samples_per_second, (uint32_t)impl.microseconds_per_packet / 1000,
404 video_impl.iananame);
405 } else {
406 switch_snprintf(tmp, sizeof(tmp), "%s@%uh@%ui",
407 impl.iananame, impl.samples_per_second, (uint32_t)impl.microseconds_per_packet / 1000);
408 }
409
410 if (ep && switch_stristr(impl.iananame, ep)) {
411 switch_channel_set_variable(caller_channel, "absolute_codec_string", tmp)switch_channel_set_variable_var_check(caller_channel, "absolute_codec_string"
, tmp, SWITCH_TRUE);
412 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 412, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_DEBUG, "Setting codec string on %s to %s\n",
413 switch_channel_get_name(caller_channel), tmp);
414 } else {
415 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 415, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_DEBUG, "Codec string %s not supported on %s, skipping inheritance\n",
416 tmp, switch_channel_get_name(caller_channel));
417 }
418 } else {
419 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 419, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_WARNING,
420 "Error inheriting codec. Channel %s has no read codec yet.\n",
421 switch_channel_get_name(channel));
422 }
423
424 }
425}
426
427static uint8_t check_channel_status(originate_global_t *oglobals, originate_status_t *originate_status, uint32_t len, switch_call_cause_t *force_reason)
428{
429
430 uint32_t i;
431 uint8_t rval = 0;
432 switch_channel_t *caller_channel = NULL((void*)0);
433 int pindex = -1;
434 char bug_key[256] = "";
435 int send_ringback = 0;
436 uint8_t ring_ready_val = 0;
437 int pickups = 0;
438
439 oglobals->hups = 0;
440 oglobals->idx = IDX_NADA;
441
442
443 if (oglobals->session) {
444 caller_channel = switch_core_session_get_channel(oglobals->session);
445 if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
446 caller_channel = NULL((void*)0);
447 }
448 }
449
450
451 for (i = 0; i < len; i++) {
452 if (originate_status[i].peer_channel && switch_channel_test_flag(originate_status[i].peer_channel, CF_CHANNEL_SWAP)) {
453 const char *key = switch_channel_get_variable(originate_status[i].peer_channel, "channel_swap_uuid")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "channel_swap_uuid", SWITCH_TRUE, -1);
454 switch_core_session_t *swap_session, *old_session;
455
456 if ((swap_session = switch_core_session_locate(key)switch_core_session_perform_locate(key, "src/switch_ivr_originate.c"
, (const char *)__func__, 456))) {
457 switch_channel_clear_flag(originate_status[i].peer_channel, CF_CHANNEL_SWAP);
458 switch_channel_hangup(originate_status[i].peer_channel, SWITCH_CAUSE_PICKED_OFF)switch_channel_perform_hangup(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 458, SWITCH_CAUSE_PICKED_OFF
);
459
460 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(originate_status[i].peer_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 460, (const char*)switch_channel_get_session
(originate_status[i].peer_channel), SWITCH_LOG_DEBUG, "Swapping %s for %s\n",
461 switch_core_session_get_name(swap_session)switch_channel_get_name(switch_core_session_get_channel(swap_session
)), switch_channel_get_name(originate_status[i].peer_channel));
462
463
464 old_session = originate_status[i].peer_session;
465 originate_status[i].peer_session = swap_session;
466 originate_status[i].peer_channel = switch_core_session_get_channel(originate_status[i].peer_session);
467 originate_status[i].caller_profile = switch_channel_get_caller_profile(originate_status[i].peer_channel);
468 switch_channel_set_flag(originate_status[i].peer_channel, CF_ORIGINATING)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_ORIGINATING, 1);
469
470 switch_channel_answer(originate_status[i].peer_channel)switch_channel_perform_answer(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 470);
471
472 switch_channel_set_variable(originate_status[i].peer_channel, "picked_up_uuid", switch_core_session_get_uuid(old_session))switch_channel_set_variable_var_check(originate_status[i].peer_channel
, "picked_up_uuid", switch_core_session_get_uuid(old_session)
, SWITCH_TRUE);
473 switch_channel_execute_on(originate_status[i].peer_channel, "execute_on_pickup");
474 switch_channel_api_on(originate_status[i].peer_channel, "api_on_pickup");
475
476 switch_core_session_rwunlock(old_session);
477 break;
478 }
479 }
480 }
481
482 for (i = 0; i < len; i++) {
483 switch_channel_state_t state;
484
485 if (originate_status[i].tagged && originate_status[i].peer_session) {
486 switch_channel_t *channel = switch_core_session_get_channel(originate_status[i].peer_session);
487 uint32_t j;
488
489 if (switch_channel_down_nosig(channel)(switch_channel_get_state(channel) >= CS_HANGUP)) {
490 switch_call_cause_t cause = switch_channel_get_cause(channel);
491
492 for (j = 0; j < len; j++) {
493 channel = switch_core_session_get_channel(originate_status[j].peer_session);
494 switch_channel_hangup(channel, cause)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 494, cause);
495 }
496 oglobals->hups = len;
497 rval = 0;
498 goto end;
499 }
500 }
501
502
503 if (originate_status[i].peer_channel && switch_channel_test_flag(originate_status[i].peer_channel, CF_PICKUP)) {
504 pickups++;
505 }
506
507 if (!(originate_status[i].peer_channel && originate_status[i].peer_session)) {
508 oglobals->hups++;
509 continue;
510 }
511
512 if ((ring_ready_val = (uint8_t)switch_channel_test_flag(originate_status[i].peer_channel, CF_RING_READY))) {
513 if (!originate_status[i].ring_ready) {
514 originate_status[i].ring_ready = ring_ready_val;
515 }
516
517 if (oglobals->sending_ringback == 1) {
518 send_ringback++;
519 pindex = (uint32_t) i;
520 } else {
521 if (!oglobals->ring_ready) {
522 oglobals->ring_ready = ring_ready_val;
523 if (caller_channel && !oglobals->ignore_ring_ready) {
524 if (len == 1) {
525 switch_channel_pass_callee_id(originate_status[0].peer_channel, caller_channel);
526 }
527 switch_channel_ring_ready_value(caller_channel, ring_ready_val)switch_channel_perform_ring_ready_value(caller_channel, ring_ready_val
, "src/switch_ivr_originate.c", (const char *)__func__, 527);
528 oglobals->sent_ring = ring_ready_val;
529 }
530 }
531 }
532 }
533
534 if (switch_channel_test_flag(originate_status[i].peer_channel, CF_EARLY_MEDIA)) {
535
536 if (oglobals->ignore_early_media == 3 && oglobals->bridge_early_media == -1) {
537 oglobals->bridge_early_media = i;
538 oglobals->ringback_ok = 1;
539 }
540
541 if (oglobals->sending_ringback == 1) {
542 send_ringback++;
543 pindex = (uint32_t) i;
544 } else if (!oglobals->sent_ring && oglobals->ignore_early_media == 2 && len == 1 && caller_channel && !oglobals->ignore_ring_ready) {
545 switch_channel_pass_callee_id(originate_status[0].peer_channel, caller_channel);
546 switch_channel_ring_ready(caller_channel)switch_channel_perform_ring_ready_value(caller_channel, SWITCH_RING_READY_RINGING
, "src/switch_ivr_originate.c", (const char *)__func__, 546);
547 oglobals->sent_ring = 1;
548 }
549
550 if (!originate_status[i].early_media) {
551 originate_status[i].early_media = 1;
552 if (oglobals->early_ok) {
553 pindex = i;
554 }
555
556 if (oglobals->monitor_early_media_fail) {
557 const char *var = switch_channel_get_variable(originate_status[i].peer_channel, "monitor_early_media_fail")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "monitor_early_media_fail", SWITCH_TRUE, -1);
558 if (!zstr(var)_zstr(var)) {
559 char *fail_array[128] = { 0 };
560 int fail_count = 0;
561 char *fail_data = strdup(var)(__extension__ (__builtin_constant_p (var) && ((size_t
)(const void *)((var) + 1) - (size_t)(const void *)(var) == 1
) ? (((const char *) (var))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (var) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, var, __len); __retval
; })) : __strdup (var)));
562 int fx;
563 int y = 0;
564
565 switch_assert(fail_data)((fail_data) ? (void) (0) : __assert_fail ("fail_data", "src/switch_ivr_originate.c"
, 565, __PRETTY_FUNCTION__));
566 fail_count = switch_separate_string(fail_data, '!', fail_array, (sizeof(fail_array) / sizeof(fail_array[0])));
567
568 for (fx = 0; fx < fail_count; fx++) {
569 char *cause = fail_array[fx];
570 int hits = 2;
571 char *p, *q;
572
573 if (!(p = strchr(cause, ':')(__extension__ (__builtin_constant_p (':') && !__builtin_constant_p
(cause) && (':') == '\0' ? (char *) __rawmemchr (cause
, ':') : __builtin_strchr (cause, ':'))))) {
574 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 574, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
575 continue;
576 }
577 *p++ = '\0';
578
579
580 if (!p) {
581 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 581, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
582 continue;
583 }
584
585
586 if (!(hits = atoi(p))) {
587 hits = 2;
588 }
589
590
591 if (!(p = strchr(p, ':')(__extension__ (__builtin_constant_p (':') && !__builtin_constant_p
(p) && (':') == '\0' ? (char *) __rawmemchr (p, ':')
: __builtin_strchr (p, ':'))))) {
592 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 592, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
593 continue;
594 }
595 *p++ = '\0';
596
597 if (!p) {
598 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 598, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
599 continue;
600 }
601
602 for (q = p; q && *q; q++) {
603 if (*q == '+') {
604 *q = ',';
605 }
606 }
607 switch_snprintf(bug_key, sizeof(bug_key), "monitor_early_media_fail_%d", ++y);
608 switch_ivr_tone_detect_session(originate_status[i].peer_session, bug_key, p, "r", 0, hits, "fail", cause, monitor_callback);
609
610 }
611
612 switch_safe_free(fail_data)if (fail_data) {free(fail_data);fail_data=((void*)0);};
613
614 }
615 }
616
617 if (oglobals->monitor_early_media_ring) {
618 const char *var = switch_channel_get_variable(originate_status[i].peer_channel, "monitor_early_media_ring")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "monitor_early_media_ring", SWITCH_TRUE, -1);
619 const char *var_total = switch_channel_get_variable(originate_status[i].peer_channel, "monitor_early_media_ring_total")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "monitor_early_media_ring_total", SWITCH_TRUE, -1);
620 if (!zstr(var)_zstr(var)) {
621 char *ring_array[128] = { 0 };
622 int ring_count = 0;
623 char *ring_data = strdup(var)(__extension__ (__builtin_constant_p (var) && ((size_t
)(const void *)((var) + 1) - (size_t)(const void *)(var) == 1
) ? (((const char *) (var))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (var) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, var, __len); __retval
; })) : __strdup (var)));
624 int fx;
625 int y = 0;
626
627 switch_assert(ring_data)((ring_data) ? (void) (0) : __assert_fail ("ring_data", "src/switch_ivr_originate.c"
, 627, __PRETTY_FUNCTION__));
628 ring_count = switch_separate_string(ring_data, '!', ring_array, (sizeof(ring_array) / sizeof(ring_array[0])));
629
630 for (fx = 0; fx < ring_count; fx++) {
631 int hits = 2;
632 char *p = ring_array[fx], *q;
633
634 if (!p) {
635 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 635, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
636 continue;
637 }
638
639 if (!(hits = atoi(p))) {
640 hits = 2;
641 }
642
643 if (!(p = strchr(p, ':')(__extension__ (__builtin_constant_p (':') && !__builtin_constant_p
(p) && (':') == '\0' ? (char *) __rawmemchr (p, ':')
: __builtin_strchr (p, ':'))))) {
644 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 644, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
645 continue;
646 }
647 *p++ = '\0';
648
649 if (!p) {
650 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 650, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_ERROR, "Parse Error\n");
651 continue;
652 }
653
654 for (q = p; q && *q; q++) {
655 if (*q == '+') {
656 *q = ',';
657 }
658 }
659
660 switch_channel_set_private(originate_status[i].peer_channel, "_oglobals_", oglobals);
661 switch_snprintf(bug_key, sizeof(bug_key), "monitor_early_media_ring_%d", ++y);
662 switch_ivr_tone_detect_session(originate_status[i].peer_session, bug_key, p, "r", 0, hits, "ring", NULL((void*)0), monitor_callback);
663
664 }
665
666 if (var_total) {
667 int tmp = atoi(var_total);
668 if (tmp > 0 && tmp < 100) {
669 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originate_status[i].peer_session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 669, (const char*)(originate_status[i].peer_session
), SWITCH_LOG_DEBUG,
670 "%s setting ring total to %d\n", switch_channel_get_name(originate_status[i].peer_channel), tmp);
671 oglobals->monitor_early_media_ring_total = tmp;
672 }
673 }
674
675 switch_safe_free(ring_data)if (ring_data) {free(ring_data);ring_data=((void*)0);};
676
677 }
678 }
679 }
680
681 if (!oglobals->monitor_early_media_ring) {
682
683 if (!oglobals->progress) {
684 oglobals->progress = 1;
685 }
686
687 if (!oglobals->ring_ready && !oglobals->ignore_ring_ready) {
688 oglobals->ring_ready = 1;
689
690 }
691 }
692 }
693
694 if (!switch_channel_test_flag(originate_status[i].peer_channel, CF_PARK) &&
695 !switch_channel_test_flag(originate_status[i].peer_channel, CF_CONSUME_ON_ORIGINATE)) {
696 if (switch_core_session_messages_waiting(originate_status[i].peer_session)) {
697 if (switch_channel_test_flag(originate_status[i].peer_channel, CF_THREAD_SLEEPING)) {
698 switch_core_session_wake_session_thread(originate_status[i].peer_session);
699 } else {
700 switch_ivr_parse_all_events(originate_status[i].peer_session);
701 }
702 }
703 }
704
705 if (switch_channel_test_flag(originate_status[i].peer_channel, CF_EARLY_OK)) {
706 if (!oglobals->early_ok) {
707 oglobals->early_ok = 1;
708 }
709 switch_channel_clear_flag(originate_status[i].peer_channel, CF_EARLY_OK);
710 }
711
712 if (caller_channel && switch_channel_test_flag(caller_channel, CF_EARLY_OK)) {
713 if (!oglobals->early_ok) {
714 oglobals->early_ok = 1;
715 }
716 switch_channel_clear_flag(caller_channel, CF_EARLY_OK);
717 }
718
719 state = switch_channel_get_state(originate_status[i].peer_channel);
720 if (state >= CS_HANGUP || state == CS_RESET || switch_channel_test_flag(originate_status[i].peer_channel, CF_TRANSFER) ||
721 switch_channel_test_flag(originate_status[i].peer_channel, CF_REDIRECT) ||
722 switch_channel_test_flag(originate_status[i].peer_channel, CF_BRIDGED) ||
723 !switch_channel_test_flag(originate_status[i].peer_channel, CF_ORIGINATING)
724 ) {
725 (oglobals->hups)++;
726 if (switch_channel_test_flag(originate_status[i].peer_channel, CF_PICKUP)) {
727 pickups--;
728 }
729 } else if ((switch_channel_test_flag(originate_status[i].peer_channel, CF_ANSWERED) ||
730 (oglobals->early_ok && switch_channel_test_flag(originate_status[i].peer_channel, CF_EARLY_MEDIA)) ||
731 (oglobals->ring_ready && oglobals->return_ring_ready && len == 1 &&
732 switch_channel_test_flag(originate_status[i].peer_channel, CF_RING_READY))
733 )
734 && !switch_channel_test_flag(originate_status[i].peer_channel, CF_TAGGED)
735 ) {
736
737 if (!zstr(oglobals->key)_zstr(oglobals->key)) {
738 struct key_collect *collect;
739
740 if (oglobals->cancel_timeout < 0) {
741 oglobals->cancel_timeout = 1;
742 }
743
744 if ((collect = switch_core_session_alloc(originate_status[i].peer_session, sizeof(*collect))switch_core_perform_session_alloc(originate_status[i].peer_session
, sizeof(*collect), "src/switch_ivr_originate.c", (const char
*)__func__, 744))) {
745 switch_channel_set_flag(originate_status[i].peer_channel, CF_TAGGED)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_TAGGED, 1);
746 if (!zstr(oglobals->key)_zstr(oglobals->key)) {
747 collect->key = switch_core_session_strdup(originate_status[i].peer_session, oglobals->key)switch_core_perform_session_strdup(originate_status[i].peer_session
, oglobals->key, "src/switch_ivr_originate.c", (const char
*)__func__, 747);
748 }
749 if (!zstr(oglobals->file)_zstr(oglobals->file)) {
750 collect->file = switch_core_session_strdup(originate_status[i].peer_session, oglobals->file)switch_core_perform_session_strdup(originate_status[i].peer_session
, oglobals->file, "src/switch_ivr_originate.c", (const char
*)__func__, 750);
751 }
752 if (!zstr(oglobals->error_file)_zstr(oglobals->error_file)) {
753 collect->error_file = switch_core_session_strdup(originate_status[i].peer_session, oglobals->error_file)switch_core_perform_session_strdup(originate_status[i].peer_session
, oglobals->error_file, "src/switch_ivr_originate.c", (const
char *)__func__, 753);
754 }
755
756 if (oglobals->confirm_timeout) {
757 collect->confirm_timeout = oglobals->confirm_timeout;
758 } else {
759 collect->confirm_timeout = 5000;
760 }
761
762 switch_channel_audio_sync(originate_status[i].peer_channel)switch_channel_perform_audio_sync(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 762);
763 collect->session = originate_status[i].peer_session;
764 launch_collect_thread(collect);
765 }
766 } else {
767 oglobals->idx = i;
768 pindex = (uint32_t) i;
769 rval = 0;
770 goto end;
771
772 }
773 } else if (switch_channel_test_flag(originate_status[i].peer_channel, CF_WINNER)) {
774 oglobals->idx = i;
775 rval = 0;
776 pindex = (uint32_t) i;
777 goto end;
778 }
779 }
780
781 if (oglobals->hups > 0 && oglobals->hups + pickups == len) {
782 rval = 0;
783 } else {
784 rval = 1;
785 }
786
787 end:
788
789 if (rval == 0 && pickups) {
790 for (i = 0; i < len; i++) {
791 if (originate_status[i].peer_channel && switch_channel_test_flag(originate_status[i].peer_channel, CF_PICKUP) &&
792 switch_channel_up(originate_status[i].peer_channel)(switch_channel_check_signal(originate_status[i].peer_channel
, SWITCH_TRUE) || switch_channel_get_state(originate_status[i
].peer_channel) < CS_HANGUP)) {
793 switch_channel_hangup(originate_status[i].peer_channel, SWITCH_CAUSE_NO_PICKUP)switch_channel_perform_hangup(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 793, SWITCH_CAUSE_NO_PICKUP
);
794 }
795 }
796 }
797
798
799 if (pindex > -1 && caller_channel && switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
) && !switch_channel_media_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_TRUE
) &&
800 switch_channel_media_ready(originate_status[pindex].peer_channel)switch_channel_test_ready(originate_status[pindex].peer_channel
, SWITCH_TRUE, SWITCH_TRUE)) {
801 inherit_codec(caller_channel, originate_status[pindex].peer_session);
802 }
803
804 if (send_ringback) {
805 oglobals->sending_ringback++;
806 }
807
808 return rval;
809
810}
811
812struct ringback {
813 switch_buffer_t *audio_buffer;
814 teletone_generation_session_t ts;
815 switch_file_handle_t fhb;
816 switch_file_handle_t *fh;
817 int silence;
818 uint8_t asis;
819};
820
821typedef struct ringback ringback_t;
822
823static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map)
824{
825 ringback_t *tto = ts->user_data;
826 int wrote;
827
828 if (!tto) {
829 return -1;
830 }
831 wrote = teletone_mux_tones(ts, map);
832 switch_buffer_write(tto->audio_buffer, ts->buffer, wrote * 2);
833
834 return 0;
835}
836
837
838SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_ivr_wait_for_answer(switch_core_session_t *session, switch_core_session_t *peer_session)
839{
840 switch_channel_t *caller_channel = NULL((void*)0);
841 switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);
842 const char *ringback_data = NULL((void*)0);
843 switch_frame_t write_frame = { 0 };
844 switch_codec_t write_codec = { 0 };
845 switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
846 uint8_t pass = 0;
847 ringback_t ringback = { 0 };
848 switch_frame_t *read_frame = NULL((void*)0);
849 switch_status_t status = SWITCH_STATUS_SUCCESS;
850 int timelimit = 60;
851 const char *var;
852 switch_time_t start = 0;
853 const char *cancel_key = NULL((void*)0);
854 switch_channel_state_t wait_state = 0;
855
856 switch_assert(peer_channel)((peer_channel) ? (void) (0) : __assert_fail ("peer_channel",
"src/switch_ivr_originate.c", 856, __PRETTY_FUNCTION__));
857
858 if (switch_channel_get_state(peer_channel) == CS_RESET) {
859 switch_channel_set_state(peer_channel, CS_SOFT_EXECUTE)switch_channel_perform_set_state(peer_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 859, CS_SOFT_EXECUTE);
860 }
861
862 if (session) {
863 caller_channel = switch_core_session_get_channel(session);
864 }
865
866 if ((switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA))) {
867 goto end;
868 }
869
870 switch_zmalloc(write_frame.data, SWITCH_RECOMMENDED_BUFFER_SIZE)(void)((((write_frame.data = calloc(1, (8192)))) ? (void) (0)
: __assert_fail ("(write_frame.data = calloc(1, (8192)))", "src/switch_ivr_originate.c"
, 870, __PRETTY_FUNCTION__)),write_frame.data);
871 write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE8192;
872
873 if (caller_channel && (var = switch_channel_get_variable(caller_channel, SWITCH_CALL_TIMEOUT_VARIABLE)switch_channel_get_variable_dup(caller_channel, "call_timeout"
, SWITCH_TRUE, -1))) {
874 timelimit = atoi(var);
875 if (timelimit < 0) {
876 timelimit = 60;
877 }
878 }
879
880 timelimit *= 1000000;
881 start = switch_micro_time_now();
882
883 if (caller_channel) {
884 cancel_key = switch_channel_get_variable(caller_channel, "origination_cancel_key")switch_channel_get_variable_dup(caller_channel, "origination_cancel_key"
, SWITCH_TRUE, -1);
885
886 if (switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
887 ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback")switch_channel_get_variable_dup(caller_channel, "transfer_ringback"
, SWITCH_TRUE, -1);
888 }
889
890 if (!ringback_data) {
891 ringback_data = switch_channel_get_variable(caller_channel, "ringback")switch_channel_get_variable_dup(caller_channel, "ringback", SWITCH_TRUE
, -1);
892 }
893
894 if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) || switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
895 ringback_data = NULL((void*)0);
896 } else if (zstr(ringback_data)_zstr(ringback_data)) {
897 if ((var = switch_channel_get_variable(caller_channel, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE)switch_channel_get_variable_dup(caller_channel, "send_silence_when_idle"
, SWITCH_TRUE, -1))) {
898 int sval = atoi(var);
899
900 if (sval) {
901 ringback_data = switch_core_session_sprintf(session, "silence:%d", sval);
902 }
903 }
904 }
905 }
906
907
908 if (read_codec && ringback_data) {
909 if (switch_is_file_path(ringback_data)) {
910 if (!(strrchr(ringback_data, '.') || strstr(ringback_data, SWITCH_URL_SEPARATOR"://"))) {
911 ringback.asis++;
912 }
913 }
914
915
916
917 if (!ringback.asis) {
918 if ((pass = (uint8_t) switch_test_flag(read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH)((read_codec)->flags & SWITCH_CODEC_FLAG_PASSTHROUGH))) {
919 goto no_ringback;
920 }
921
922 if (switch_core_codec_init(&write_codec,switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session))
923 "L16",switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session))
924 NULL,switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session))
925 read_codec->implementation->actual_samples_per_second,switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session))
926 read_codec->implementation->microseconds_per_packet / 1000,switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session))
927 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session))
928 switch_core_session_get_pool(session))switch_core_codec_init_with_bitrate(&write_codec, "L16", (
(void*)0), read_codec->implementation->actual_samples_per_second
, read_codec->implementation->microseconds_per_packet /
1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE
, ((void*)0), switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
929 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 929, (const char*)(session), SWITCH_LOG_ERROR, "Codec Error!\n");
930 if (caller_channel) {
931 switch_channel_hangup(caller_channel, SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL)switch_channel_perform_hangup(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 931, SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL
);
932 }
933 read_codec = NULL((void*)0);
934 goto done;
935 } else {
936 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 936, (const char*)(session), SWITCH_LOG_DEBUG,
937 "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
938 read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_packet / 1000);
939
940 write_frame.codec = &write_codec;
941 write_frame.datalen = read_codec->implementation->decoded_bytes_per_packet;
942 write_frame.samples = write_frame.datalen / 2;
943 memset(write_frame.data, 255, write_frame.datalen);
944 switch_core_session_set_read_codec(session, &write_codec);
945 }
946 }
947
948 if (switch_channel_test_flag(caller_channel, CF_DISABLE_RINGBACK)) {
949 ringback_data = NULL((void*)0);
950 }
951
952 if (ringback_data) {
953 char *tmp_data = NULL((void*)0);
954
955 if (switch_is_file_path(ringback_data)) {
956 char *ext;
957
958 if (ringback.asis) {
959 write_frame.codec = read_codec;
960 ext = read_codec->implementation->iananame;
961 tmp_data = switch_mprintf("%s.%s", ringback_data, ext);
962 ringback_data = tmp_data;
963 }
964
965 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 965, (const char*)(session), SWITCH_LOG_DEBUG, "Play Ringback File [%s]\n", ringback_data);
966
967 ringback.fhb.channels = read_codec->implementation->number_of_channels;
968 ringback.fhb.samplerate = read_codec->implementation->actual_samples_per_second;
969 if (switch_core_file_open(&ringback.fhb,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 973, &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, ((void*)0))
970 ringback_data,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 973, &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, ((void*)0))
971 read_codec->implementation->number_of_channels,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 973, &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, ((void*)0))
972 read_codec->implementation->actual_samples_per_second,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 973, &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, ((void*)0))
973 SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL)switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 973, &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, ((void*)0)) != SWITCH_STATUS_SUCCESS) {
974 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 974, (const char*)(session), SWITCH_LOG_ERROR, "Error Playing File\n");
975 switch_safe_free(tmp_data)if (tmp_data) {free(tmp_data);tmp_data=((void*)0);};
976 goto done;
977 }
978 ringback.fh = &ringback.fhb;
979 } else {
980 if (!strncasecmp(ringback_data, "silence", 7)) {
981 const char *p = ringback_data + 7;
982 if (*p == ':') {
983 p++;
984 if (p) {
985 ringback.silence = atoi(p);
986 }
987 }
988 SWITCH_IVR_VERIFY_SILENCE_DIVISOR(ringback.silence){ if ((ringback.silence) <= 0 && (ringback.silence
) != -1) { ringback.silence = 400; } };
989 } else {
990 switch_buffer_create_dynamic(&ringback.audio_buffer, 512, 1024, 0);
991 switch_buffer_set_loops(ringback.audio_buffer, -1);
992
993 teletone_init_session(&ringback.ts, 0, teletone_handler, &ringback);
994 ringback.ts.rate = read_codec->implementation->actual_samples_per_second;
995 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 995, (const char*)(session), SWITCH_LOG_DEBUG, "Play Ringback Tone [%s]\n", ringback_data);
996 if (teletone_run(&ringback.ts, ringback_data)) {
997 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 997, (const char*)(session), SWITCH_LOG_ERROR, "Error Playing Tone\n");
998 teletone_destroy_session(&ringback.ts);
999 switch_buffer_destroy(&ringback.audio_buffer);
1000 ringback_data = NULL((void*)0);
1001 }
1002 }
1003 }
1004 switch_safe_free(tmp_data)if (tmp_data) {free(tmp_data);tmp_data=((void*)0);};
1005 }
1006 }
1007
1008 no_ringback:
1009
1010 if (caller_channel) {
1011 wait_state = switch_channel_get_state(caller_channel);
1012 }
1013
1014 while (switch_channel_ready(peer_channel)switch_channel_test_ready(peer_channel, SWITCH_TRUE, SWITCH_FALSE
) && !switch_channel_media_ready(peer_channel)switch_channel_test_ready(peer_channel, SWITCH_TRUE, SWITCH_TRUE
)) {
1015 int diff = (int) (switch_micro_time_now() - start);
1016
1017 switch_ivr_parse_all_messages(session);
1018
1019 if (caller_channel && cancel_key) {
1020 if (switch_channel_has_dtmf(caller_channel)) {
1021 switch_dtmf_t dtmf = { 0, 0 };
1022 if (switch_channel_dequeue_dtmf(caller_channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
1023 if (dtmf.digit == *cancel_key) {
1024 status = SWITCH_STATUS_FALSE;
1025 goto done;
1026 }
1027 }
1028 }
1029 }
1030
1031 if (caller_channel && switch_channel_get_state(caller_channel) != wait_state) {
1032 goto done;
1033 }
1034
1035 if (diff > timelimit) {
1036 status = SWITCH_STATUS_TIMEOUT;
1037 goto done;
1038 }
1039
1040 if (switch_channel_media_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_TRUE
)) {
1041 status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
1042 if (!SWITCH_READ_ACCEPTABLE(status)(status == SWITCH_STATUS_SUCCESS || status == SWITCH_STATUS_BREAK
|| status == SWITCH_STATUS_INUSE)) {
1043 break;
1044 }
1045 } else {
1046 read_frame = NULL((void*)0);
1047 }
1048
1049 if (read_frame && !pass) {
1050
1051 if (ringback.fh) {
1052 switch_size_t mlen, olen;
1053 unsigned int pos = 0;
1054
1055 if (ringback.asis) {
1056 mlen = write_frame.codec->implementation->encoded_bytes_per_packet;
1057 } else {
1058 mlen = write_frame.codec->implementation->samples_per_packet;
1059 }
1060
1061 olen = mlen;
1062 //if (ringback.fh->resampler && ringback.fh->resampler->rfactor > 1) {
1063 //olen = (switch_size_t) (olen * ringback.fh->resampler->rfactor);
1064 //}
1065 switch_core_file_read(ringback.fh, write_frame.data, &olen);
1066
1067 if (olen == 0) {
1068 olen = mlen;
1069 ringback.fh->speed = 0;
1070 switch_core_file_seek(ringback.fh, &pos, 0, SEEK_SET0);
1071 switch_core_file_read(ringback.fh, write_frame.data, &olen);
1072 if (olen == 0) {
1073 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1073, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_ERROR,
1074 "Failure to read or re-read after seeking to beginning on file [%s]\n", ringback.fh->file_path);
1075 break;
1076 }
1077 }
1078 write_frame.datalen = (uint32_t) (ringback.asis ? olen : olen * 2 * ringback.fh->channels);
1079 } else if (ringback.audio_buffer) {
1080 if ((write_frame.datalen = (uint32_t) switch_buffer_read_loop(ringback.audio_buffer,
1081 write_frame.data,
1082 write_frame.codec->implementation->decoded_bytes_per_packet)) <= 0) {
1083 break;
1084 }
1085 } else if (ringback.silence) {
1086 write_frame.datalen = write_frame.codec->implementation->decoded_bytes_per_packet;
1087 switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.datalen / 2,
1088 write_frame.codec->implementation->number_of_channels, ringback.silence);
1089 }
1090
1091 if ((ringback.fh || ringback.silence || ringback.audio_buffer) && write_frame.codec && write_frame.datalen) {
1092 if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
1093 break;
1094 }
1095 }
1096 } else {
1097 switch_cond_next();
1098 }
1099 }
1100
1101 done:
1102
1103 if (ringback.fh) {
1104 switch_core_file_close(ringback.fh);
1105 ringback.fh = NULL((void*)0);
1106 } else if (ringback.audio_buffer) {
1107 teletone_destroy_session(&ringback.ts);
1108 switch_buffer_destroy(&ringback.audio_buffer);
1109 }
1110
1111
1112 switch_ivr_parse_all_events(session);
1113
1114 switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
1115
1116 if (switch_core_codec_ready(&write_codec)) {
1117 switch_core_codec_destroy(&write_codec);
1118 }
1119
1120 switch_safe_free(write_frame.data)if (write_frame.data) {free(write_frame.data);write_frame.data
=((void*)0);};
1121
1122 end:
1123
1124 if (!switch_channel_media_ready(peer_channel)switch_channel_test_ready(peer_channel, SWITCH_TRUE, SWITCH_TRUE
)) {
1125 if (switch_channel_up_nosig(peer_channel)(switch_channel_get_state(peer_channel) < CS_HANGUP)) {
1126 switch_channel_hangup(peer_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(peer_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 1126, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
1127 }
1128 status = SWITCH_STATUS_FALSE;
1129 }
1130
1131 if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
1132 switch_channel_state_t peer_state = switch_channel_get_state(peer_channel);
1133
1134 while (switch_channel_ready(peer_channel)switch_channel_test_ready(peer_channel, SWITCH_TRUE, SWITCH_FALSE
) && switch_channel_get_state(peer_channel) == peer_state) {
1135 switch_ivr_parse_all_messages(session);
1136 switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
);
1137 switch_yield(20000)switch_sleep(20000);;
1138 }
1139 }
1140
1141 if (caller_channel && !switch_channel_up_nosig(caller_channel)(switch_channel_get_state(caller_channel) < CS_HANGUP)) {
1142 status = SWITCH_STATUS_FALSE;
1143 }
1144
1145 return status;
1146}
1147
1148SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_process_import(switch_core_session_t *session, switch_channel_t *peer_channel, const char *varname, const char *prefix)
1149{
1150 const char *import, *val;
1151 switch_channel_t *caller_channel;
1152
1153 switch_assert(session && peer_channel)((session && peer_channel) ? (void) (0) : __assert_fail
("session && peer_channel", "src/switch_ivr_originate.c"
, 1153, __PRETTY_FUNCTION__));
1154 caller_channel = switch_core_session_get_channel(session);
1155
1156 if ((import = switch_channel_get_variable(caller_channel, varname)switch_channel_get_variable_dup(caller_channel, varname, SWITCH_TRUE
, -1))) {
1157 char *mydata = switch_core_session_strdup(session, import)switch_core_perform_session_strdup(session, import, "src/switch_ivr_originate.c"
, (const char *)__func__, 1157);
1158 int i, argc;
1159 char *argv[64] = { 0 };
1160
1161 if ((argc = switch_separate_string(mydata, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
1162 for (i = 0; i < argc; i++) {
1163 if ((val = switch_channel_get_variable(peer_channel, argv[i])switch_channel_get_variable_dup(peer_channel, argv[i], SWITCH_TRUE
, -1))) {
1164 if (prefix) {
1165 char *var = switch_mprintf("%s%s", prefix, argv[i]);
1166 switch_channel_set_variable(caller_channel, var, val)switch_channel_set_variable_var_check(caller_channel, var, val
, SWITCH_TRUE);
1167 free(var);
1168 } else {
1169 switch_channel_set_variable(caller_channel, argv[i], val)switch_channel_set_variable_var_check(caller_channel, argv[i]
, val, SWITCH_TRUE);
1170 }
1171 }
1172 }
1173 }
1174 }
1175}
1176
1177
1178static switch_status_t setup_ringback(originate_global_t *oglobals, originate_status_t *originate_status, int len,
1179 const char *ringback_data, ringback_t *ringback, switch_frame_t *write_frame, switch_codec_t *write_codec)
1180{
1181 switch_status_t status = SWITCH_STATUS_SUCCESS;
1182 switch_channel_t *caller_channel = switch_core_session_get_channel(oglobals->session);
1183 switch_codec_t *read_codec = NULL((void*)0);
1184 char *tmp_data = NULL((void*)0);
1185
1186 if (!switch_channel_test_flag(caller_channel, CF_ANSWERED)
1187 && !switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)) {
1188 if (oglobals->bridge_early_media > -1 && len == 1 && originate_status[0].peer_session &&
1189 switch_channel_media_ready(originate_status[0].peer_channel)switch_channel_test_ready(originate_status[0].peer_channel, SWITCH_TRUE
, SWITCH_TRUE)) {
1190 inherit_codec(caller_channel, originate_status[0].peer_session);
1191 }
1192 if ((status = switch_channel_pre_answer(caller_channel)switch_channel_perform_pre_answer(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 1192)) != SWITCH_STATUS_SUCCESS) {
1193 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1193, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_DEBUG, "%s Media Establishment Failed.\n",
1194 switch_channel_get_name(caller_channel));
1195 switch_goto_status(SWITCH_STATUS_BREAK, end)status = SWITCH_STATUS_BREAK; goto end;
1196 }
1197 }
1198
1199 if (oglobals->session && (read_codec = switch_core_session_get_read_codec(oglobals->session))) {
1200 if (ringback_data && switch_is_file_path(ringback_data)) {
1201 if (!(strrchr(ringback_data, '.') || strstr(ringback_data, SWITCH_URL_SEPARATOR"://"))) {
1202 ringback->asis++;
1203 }
1204 } else if (oglobals->bridge_early_media > -1 && zstr(ringback_data)_zstr(ringback_data) && len == 1 && originate_status[0].peer_session) {
1205 switch_codec_implementation_t read_impl = { 0 }, write_impl = { 0 };
1206
1207 if (switch_channel_ready(originate_status[0].peer_channel)switch_channel_test_ready(originate_status[0].peer_channel, SWITCH_TRUE
, SWITCH_FALSE)
1208 && switch_core_session_get_read_impl(originate_status[0].peer_session, &read_impl) == SWITCH_STATUS_SUCCESS
1209 && switch_core_session_get_write_impl(oglobals->session, &write_impl) == SWITCH_STATUS_SUCCESS) {
1210 if (read_impl.impl_id == write_impl.impl_id &&
1211 read_impl.microseconds_per_packet == write_impl.microseconds_per_packet &&
1212 read_impl.actual_samples_per_second == write_impl.actual_samples_per_second) {
1213 ringback->asis++;
1214 write_frame->codec = switch_core_session_get_write_codec(originate_status[0].peer_session);
1215 write_frame->datalen = write_frame->codec->implementation->decoded_bytes_per_packet;
1216 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1216, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_DEBUG, "bridge_early_media: passthrough enabled\n");
1217 } else {
1218 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1218, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_DEBUG, "bridge_early_media: codecs don't match (%s@%uh@%di / %s@%uh@%di)\n",
1219 read_impl.iananame, read_impl.actual_samples_per_second, read_impl.microseconds_per_packet / 1000,
1220 write_impl.iananame, write_impl.actual_samples_per_second, write_impl.microseconds_per_packet / 1000);
1221 }
1222 }
1223 }
1224
1225 if (!ringback->asis) {
1226 switch_codec_implementation_t peer_read_impl = { 0 };
1227
1228 if (switch_test_flag(read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH)((read_codec)->flags & SWITCH_CODEC_FLAG_PASSTHROUGH)) {
1229 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1229, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_WARNING, "%s Ringback not supported in passthrough codec mode.\n",
1230 switch_channel_get_name(caller_channel));
1231 switch_goto_status(SWITCH_STATUS_GENERR, end)status = SWITCH_STATUS_GENERR; goto end;
1232 }
1233
1234 if (oglobals->bridge_early_media > -1 && zstr(ringback_data)_zstr(ringback_data) && len == 1 && originate_status[0].peer_session) {
1235 switch_core_session_get_read_impl(originate_status[0].peer_session, &peer_read_impl);
1236 } else {
1237 switch_core_session_get_read_impl(oglobals->session, &peer_read_impl);
1238 }
1239
1240 if (switch_core_codec_init(write_codec,switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session))
1241 "L16",switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session))
1242 NULL,switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session))
1243 peer_read_impl.actual_samples_per_second,switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session))
1244 peer_read_impl.microseconds_per_packet / 1000,switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session))
1245 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session))
1246 switch_core_session_get_pool(oglobals->session))switch_core_codec_init_with_bitrate(write_codec, "L16", ((void
*)0), peer_read_impl.actual_samples_per_second, peer_read_impl
.microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(oglobals->session)) == SWITCH_STATUS_SUCCESS) {
1247
1248
1249 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1249, (const char*)(oglobals->session), SWITCH_LOG_DEBUG,
1250 "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
1251 peer_read_impl.actual_samples_per_second, peer_read_impl.microseconds_per_packet / 1000);
1252 write_frame->codec = write_codec;
1253 write_frame->datalen = read_codec->implementation->decoded_bytes_per_packet;
1254 write_frame->samples = write_frame->datalen / 2;
1255 memset(write_frame->data, 255, write_frame->datalen);
1256 switch_core_session_set_read_codec(oglobals->session, write_codec);
1257 } else {
1258 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1258, (const char*)switch_channel_get_session
(caller_channel), SWITCH_LOG_ERROR, "Codec Error!\n");
1259 switch_channel_hangup(caller_channel, SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL)switch_channel_perform_hangup(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 1259, SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL
);
1260 read_codec = NULL((void*)0);
1261 switch_goto_status(SWITCH_STATUS_BREAK, end)status = SWITCH_STATUS_BREAK; goto end;
1262 }
1263 }
1264
1265 oglobals->gen_ringback = 1;
1266
1267 if (zstr(ringback_data)_zstr(ringback_data)) {
1268 switch_goto_status(SWITCH_STATUS_SUCCESS, end)status = SWITCH_STATUS_SUCCESS; goto end;
1269 }
1270
1271 if (switch_is_file_path(ringback_data)) {
1272 char *ext;
1273
1274 if (ringback->asis) {
1275 write_frame->codec = read_codec;
1276 ext = read_codec->implementation->iananame;
1277 tmp_data = switch_mprintf("%s.%s", ringback_data, ext);
1278 ringback_data = tmp_data;
1279 }
1280
1281 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1281, (const char*)(oglobals->session), SWITCH_LOG_DEBUG, "Play Ringback File [%s]\n", ringback_data);
1282
1283 if (switch_test_flag((&ringback->fhb), SWITCH_FILE_OPEN)(((&ringback->fhb))->flags & SWITCH_FILE_OPEN)) {
1284 switch_core_file_close(&ringback->fhb);
1285 }
1286
1287
1288 ringback->fhb.channels = read_codec->implementation->number_of_channels;
1289 ringback->fhb.samplerate = read_codec->implementation->actual_samples_per_second;
1290 if (switch_core_file_open(&ringback->fhb,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 1294, &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, ((void*)0))
1291 ringback_data,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 1294, &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, ((void*)0))
1292 read_codec->implementation->number_of_channels,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 1294, &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, ((void*)0))
1293 read_codec->implementation->actual_samples_per_second,switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 1294, &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, ((void*)0))
1294 SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL)switch_core_perform_file_open("src/switch_ivr_originate.c", (
const char *)__func__, 1294, &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, ((void*)0)) != SWITCH_STATUS_SUCCESS) {
1295 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1295, (const char*)(oglobals->session), SWITCH_LOG_ERROR, "Error Playing File\n");
1296 switch_safe_free(tmp_data)if (tmp_data) {free(tmp_data);tmp_data=((void*)0);};
1297 switch_goto_status(SWITCH_STATUS_GENERR, end)status = SWITCH_STATUS_GENERR; goto end;
1298 //switch_goto_status(SWITCH_STATUS_FALSE, end);
1299 }
1300 ringback->fh = &ringback->fhb;
1301
1302 } else if (!strncasecmp(ringback_data, "silence", 7)) {
1303 const char *c = ringback_data + 7;
1304 if (*c == ':') {
1305 c++;
1306 if (c) {
1307 ringback->silence = atoi(c);
1308 }
1309 }
1310 SWITCH_IVR_VERIFY_SILENCE_DIVISOR(ringback->silence){ if ((ringback->silence) <= 0 && (ringback->
silence) != -1) { ringback->silence = 400; } };
1311 } else {
1312 switch_buffer_create_dynamic(&ringback->audio_buffer, 512, 1024, 0);
1313 switch_buffer_set_loops(ringback->audio_buffer, -1);
1314
1315 teletone_init_session(&ringback->ts, 0, teletone_handler, ringback);
1316 ringback->ts.rate = read_codec->implementation->actual_samples_per_second;
1317 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1317, (const char*)(oglobals->session), SWITCH_LOG_DEBUG, "Play Ringback Tone [%s]\n", ringback_data);
1318 /* ringback->ts.debug = 1;
1319 ringback->ts.debug_stream = switch_core_get_console(); */
1320
1321 if (teletone_run(&ringback->ts, ringback_data)) {
1322 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1322, (const char*)(oglobals->session), SWITCH_LOG_ERROR, "Error Playing Tone\n");
1323 teletone_destroy_session(&ringback->ts);
1324 switch_buffer_destroy(&ringback->audio_buffer);
1325 switch_goto_status(SWITCH_STATUS_GENERR, end)status = SWITCH_STATUS_GENERR; goto end;
1326 }
1327 }
1328 }
1329
1330 end:
1331
1332 switch_safe_free(tmp_data)if (tmp_data) {free(tmp_data);tmp_data=((void*)0);};
1333
1334 return status;
1335
1336}
1337
1338
1339#define MAX_PEERS128 128
1340
1341typedef struct {
1342 switch_core_session_t *session;
1343 switch_core_session_t *bleg;
1344 switch_call_cause_t cause;
1345 switch_call_cause_t cancel_cause;
1346 const char *bridgeto;
1347 uint32_t timelimit_sec;
1348 const switch_state_handler_table_t *table;
1349 const char *cid_name_override;
1350 const char *cid_num_override;
1351 switch_caller_profile_t *caller_profile_override;
1352 switch_event_t *ovars;
1353 switch_originate_flag_t flags;
1354 switch_status_t status;
1355 int done;
1356 switch_thread_t *thread;
1357 switch_mutex_t *mutex;
1358} enterprise_originate_handle_t;
1359
1360
1361struct ent_originate_ringback {
1362 switch_core_session_t *session;
1363 int running;
1364 const char *ringback_data;
1365 switch_thread_t *thread;
1366};
1367
1368static void *SWITCH_THREAD_FUNC enterprise_originate_thread(switch_thread_t *thread, void *obj)
1369{
1370 enterprise_originate_handle_t *handle = (enterprise_originate_handle_t *) obj;
1371
1372 handle->done = 0;
1373 handle->status = switch_ivr_originate(NULL((void*)0), &handle->bleg, &handle->cause,
1374 handle->bridgeto, handle->timelimit_sec,
1375 handle->table,
1376 handle->cid_name_override,
1377 handle->cid_num_override, handle->caller_profile_override, handle->ovars, handle->flags, &handle->cancel_cause);
1378
1379
1380 handle->done = 1;
1381 switch_mutex_lock(handle->mutex);
1382 switch_mutex_unlock(handle->mutex);
1383
1384 if (handle->done != 2) {
1385 if (handle->status == SWITCH_STATUS_SUCCESS && handle->bleg) {
1386 switch_channel_t *channel = switch_core_session_get_channel(handle->bleg);
1387
1388 switch_channel_set_variable(channel, "group_dial_status", "loser")switch_channel_set_variable_var_check(channel, "group_dial_status"
, "loser", SWITCH_TRUE);
1389 switch_channel_hangup(channel, SWITCH_CAUSE_LOSE_RACE)switch_channel_perform_hangup(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 1389, SWITCH_CAUSE_LOSE_RACE);
1390 switch_core_session_rwunlock(handle->bleg);
1391 }
1392 }
1393
1394 return NULL((void*)0);
1395}
1396
1397static void *SWITCH_THREAD_FUNC enterprise_originate_ringback_thread(switch_thread_t *thread, void *obj)
1398{
1399 struct ent_originate_ringback *rb_data = (struct ent_originate_ringback *) obj;
1400 switch_core_session_t *session = rb_data->session;
1401 switch_channel_t *channel = switch_core_session_get_channel(rb_data->session);
1402 switch_status_t status = SWITCH_STATUS_FALSE;
1403
1404 switch_core_session_read_lock(session);
1405
1406 while (rb_data->running && switch_channel_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_FALSE)) {
1407 switch_ivr_parse_all_messages(session);
1408 if (status != SWITCH_STATUS_BREAK) {
1409 if (zstr(rb_data->ringback_data)_zstr(rb_data->ringback_data) || !strcasecmp(rb_data->ringback_data, "silence")) {
1410 status = switch_ivr_collect_digits_callback(session, NULL((void*)0), 0, 0);
1411 } else if (switch_is_file_path(rb_data->ringback_data)) {
1412 status = switch_ivr_play_file(session, NULL((void*)0), rb_data->ringback_data, NULL((void*)0));
1413 } else {
1414 status = switch_ivr_gentones(session, rb_data->ringback_data, 0, NULL((void*)0));
1415 }
1416 }
1417
1418 if (status == SWITCH_STATUS_BREAK) {
1419 switch_channel_set_flag(channel, CF_NOT_READY)switch_channel_set_flag_value(channel, CF_NOT_READY, 1);
1420 }
1421 }
1422 switch_core_session_rwunlock(session);
1423
1424 rb_data->running = 0;
1425 return NULL((void*)0);
1426}
1427
1428
1429SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_ivr_enterprise_originate(switch_core_session_t *session,
1430 switch_core_session_t **bleg,
1431 switch_call_cause_t *cause,
1432 const char *bridgeto,
1433 uint32_t timelimit_sec,
1434 const switch_state_handler_table_t *table,
1435 const char *cid_name_override,
1436 const char *cid_num_override,
1437 switch_caller_profile_t *caller_profile_override,
1438 switch_event_t *ovars, switch_originate_flag_t flags,
1439 switch_call_cause_t *cancel_cause)
1440{
1441 int x_argc = 0;
1442 char *x_argv[MAX_PEERS128] = { 0 };
1443 enterprise_originate_handle_t *hp = NULL((void*)0), handles[MAX_PEERS128] = { {0} };
1444 int i;
1445 switch_caller_profile_t *cp = NULL((void*)0);
1446 switch_channel_t *channel = NULL((void*)0);
1447 char *data;
1448 switch_status_t status = SWITCH_STATUS_FALSE;
1449 switch_threadattr_t *thd_attr = NULL((void*)0);
1450 int running = 0, over = 0;
1451 switch_status_t tstatus = SWITCH_STATUS_FALSE;
1452 switch_memory_pool_t *pool;
1453 switch_event_header_t *hi = NULL((void*)0);
1454 struct ent_originate_ringback rb_data = { 0 };
1455 const char *ringback_data = NULL((void*)0);
1456 switch_event_t *var_event = NULL((void*)0);
1457 int getcause = 1;
1458
1459 *cause = SWITCH_CAUSE_SUCCESS;
1460
1461 switch_core_new_memory_pool(&pool)switch_core_perform_new_memory_pool(&pool, "src/switch_ivr_originate.c"
, (const char *)__func__, 1461);
1462
1463 if (zstr(bridgeto)_zstr(bridgeto)) {
1
Taking false branch
→
1464 *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
1465 getcause = 0;
1466 switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
1467 }
1468
1469 data = switch_core_strdup(pool, bridgeto)switch_core_perform_strdup(pool, bridgeto, "src/switch_ivr_originate.c"
, (const char *)__func__, 1469);
2
←
Value assigned to 'data'
→
1470
1471 if (session) {
3
←
Assuming 'session' is null
→
4
←
Taking false branch
→
1472 switch_caller_profile_t *cpp = NULL((void*)0);
1473 channel = switch_core_session_get_channel(session);
1474 if ((cpp = switch_channel_get_caller_profile(channel))) {
1475 cp = switch_caller_profile_dup(pool, cpp);
1476 }
1477 }
1478
1479 if (ovars) {
5
←
Assuming 'ovars' is non-null
→
6
←
Taking true branch
→
1480 var_event = ovars;
1481 } else {
1482 if (switch_event_create_plain(&var_event, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
1483 abort();
1484 }
1485 }
1486
1487 if (session) {
7
←
Taking false branch
→
1488 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "ent_originate_aleg_uuid", switch_core_session_get_uuid(session));
1489 }
1490
1491 if (channel) {
8
←
Taking false branch
→
1492 const char *tmp_var = NULL((void*)0);
1493
1494 switch_channel_process_export(channel, NULL((void*)0), var_event, SWITCH_EXPORT_VARS_VARIABLE"export_vars");
1495
1496 if ((tmp_var = switch_channel_get_variable(channel, "effective_ani")switch_channel_get_variable_dup(channel, "effective_ani", SWITCH_TRUE
, -1))) {
1497 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_ani", tmp_var);
1498 }
1499
1500 if ((tmp_var = switch_channel_get_variable(channel, "effective_aniii")switch_channel_get_variable_dup(channel, "effective_aniii", SWITCH_TRUE
, -1))) {
1501 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_aniii", tmp_var);
1502 }
1503
1504 if ((tmp_var = switch_channel_get_variable(channel, "effective_caller_id_name")switch_channel_get_variable_dup(channel, "effective_caller_id_name"
, SWITCH_TRUE, -1))) {
1505 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_name", tmp_var);
1506 }
1507
1508 if ((tmp_var = switch_channel_get_variable(channel, "effective_caller_id_number")switch_channel_get_variable_dup(channel, "effective_caller_id_number"
, SWITCH_TRUE, -1))) {
1509 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_number", tmp_var);
1510 }
1511 }
1512
1513 /* strip leading spaces */
1514 while (data && *data && *data == ' ') {
9
←
Assuming pointer value is null
→
1515 data++;
1516 }
1517
1518 /* extract channel variables, allowing multiple sets of braces */
1519 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1519, (const char*)(session), SWITCH_LOG_DEBUG, "Parsing ultra-global variables\n");
1520 while (*data == '<') {
10
←
Dereference of null pointer (loaded from variable 'data')
1521 char *parsed = NULL((void*)0);
1522
1523 if (switch_event_create_brackets(data, '<', '>', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
1524 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1524, (const char*)(session), SWITCH_LOG_ERROR, "Parse Error!\n");
1525 switch_goto_status(SWITCH_STATUS_GENERR, done)status = SWITCH_STATUS_GENERR; goto done;
1526 }
1527
1528 data = parsed;
1529 }
1530
1531 /* strip leading spaces (again) */
1532 while (data && *data && *data == ' ') {
1533 data++;
1534 }
1535
1536 if (ovars && ovars != var_event) {
1537 for (hi = ovars->headers; hi; hi = hi->next) {
1538 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, hi->name, hi->value);
1539 }
1540 }
1541
1542 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "ignore_early_media", "true");
1543
1544 if (!(x_argc = switch_separate_string_string(data, SWITCH_ENT_ORIGINATE_DELIM":_:", x_argv, MAX_PEERS128))) {
1545 *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
1546 getcause = 0;
1547 switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
1548 }
1549
1550 switch_threadattr_create(&thd_attr, pool);
1551 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE240 * 1024);
1552
1553 for (i = 0; i < x_argc; i++) {
1554 handles[i].session = session;
1555 handles[i].bleg = NULL((void*)0);
1556 handles[i].cause = 0;
1557 handles[i].cancel_cause = 0;
1558 handles[i].bridgeto = x_argv[i];
1559 handles[i].timelimit_sec = timelimit_sec;
1560 handles[i].table = table;
1561 handles[i].cid_name_override = cid_name_override;
1562 handles[i].cid_num_override = cid_num_override;
1563 handles[i].caller_profile_override = cp;
1564 switch_event_dup(&handles[i].ovars, var_event);
1565 handles[i].flags = flags;
1566 switch_mutex_init(&handles[i].mutex, SWITCH_MUTEX_NESTED0x1, pool);
1567 switch_mutex_lock(handles[i].mutex);
1568 switch_thread_create(&handles[i].thread, thd_attr, enterprise_originate_thread, &handles[i], pool);
1569 }
1570
1571 if (channel && !switch_channel_test_flag(channel, CF_PROXY_MODE) && !switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
1572 if (switch_channel_test_flag(channel, CF_ANSWERED)) {
1573 ringback_data = switch_channel_get_variable(channel, "transfer_ringback")switch_channel_get_variable_dup(channel, "transfer_ringback",
SWITCH_TRUE, -1);
1574 }
1575
1576 if (!ringback_data) {
1577 ringback_data = switch_channel_get_variable(channel, "ringback")switch_channel_get_variable_dup(channel, "ringback", SWITCH_TRUE
, -1);
1578 }
1579
1580 if (ringback_data || switch_channel_media_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_TRUE)) {
1581 rb_data.ringback_data = ringback_data;
1582 rb_data.session = session;
1583 rb_data.running = 1;
1584 if (!switch_channel_media_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_TRUE)) {
1585 if (switch_channel_pre_answer(channel)switch_channel_perform_pre_answer(channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 1585) != SWITCH_STATUS_SUCCESS) {
1586 goto done;
1587 }
1588 }
1589 switch_thread_create(&rb_data.thread, thd_attr, enterprise_originate_ringback_thread, &rb_data, pool);
1590 }
1591 }
1592
1593
1594 for (;;) {
1595 running = 0;
1596 over = 0;
1597
1598 if (channel && !switch_channel_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_FALSE)) {
1599 break;
1600 }
1601
1602 if (cancel_cause && *cancel_cause > 0) {
1603 break;
1604 }
1605
1606 for (i = 0; i < x_argc; i++) {
1607
1608
1609 if (handles[i].done == 0) {
1610 running++;
1611 } else if (handles[i].done == 1) {
1612 if (handles[i].status == SWITCH_STATUS_SUCCESS) {
1613 handles[i].done = 2;
1614 hp = &handles[i];
1615 goto done;
1616 } else {
1617 handles[i].done = -1;
1618 }
1619 } else {
1620 over++;
1621 }
1622
1623 switch_yield(10000)switch_sleep(10000);;
1624 }
1625
1626 if (!running || over == x_argc) {
1627 break;
1628 }
1629 }
1630
1631
1632 done:
1633
1634 if (hp) {
1635 *cause = hp->cause;
1636 getcause = 0;
1637 status = hp->status;
1638 *bleg = hp->bleg;
1639 switch_mutex_unlock(hp->mutex);
1640 switch_thread_join(&tstatus, hp->thread);
1641 switch_event_destroy(&hp->ovars);
1642 }
1643
1644 for (i = 0; i < x_argc; i++) {
1645 if (hp == &handles[i]) {
1646 continue;
1647 }
1648
1649 if (cancel_cause && *cancel_cause > 0) {
1650 handles[i].cancel_cause = *cancel_cause;
1651 } else {
1652 handles[i].cancel_cause = SWITCH_CAUSE_LOSE_RACE;
1653 }
1654 }
1655
1656 for (i = 0; i < x_argc; i++) {
1657
1658 if (channel) {
1659 switch_channel_handle_cause(channel, handles[i].cause);
1660 }
1661
1662 if (hp == &handles[i]) {
1663 continue;
1664 }
1665 switch_mutex_unlock(handles[i].mutex);
1666
1667 if (getcause && *cause != handles[i].cause && handles[i].cause != SWITCH_CAUSE_LOSE_RACE && handles[i].cause != SWITCH_CAUSE_NO_PICKUP) {
1668 *cause = handles[i].cause;
1669 getcause++;
1670 }
1671
1672 switch_thread_join(&tstatus, handles[i].thread);
1673 switch_event_destroy(&handles[i].ovars);
1674 }
1675
1676 if (channel && rb_data.thread) {
1677 switch_channel_set_flag(channel, CF_NOT_READY)switch_channel_set_flag_value(channel, CF_NOT_READY, 1);
1678 switch_thread_join(&tstatus, rb_data.thread);
1679 switch_channel_clear_flag(channel, CF_NOT_READY);
1680 }
1681
1682
1683 end:
1684
1685 if (getcause == 1 && *cause == SWITCH_CAUSE_SUCCESS) {
1686 *cause = SWITCH_CAUSE_NO_ANSWER;
1687 }
1688
1689 if (channel) {
1690 if (*cause == SWITCH_CAUSE_SUCCESS) {
1691 switch_channel_set_variable(channel, "originate_disposition", "success")switch_channel_set_variable_var_check(channel, "originate_disposition"
, "success", SWITCH_TRUE);
1692 } else {
1693 switch_channel_set_variable(channel, "originate_disposition", "failure")switch_channel_set_variable_var_check(channel, "originate_disposition"
, "failure", SWITCH_TRUE);
1694 switch_channel_set_variable(channel, "hangup_cause", switch_channel_cause2str(*cause))switch_channel_set_variable_var_check(channel, "hangup_cause"
, switch_channel_cause2str(*cause), SWITCH_TRUE);
1695 }
1696 }
1697
1698
1699 if (var_event && var_event != ovars) {
1700 switch_event_destroy(&var_event);
1701 }
1702
1703 switch_core_destroy_memory_pool(&pool)switch_core_perform_destroy_memory_pool(&pool, "src/switch_ivr_originate.c"
, (const char *)__func__, 1703);
1704
1705 return status;
1706
1707}
1708
1709struct early_state {
1710 originate_global_t *oglobals;
1711 originate_status_t *originate_status;
1712 switch_mutex_t *mutex;
1713 switch_buffer_t *buffer;
1714 int ready;
1715 ringback_t *ringback;
1716 int ttl;
1717};
1718typedef struct early_state early_state_t;
1719
1720
1721static void *SWITCH_THREAD_FUNC early_thread_run(switch_thread_t *thread, void *obj)
1722{
1723 early_state_t *state = (early_state_t *) obj;
1724 originate_status_t originate_status[MAX_PEERS128] = { {0} };
1725 int16_t mux_data[SWITCH_RECOMMENDED_BUFFER_SIZE8192 / 2] = { 0 };
1726 int32_t sample;
1727 switch_codec_t read_codecs[MAX_PEERS128] = { {0} };
1728 int i, x, ready = 0, answered = 0, ring_ready = 0;
1729 int16_t *data;
1730 uint32_t datalen = 0;
1731 switch_status_t status;
1732 switch_frame_t *read_frame = NULL((void*)0);
1733 switch_codec_implementation_t read_impl = { 0 };
1734
1735 for (i = 0; i < MAX_PEERS128 && i < state->ttl; i++) {
1736 if (switch_core_session_read_lock(state->originate_status[i].peer_session) == SWITCH_STATUS_SUCCESS) {
1737 originate_status[i].peer_session = state->originate_status[i].peer_session;
1738 originate_status[i].peer_channel = switch_core_session_get_channel(state->originate_status[i].peer_session);
1739 }
1740 }
1741
1742 if (state->oglobals->session) {
1743 switch_core_session_get_read_impl(state->oglobals->session, &read_impl);
1744 }
1745
1746 while (state->ready) {
1747 datalen = 0;
1748 memset(mux_data, 0, sizeof(mux_data));
1749 ready = 0;
1750 answered = 0;
1751
1752 for (i = 0; i < MAX_PEERS128 && i < state->ttl; i++) {
1753 switch_core_session_t *session = originate_status[i].peer_session;
1754 switch_channel_t *channel = originate_status[i].peer_channel;
1755
1756 if (!session) {
1757 break;
1758 }
1759
1760 if (!channel || !switch_channel_up(channel)(switch_channel_check_signal(channel, SWITCH_TRUE) || switch_channel_get_state
(channel) < CS_HANGUP)) {
1761 continue;
1762 }
1763
1764 if (switch_channel_media_ready(channel)switch_channel_test_ready(channel, SWITCH_TRUE, SWITCH_TRUE)) {
1765 ready++;
1766
1767 if (switch_channel_test_flag(channel, CF_RING_READY)) {
1768 ring_ready = 1;
1769 state->oglobals->bridge_early_media = -1;
1770 state->oglobals->ignore_early_media = 1;
1771 }
1772
1773 if (switch_channel_test_flag(channel, CF_ANSWERED)) {
1774 answered++;
1775 }
1776
1777 if (!state->ringback->asis) {
1778 if (!switch_core_codec_ready((&read_codecs[i]))) {
1779 if (switch_core_codec_init(&read_codecs[i],switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session))
1780 "L16",switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session))
1781 NULL,switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session))
1782 read_impl.actual_samples_per_second,switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session))
1783 read_impl.microseconds_per_packet / 1000,switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session))
1784 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session))
1785 switch_core_session_get_pool(session))switch_core_codec_init_with_bitrate(&read_codecs[i], "L16"
, ((void*)0), read_impl.actual_samples_per_second, read_impl.
microseconds_per_packet / 1000, 1, 0, SWITCH_CODEC_FLAG_ENCODE
| SWITCH_CODEC_FLAG_DECODE, ((void*)0), switch_core_session_get_pool
(session)) != SWITCH_STATUS_SUCCESS) {
1786 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 1786, (const char*)(session), SWITCH_LOG_ERROR, "Codec Error!\n");
1787 }
1788 switch_core_session_set_read_codec(session, NULL((void*)0));
1789 switch_core_session_set_read_codec(session, &read_codecs[i]);
1790 }
1791 status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
1792 if (SWITCH_READ_ACCEPTABLE(status)(status == SWITCH_STATUS_SUCCESS || status == SWITCH_STATUS_BREAK
|| status == SWITCH_STATUS_INUSE) && !switch_test_flag(read_frame, SFF_CNG)((read_frame)->flags & SFF_CNG)) {
1793 data = (int16_t *) read_frame->data;
1794 if (datalen < read_frame->datalen) {
1795 datalen = read_frame->datalen;
1796 }
1797 for (x = 0; x < (int) read_frame->datalen / 2; x++) {
1798 sample = data[x] + mux_data[x];
1799 switch_normalize_to_16bit(sample)if (sample > 32767) sample = 32767; else if (sample < -
32768) sample = -32768;;
1800 mux_data[x] = (int16_t) sample;
1801 }
1802 }
1803 } else {
1804 status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
1805 if (SWITCH_READ_ACCEPTABLE(status)(status == SWITCH_STATUS_SUCCESS || status == SWITCH_STATUS_BREAK
|| status == SWITCH_STATUS_INUSE) && !switch_test_flag(read_frame, SFF_CNG)((read_frame)->flags & SFF_CNG)) {
1806 datalen = read_frame->datalen;
1807 }
1808 break;
1809 }
1810 }
1811 }
1812
1813 if (!ready || answered || ring_ready) {
1814 break;
1815 }
1816
1817 if (!datalen) {
1818 continue;
1819 }
1820
1821 if (state->ringback->asis) {
1822 uint16_t flen = (uint16_t)datalen;
1823 switch_mutex_lock(state->mutex);
1824 switch_buffer_write(state->buffer, &flen, sizeof(uint16_t));
1825 switch_buffer_write(state->buffer, read_frame->data, datalen);
1826 switch_mutex_unlock(state->mutex);
1827 } else {
1828 switch_mutex_lock(state->mutex);
1829 switch_buffer_write(state->buffer, mux_data, datalen);
1830 switch_mutex_unlock(state->mutex);
1831 }
1832 }
1833
1834
1835 for (i = 0; i < MAX_PEERS128 && i < state->ttl; i++) {
1836 switch_core_session_t *session = originate_status[i].peer_session;
1837 switch_channel_t *channel = originate_status[i].peer_channel;
1838
1839 if (!session) break;
1840
1841 if (switch_core_codec_ready((&read_codecs[i]))) {
1842 switch_core_codec_destroy(&read_codecs[i]);
1843 }
1844
1845 if (switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
1846 switch_core_session_reset(session, SWITCH_FALSE, SWITCH_TRUE);
1847 }
1848
1849 switch_core_session_rwunlock(session);
1850 }
1851
1852 if (!ring_ready) {
1853 state->oglobals->early_ok = 1;
1854 }
1855
1856 return NULL((void*)0);
1857}
1858
1859#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))) (_peer && !(switch_channel_test_flag(_peer, CF_TRANSFER) || \
1860 switch_channel_test_flag(_peer, CF_REDIRECT) || \
1861 switch_channel_test_flag(_peer, CF_BRIDGED) || \
1862 switch_channel_get_state(_peer) == CS_RESET || \
1863 !switch_channel_test_flag(_peer, CF_ORIGINATING)))
1864
1865static void wait_for_cause(switch_channel_t *channel)
1866{
1867 int sanity = 5;
1868
1869 while (--sanity > 0 && peer_eligible(channel)(channel && !(switch_channel_test_flag(channel, CF_TRANSFER
) || switch_channel_test_flag(channel, CF_REDIRECT) || switch_channel_test_flag
(channel, CF_BRIDGED) || switch_channel_get_state(channel) ==
CS_RESET || !switch_channel_test_flag(channel, CF_ORIGINATING
))) && switch_channel_get_cause(channel) == SWITCH_CAUSE_NONE) {
1870 switch_yield(10000)switch_sleep(10000);;
1871 }
1872}
1873
1874
1875
1876SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_ivr_originate(switch_core_session_t *session,
1877 switch_core_session_t **bleg,
1878 switch_call_cause_t *cause,
1879 const char *bridgeto,
1880 uint32_t timelimit_sec,
1881 const switch_state_handler_table_t *table,
1882 const char *cid_name_override,
1883 const char *cid_num_override,
1884 switch_caller_profile_t *caller_profile_override,
1885 switch_event_t *ovars, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
1886{
1887 originate_status_t originate_status[MAX_PEERS128] = { {0} };
1888 switch_originate_flag_t dftflags = SOF_NONE, myflags = dftflags;
1889 char *pipe_names[MAX_PEERS128] = { 0 };
1890 char *data = NULL((void*)0);
1891 switch_status_t status = SWITCH_STATUS_SUCCESS;
1892 switch_channel_t *caller_channel = NULL((void*)0);
1893 char *peer_names[MAX_PEERS128] = { 0 };
1894 switch_core_session_t *new_session = NULL((void*)0), *peer_session;
1895 switch_caller_profile_t *new_profile = NULL((void*)0), *caller_caller_profile;
1896 char *chan_type = NULL((void*)0), *chan_data;
1897 switch_channel_t *peer_channel = NULL((void*)0);
1898 ringback_t ringback = { 0 };
1899 time_t start;
1900 switch_frame_t *read_frame = NULL((void*)0);
1901 int r = 0, i, and_argc = 0, or_argc = 0;
1902 int32_t sleep_ms = 1000, try = 0, retries = 1;
1903 switch_codec_t write_codec = { 0 };
1904 switch_frame_t write_frame = { 0 };
1905 char *odata, *var;
1906 switch_call_cause_t reason = SWITCH_CAUSE_NONE;
1907 switch_call_cause_t force_reason = SWITCH_CAUSE_NONE;
1908 uint8_t to = 0;
1909 char *var_val;
1910 const char *ringback_data = NULL((void*)0);
1911 switch_event_t *var_event = NULL((void*)0);
1912 int8_t fail_on_single_reject = 0;
1913 int8_t hangup_on_single_reject = 0;
1914 char *fail_on_single_reject_var = NULL((void*)0);
1915 char *loop_data = NULL((void*)0);
1916 uint32_t progress_timelimit_sec = 0;
1917 const char *cid_tmp, *lc;
1918 originate_global_t oglobals = { 0 };
1919 int cdr_total = 0;
1920 int local_clobber = 0;
1921 const char *cancel_key = NULL((void*)0);
1922 const char *holding = NULL((void*)0);
1923 const char *soft_holding = NULL((void*)0);
1924 early_state_t early_state = { 0 };
1925 int read_packet = 0;
1926 int check_reject = 1;
1927 switch_codec_implementation_t read_impl = { 0 };
1928 const char *ani_override = NULL((void*)0);
1929 const char *aniii_override = NULL((void*)0);
1930 const char *ent_aleg_uuid = NULL((void*)0);
1931 switch_core_session_t *a_session = session, *l_session = NULL((void*)0);
1932
1933 if (session) {
1934 caller_channel = switch_core_session_get_channel(session);
1935
1936 if (switch_false(switch_channel_get_variable(caller_channel, "preserve_originated_vars")switch_channel_get_variable_dup(caller_channel, "preserve_originated_vars"
, SWITCH_TRUE, -1))) {
1937 switch_channel_set_variable(caller_channel, "originated_legs", NULL)switch_channel_set_variable_var_check(caller_channel, "originated_legs"
, ((void*)0), SWITCH_TRUE);
1938 switch_channel_set_variable(caller_channel, "originate_causes", NULL)switch_channel_set_variable_var_check(caller_channel, "originate_causes"
, ((void*)0), SWITCH_TRUE);
1939 }
1940 }
1941
1942
1943 if (strstr(bridgeto, SWITCH_ENT_ORIGINATE_DELIM":_:")) {
1944 return switch_ivr_enterprise_originate(session, bleg, cause, bridgeto, timelimit_sec, table, cid_name_override, cid_num_override,
1945 caller_profile_override, ovars, flags, cancel_cause);
1946 }
1947
1948 oglobals.check_vars = SWITCH_TRUE;
1949 oglobals.ringback_ok = 1;
1950 oglobals.bridge_early_media = -1;
1951 oglobals.file = NULL((void*)0);
1952 oglobals.error_file = NULL((void*)0);
1953 switch_core_new_memory_pool(&oglobals.pool)switch_core_perform_new_memory_pool(&oglobals.pool, "src/switch_ivr_originate.c"
, (const char *)__func__, 1953);
1954
1955 if (caller_profile_override) {
1956 oglobals.caller_profile_override = switch_caller_profile_dup(oglobals.pool, caller_profile_override);
1957 } else if (session) {
1958 switch_caller_profile_t *cp = switch_channel_get_caller_profile(caller_channel);
1959
1960 if (cp) {
1961 oglobals.caller_profile_override = switch_caller_profile_dup(oglobals.pool, cp);
1962 }
1963 }
1964
1965 if (session) {
1966 const char *to_var, *bypass_media = NULL((void*)0), *proxy_media = NULL((void*)0), *zrtp_passthru = NULL((void*)0);
1967 switch_channel_set_flag(caller_channel, CF_ORIGINATOR)switch_channel_set_flag_value(caller_channel, CF_ORIGINATOR, 1
);
1968 oglobals.session = session;
1969
1970 switch_channel_execute_on(caller_channel, SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE"execute_on_pre_originate");
1971 switch_channel_api_on(caller_channel, SWITCH_CHANNEL_API_ON_PRE_ORIGINATE_VARIABLE"api_on_pre_originate");
1972
1973 switch_core_session_get_read_impl(session, &read_impl);
1974
1975 if ((to_var = switch_channel_get_variable(caller_channel, SWITCH_CALL_TIMEOUT_VARIABLE)switch_channel_get_variable_dup(caller_channel, "call_timeout"
, SWITCH_TRUE, -1))) {
1976 timelimit_sec = atoi(to_var);
1977 }
1978
1979 proxy_media = switch_channel_get_variable(caller_channel, SWITCH_PROXY_MEDIA_VARIABLE)switch_channel_get_variable_dup(caller_channel, "proxy_media"
, SWITCH_TRUE, -1);
1980 bypass_media = switch_channel_get_variable(caller_channel, SWITCH_BYPASS_MEDIA_VARIABLE)switch_channel_get_variable_dup(caller_channel, "bypass_media"
, SWITCH_TRUE, -1);
1981 zrtp_passthru = switch_channel_get_variable(caller_channel, SWITCH_ZRTP_PASSTHRU_VARIABLE)switch_channel_get_variable_dup(caller_channel, "zrtp_passthru"
, SWITCH_TRUE, -1);
1982
1983 if (!zstr(proxy_media)_zstr(proxy_media)) {
1984 if (switch_true(proxy_media)) {
1985 switch_channel_set_flag(caller_channel, CF_PROXY_MEDIA)switch_channel_set_flag_value(caller_channel, CF_PROXY_MEDIA,
1);
1986 } else if (switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
1987 switch_channel_clear_flag(caller_channel, CF_PROXY_MEDIA);
1988 }
1989 }
1990
1991 if (!zstr(zrtp_passthru)_zstr(zrtp_passthru)) {
1992 if (switch_true(zrtp_passthru)) {
1993 switch_channel_set_flag(caller_channel, CF_ZRTP_PASSTHRU_REQ)switch_channel_set_flag_value(caller_channel, CF_ZRTP_PASSTHRU_REQ
, 1);
1994 } else if (switch_channel_test_flag(caller_channel, CF_ZRTP_PASSTHRU_REQ)) {
1995 switch_channel_clear_flag(caller_channel, CF_ZRTP_PASSTHRU_REQ);
1996 }
1997 }
1998
1999 if (bypass_media && switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA) && !switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
2000 switch_core_session_message_t msg = { 0 };
2001
2002 msg.message_id = SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS;
2003 msg.from = __FILE__"src/switch_ivr_originate.c";
2004 switch_core_session_receive_message(session, &msg)switch_core_session_perform_receive_message(session, &msg
, "src/switch_ivr_originate.c", (const char *)__func__, 2004);
2005 }
2006
2007
2008 if (!zstr(bypass_media)_zstr(bypass_media) && !switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
2009 if (switch_true(bypass_media)) {
2010 switch_channel_set_flag(caller_channel, CF_PROXY_MODE)switch_channel_set_flag_value(caller_channel, CF_PROXY_MODE, 1
);
2011 } else if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
2012 if (!switch_channel_test_flag(caller_channel, CF_ANSWERED) && switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)) {
2013 switch_channel_set_variable(caller_channel, SWITCH_B_SDP_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "switch_m_sdp"
, ((void*)0), SWITCH_TRUE);
2014 switch_channel_answer(caller_channel)switch_channel_perform_answer(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 2014);
2015 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2015, (const char*)(session), SWITCH_LOG_WARNING,
2016 "Must answer channel %s due to SIP PARADOX\n", switch_channel_get_name(caller_channel));
2017 }
2018 switch_channel_set_variable(caller_channel, SWITCH_B_SDP_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "switch_m_sdp"
, ((void*)0), SWITCH_TRUE);
2019 switch_ivr_media(switch_core_session_get_uuid(session), SMF_NONE);
2020 }
2021 }
2022
2023 if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) && switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
2024 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2024, (const char*)(session), SWITCH_LOG_DEBUG,
2025 "Channel is already up, delaying proxy mode 'till both legs are answered.\n");
2026 switch_channel_set_variable(caller_channel, "bypass_media_after_bridge", "true")switch_channel_set_variable_var_check(caller_channel, "bypass_media_after_bridge"
, "true", SWITCH_TRUE);
2027 switch_channel_set_variable(caller_channel, SWITCH_BYPASS_MEDIA_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "bypass_media"
, ((void*)0), SWITCH_TRUE);
2028 switch_channel_clear_flag(caller_channel, CF_PROXY_MODE);
2029 }
2030 }
2031
2032 if (timelimit_sec <= 0) {
2033 timelimit_sec = 60;
2034 }
2035
2036
2037 oglobals.idx = IDX_NADA;
2038 oglobals.early_ok = 1;
2039
2040 *bleg = NULL((void*)0);
2041
2042 switch_zmalloc(write_frame.data, SWITCH_RECOMMENDED_BUFFER_SIZE)(void)((((write_frame.data = calloc(1, (8192)))) ? (void) (0)
: __assert_fail ("(write_frame.data = calloc(1, (8192)))", "src/switch_ivr_originate.c"
, 2042, __PRETTY_FUNCTION__)),write_frame.data);
2043 write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE8192;
2044
2045 odata = strdup(bridgeto)(__extension__ (__builtin_constant_p (bridgeto) && ((
size_t)(const void *)((bridgeto) + 1) - (size_t)(const void *
)(bridgeto) == 1) ? (((const char *) (bridgeto))[0] == '\0' ?
(char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len =
strlen (bridgeto) + 1; char *__retval = (char *) malloc (__len
); if (__retval != ((void*)0)) __retval = (char *) memcpy (__retval
, bridgeto, __len); __retval; })) : __strdup (bridgeto)));
2046
2047 if (!odata) {
2048 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2048, (const char*)(session), SWITCH_LOG_ERROR, "Memory Error!\n");
2049 status = SWITCH_STATUS_MEMERR;
2050 goto done;
2051 }
2052
2053 data = odata;
2054
2055
2056 /* Some channel are created from an originating channel and some aren't so not all outgoing calls have a way to get params
2057 so we will normalize dialstring params and channel variables (when there is an originator) into an event that we
2058 will use as a pseudo hash to consult for params as needed.
2059 */
2060
2061 if (ovars) {
2062 var_event = ovars;
2063 } else {
2064 if (switch_event_create_plain(&var_event, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
2065 abort();
2066 }
2067 }
2068
2069 ent_aleg_uuid = switch_event_get_header(var_event, "ent_originate_aleg_uuid")switch_event_get_header_idx(var_event, "ent_originate_aleg_uuid"
, -1);
2070
2071 if (caller_channel) {
2072 switch_channel_process_export(caller_channel, NULL((void*)0), var_event, SWITCH_EXPORT_VARS_VARIABLE"export_vars");
2073 }
2074
2075 /* strip leading spaces */
2076 while (data && *data && *data == ' ') {
2077 data++;
2078 }
2079
2080 if ((ovars && switch_true(switch_event_get_header(ovars,"origination_nested_vars")switch_event_get_header_idx(ovars, "origination_nested_vars",
-1))) ||
2081 (caller_channel && switch_true(switch_channel_get_variable(caller_channel, "origination_nested_vars")switch_channel_get_variable_dup(caller_channel, "origination_nested_vars"
, SWITCH_TRUE, -1)))
2082 || switch_true(switch_core_get_variable("origination_nested_vars")) || switch_stristr("origination_nested_vars=true", data)) {
2083 oglobals.check_vars = SWITCH_FALSE;
2084 }
2085
2086
2087 /* extract channel variables, allowing multiple sets of braces */
2088 if (*data == '<') {
2089 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2089, (const char*)(session), SWITCH_LOG_DEBUG, "Parsing ultra-global variables\n");
2090 while (*data == '<') {
2091 char *parsed = NULL((void*)0);
2092
2093 if (switch_event_create_brackets(data, '<', '>', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
2094 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2094, (const char*)(session), SWITCH_LOG_ERROR, "Parse Error!\n");
2095 switch_goto_status(SWITCH_STATUS_GENERR, done)status = SWITCH_STATUS_GENERR; goto done;
2096 }
2097
2098 data = parsed;
2099 }
2100 }
2101
2102 /* extract channel variables, allowing multiple sets of braces */
2103 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2103, (const char*)(session), SWITCH_LOG_DEBUG, "Parsing global variables\n");
2104 while (*data == '{') {
2105 char *parsed = NULL((void*)0);
2106
2107 if (switch_event_create_brackets(data, '{', '}', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
2108 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2108, (const char*)(session), SWITCH_LOG_ERROR, "Parse Error!\n");
2109 switch_goto_status(SWITCH_STATUS_GENERR, done)status = SWITCH_STATUS_GENERR; goto done;
2110 }
2111
2112 data = parsed;
2113 }
2114
2115
2116 /* strip leading spaces (again) */
2117 while (data && *data && *data == ' ') {
2118 data++;
2119 }
2120
2121 if (zstr(data)_zstr(data)) {
2122 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2122, (const char*)(session), SWITCH_LOG_WARNING, "No origination URL specified!\n");
2123 status = SWITCH_STATUS_GENERR;
2124 goto done;
2125 }
2126
2127 if (!(flags & SOF_NOBLOCK) && var_event && (var = switch_event_get_header(var_event, "originate_delay_start")switch_event_get_header_idx(var_event, "originate_delay_start"
, -1))) {
2128 int tmp = atoi(var);
2129 if (tmp > 0) {
2130 while (tmp && (!cancel_cause || *cancel_cause == 0)) {
2131 switch_cond_next();
2132 tmp--;
2133 }
2134 }
2135 }
2136
2137 if (oglobals.session) {
2138 switch_event_header_t *hi;
2139 const char *cdr_total_var;
2140 const char *cdr_var;
2141 const char *json_cdr_var;
2142
2143 if ((cdr_var = switch_channel_get_variable(caller_channel, "failed_xml_cdr_prefix")switch_channel_get_variable_dup(caller_channel, "failed_xml_cdr_prefix"
, SWITCH_TRUE, -1))) {
2144 char buf[128] = "";
2145 switch_snprintf(buf, sizeof(buf), "%s_total", cdr_var);
2146 if ((cdr_total_var = switch_channel_get_variable(caller_channel, buf)switch_channel_get_variable_dup(caller_channel, buf, SWITCH_TRUE
, -1))) {
2147 int tmp = atoi(cdr_total_var);
2148 if (tmp > 0) {
2149 cdr_total = tmp;
2150 }
2151 }
2152 }
2153
2154 if ((json_cdr_var = switch_channel_get_variable(caller_channel, "failed_json_cdr_prefix")switch_channel_get_variable_dup(caller_channel, "failed_json_cdr_prefix"
, SWITCH_TRUE, -1))) {
2155 char buf[128] = "";
2156 switch_snprintf(buf, sizeof(buf), "%s_total", json_cdr_var);
2157 if ((cdr_total_var = switch_channel_get_variable(caller_channel, buf)switch_channel_get_variable_dup(caller_channel, buf, SWITCH_TRUE
, -1))) {
2158 int tmp = atoi(cdr_total_var);
2159 if (tmp > 0) {
2160 cdr_total = tmp;
2161 }
2162 }
2163 }
2164
2165 /* Copy all the missing applicable channel variables from A-leg into the event */
2166 if ((hi = switch_channel_variable_first(caller_channel))) {
2167 for (; hi; hi = hi->next) {
2168 int ok = 0;
2169 if (!strcasecmp((char *) hi->name, "group_confirm_key")) {
2170 ok = 1;
2171 } else if (!strcasecmp((char *) hi->name, "group_confirm_file")) {
2172 ok = 1;
2173 } else if (!strcasecmp((char *) hi->name, "group_confirm_read_timeout")) {
2174 ok = 1;
2175 } else if (!strcasecmp((char *) hi->name, "group_confirm_cancel_timeout")) {
2176 ok = 1;
2177 } else if (!strcasecmp((char *) hi->name, "forked_dial")) {
2178 ok = 1;
2179 } else if (!strcasecmp((char *) hi->name, "fail_on_single_reject")) {
2180 ok = 1;
2181 } else if (!strcasecmp((char *) hi->name, "hangup_on_single_reject")) {
2182 ok = 1;
2183 } else if (!strcasecmp((char *) hi->name, "ignore_early_media")) {
2184 ok = 1;
2185 } else if (!strcasecmp((char *) hi->name, "bridge_early_media")) {
2186 ok = 1;
2187 } else if (!strcasecmp((char *) hi->name, "originate_continue_on_timeout")) {
2188 ok = 1;
2189 } else if (!strcasecmp((char *) hi->name, "ignore_ring_ready")) {
2190 ok = 1;
2191 } else if (!strcasecmp((char *) hi->name, "monitor_early_media_ring")) {
2192 ok = 1;
2193 } else if (!strcasecmp((char *) hi->name, "monitor_early_media_ring_total")) {
2194 ok = 1;
2195 } else if (!strcasecmp((char *) hi->name, "monitor_early_media_fail")) {
2196 ok = 1;
2197 } else if (!strcasecmp((char *) hi->name, "return_ring_ready")) {
2198 ok = 1;
2199 } else if (!strcasecmp((char *) hi->name, "ring_ready")) {
2200 ok = 1;
2201 } else if (!strcasecmp((char *) hi->name, "instant_ringback")) {
2202 ok = 1;
2203 } else if (!strcasecmp((char *) hi->name, "progress_timeout")) {
2204 ok = 1;
2205 } else if (!strcasecmp((char *) hi->name, "language")) {
2206 ok = 1;
2207 }
2208
2209 if (ok && !switch_event_get_header(var_event, hi->name)switch_event_get_header_idx(var_event, hi->name, -1)) {
2210 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, (char *) hi->name, (char *) hi->value);
2211 }
2212 }
2213 switch_channel_variable_last(caller_channel);
2214 }
2215 /*
2216 if ((hi = switch_channel_variable_first(caller_channel))) {
2217 for (; hi; hi = switch_core_hash_next(&hi)) {
2218 switch_core_hash_this(hi, &vvar, NULL, &vval);
2219 if (vvar && vval) {
2220 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, (void *) vvar, (char *) vval);
2221 }
2222 }
2223 switch_channel_variable_last(caller_channel);
2224 }
2225 */
2226 }
2227
2228 if (caller_channel) { /* ringback is only useful when there is an originator */
2229 ringback_data = NULL((void*)0);
2230 cancel_key = switch_channel_get_variable(caller_channel, "origination_cancel_key")switch_channel_get_variable_dup(caller_channel, "origination_cancel_key"
, SWITCH_TRUE, -1);
2231
2232 if (switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
2233 ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback")switch_channel_get_variable_dup(caller_channel, "transfer_ringback"
, SWITCH_TRUE, -1);
2234 }
2235
2236 if (!ringback_data) {
2237 ringback_data = switch_channel_get_variable(caller_channel, "ringback")switch_channel_get_variable_dup(caller_channel, "ringback", SWITCH_TRUE
, -1);
2238 }
2239
2240 switch_channel_set_variable(caller_channel, "originate_disposition", "failure")switch_channel_set_variable_var_check(caller_channel, "originate_disposition"
, "failure", SWITCH_TRUE);
2241 switch_channel_set_variable(caller_channel, "DIALSTATUS", "INVALIDARGS")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "INVALIDARGS", SWITCH_TRUE);
2242
2243 if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) || switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
2244 ringback_data = NULL((void*)0);
2245 }
2246 }
2247#if 0
2248 /* changing behaviour ignore_early_media=true must also be explicitly set for previous behaviour */
2249 if (ringback_data) {
2250 oglobals.early_ok = 0;
2251 }
2252#endif
2253
2254 if (switch_true(switch_event_get_header(var_event, "group_confirm_cancel_timeout")switch_event_get_header_idx(var_event, "group_confirm_cancel_timeout"
, -1))) {
2255 oglobals.cancel_timeout = -1;
2256 }
2257
2258 if ((var = switch_event_get_header(var_event, "group_confirm_key")switch_event_get_header_idx(var_event, "group_confirm_key", -
1))) {
2259 switch_copy_string(oglobals.key, var, sizeof(oglobals.key));
2260 if ((var = switch_event_get_header(var_event, "group_confirm_file")switch_event_get_header_idx(var_event, "group_confirm_file", -
1))) {
2261 oglobals.file = strdup(var)(__extension__ (__builtin_constant_p (var) && ((size_t
)(const void *)((var) + 1) - (size_t)(const void *)(var) == 1
) ? (((const char *) (var))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (var) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, var, __len); __retval
; })) : __strdup (var)));
2262 }
2263 if ((var = switch_event_get_header(var_event, "group_confirm_error_file")switch_event_get_header_idx(var_event, "group_confirm_error_file"
, -1))) {
2264 oglobals.error_file = strdup(var)(__extension__ (__builtin_constant_p (var) && ((size_t
)(const void *)((var) + 1) - (size_t)(const void *)(var) == 1
) ? (((const char *) (var))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (var) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, var, __len); __retval
; })) : __strdup (var)));
2265 }
2266 if ((var = switch_event_get_header(var_event, "group_confirm_read_timeout")switch_event_get_header_idx(var_event, "group_confirm_read_timeout"
, -1))) {
2267 int tmp = atoi(var);
2268
2269 if (tmp >= 0) {
2270 oglobals.confirm_timeout = tmp;
2271 }
2272
2273 }
2274 }
2275 /* When using the AND operator, the fail_on_single_reject flag may be set in order to indicate that a single
2276 rejections should terminate the attempt rather than a timeout, answer, or rejection by all.
2277 If the value is set to 'true' any fail cause will end the attempt otherwise it can contain a comma (,) separated
2278 list of cause names which should be considered fatal
2279 */
2280 if ((var = switch_event_get_header(var_event, "hangup_on_single_reject")switch_event_get_header_idx(var_event, "hangup_on_single_reject"
, -1))) {
2281 hangup_on_single_reject = 1;
2282 }
2283
2284 if (hangup_on_single_reject || (var = switch_event_get_header(var_event, "fail_on_single_reject")switch_event_get_header_idx(var_event, "fail_on_single_reject"
, -1))) {
2285 fail_on_single_reject_var = strdup(var)(__extension__ (__builtin_constant_p (var) && ((size_t
)(const void *)((var) + 1) - (size_t)(const void *)(var) == 1
) ? (((const char *) (var))[0] == '\0' ? (char *) calloc ((size_t
) 1, (size_t) 1) : ({ size_t __len = strlen (var) + 1; char *
__retval = (char *) malloc (__len); if (__retval != ((void*)0
)) __retval = (char *) memcpy (__retval, var, __len); __retval
; })) : __strdup (var)));
2286 if (switch_true(var)) {
2287 fail_on_single_reject = 1;
2288 } else {
2289 fail_on_single_reject = -1;
2290 }
2291 }
2292
2293 if ((!zstr(oglobals.file)_zstr(oglobals.file)) && (!strcmp(oglobals.file, "undef")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(oglobals.file) && __builtin_constant_p ("undef") &&
(__s1_len = __builtin_strlen (oglobals.file), __s2_len = __builtin_strlen
("undef"), (!((size_t)(const void *)((oglobals.file) + 1) - (
size_t)(const void *)(oglobals.file) == 1) || __s1_len >= 4
) && (!((size_t)(const void *)(("undef") + 1) - (size_t
)(const void *)("undef") == 1) || __s2_len >= 4)) ? __builtin_strcmp
(oglobals.file, "undef") : (__builtin_constant_p (oglobals.file
) && ((size_t)(const void *)((oglobals.file) + 1) - (
size_t)(const void *)(oglobals.file) == 1) && (__s1_len
= __builtin_strlen (oglobals.file), __s1_len < 4) ? (__builtin_constant_p
("undef") && ((size_t)(const void *)(("undef") + 1) -
(size_t)(const void *)("undef") == 1) ? __builtin_strcmp (oglobals
.file, "undef") : (__extension__ ({ const unsigned char *__s2
= (const unsigned char *) (const char *) ("undef"); int __result
= (((const unsigned char *) (const char *) (oglobals.file))[
0] - __s2[0]); if (__s1_len > 0 && __result == 0) {
__result = (((const unsigned char *) (const char *) (oglobals
.file))[1] - __s2[1]); if (__s1_len > 1 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
oglobals.file))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (oglobals.file))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("undef") && ((size_t)(const void *)(("undef") + 1) -
(size_t)(const void *)("undef") == 1) && (__s2_len =
__builtin_strlen ("undef"), __s2_len < 4) ? (__builtin_constant_p
(oglobals.file) && ((size_t)(const void *)((oglobals
.file) + 1) - (size_t)(const void *)(oglobals.file) == 1) ? __builtin_strcmp
(oglobals.file, "undef") : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (oglobals
.file); int __result = (((const unsigned char *) (const char *
) ("undef"))[0] - __s2[0]); if (__s2_len > 0 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
"undef"))[1] - __s2[1]); if (__s2_len > 1 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
"undef"))[2] - __s2[2]); if (__s2_len > 2 && __result
== 0) __result = (((const unsigned char *) (const char *) ("undef"
))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (oglobals
.file, "undef")))); }))) {
2294 switch_safe_free(oglobals.file)if (oglobals.file) {free(oglobals.file);oglobals.file=((void*
)0);};
2295 oglobals.file = NULL((void*)0);
2296 }
2297 if ((!zstr(oglobals.error_file)_zstr(oglobals.error_file)) && (!strcmp(oglobals.error_file, "undef")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(oglobals.error_file) && __builtin_constant_p ("undef"
) && (__s1_len = __builtin_strlen (oglobals.error_file
), __s2_len = __builtin_strlen ("undef"), (!((size_t)(const void
*)((oglobals.error_file) + 1) - (size_t)(const void *)(oglobals
.error_file) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)(("undef") + 1) - (size_t)(const void *)("undef"
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (oglobals.error_file
, "undef") : (__builtin_constant_p (oglobals.error_file) &&
((size_t)(const void *)((oglobals.error_file) + 1) - (size_t
)(const void *)(oglobals.error_file) == 1) && (__s1_len
= __builtin_strlen (oglobals.error_file), __s1_len < 4) ?
(__builtin_constant_p ("undef") && ((size_t)(const void
*)(("undef") + 1) - (size_t)(const void *)("undef") == 1) ? __builtin_strcmp
(oglobals.error_file, "undef") : (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) ("undef"
); int __result = (((const unsigned char *) (const char *) (oglobals
.error_file))[0] - __s2[0]); if (__s1_len > 0 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
oglobals.error_file))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (oglobals.error_file))[2] - __s2[2]); if (__s1_len >
2 && __result == 0) __result = (((const unsigned char
*) (const char *) (oglobals.error_file))[3] - __s2[3]); } } __result
; }))) : (__builtin_constant_p ("undef") && ((size_t)
(const void *)(("undef") + 1) - (size_t)(const void *)("undef"
) == 1) && (__s2_len = __builtin_strlen ("undef"), __s2_len
< 4) ? (__builtin_constant_p (oglobals.error_file) &&
((size_t)(const void *)((oglobals.error_file) + 1) - (size_t
)(const void *)(oglobals.error_file) == 1) ? __builtin_strcmp
(oglobals.error_file, "undef") : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (oglobals
.error_file); int __result = (((const unsigned char *) (const
char *) ("undef"))[0] - __s2[0]); if (__s2_len > 0 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("undef"))[1] - __s2[1]); if (__s2_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) ("undef"))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) ("undef"))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(oglobals.error_file, "undef")))); }))) {
2298 switch_safe_free(oglobals.error_file)if (oglobals.error_file) {free(oglobals.error_file);oglobals.
error_file=((void*)0);};
2299 oglobals.error_file = NULL((void*)0);
2300 }
2301
2302 if ((var_val = switch_event_get_header(var_event, "bridge_early_media")switch_event_get_header_idx(var_event, "bridge_early_media", -
1))) {
2303 if (switch_true(var_val)) {
2304 oglobals.early_ok = 0;
2305 oglobals.ignore_early_media = 3;
2306 }
2307 }
2308
2309 if ((var_val = switch_event_get_header(var_event, "ignore_early_media")switch_event_get_header_idx(var_event, "ignore_early_media", -
1))) {
2310 if (switch_true(var_val)) {
2311 oglobals.early_ok = 0;
2312 oglobals.ignore_early_media = 1;
2313 } else if (!strcmp(var_val, "consume")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(var_val) && __builtin_constant_p ("consume") &&
(__s1_len = __builtin_strlen (var_val), __s2_len = __builtin_strlen
("consume"), (!((size_t)(const void *)((var_val) + 1) - (size_t
)(const void *)(var_val) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)(("consume") + 1) - (size_t)(const void
*)("consume") == 1) || __s2_len >= 4)) ? __builtin_strcmp
(var_val, "consume") : (__builtin_constant_p (var_val) &&
((size_t)(const void *)((var_val) + 1) - (size_t)(const void
*)(var_val) == 1) && (__s1_len = __builtin_strlen (var_val
), __s1_len < 4) ? (__builtin_constant_p ("consume") &&
((size_t)(const void *)(("consume") + 1) - (size_t)(const void
*)("consume") == 1) ? __builtin_strcmp (var_val, "consume") :
(__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) ("consume"); int __result = (((const unsigned
char *) (const char *) (var_val))[0] - __s2[0]); if (__s1_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (var_val))[1] - __s2[1]); if (__s1_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (var_val))[2] - __s2[2]); if (__s1_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (var_val))[3] - __s2[3]); } } __result
; }))) : (__builtin_constant_p ("consume") && ((size_t
)(const void *)(("consume") + 1) - (size_t)(const void *)("consume"
) == 1) && (__s2_len = __builtin_strlen ("consume"), __s2_len
< 4) ? (__builtin_constant_p (var_val) && ((size_t
)(const void *)((var_val) + 1) - (size_t)(const void *)(var_val
) == 1) ? __builtin_strcmp (var_val, "consume") : (- (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (var_val); int __result = (((const unsigned char *) (
const char *) ("consume"))[0] - __s2[0]); if (__s2_len > 0
&& __result == 0) { __result = (((const unsigned char
*) (const char *) ("consume"))[1] - __s2[1]); if (__s2_len >
1 && __result == 0) { __result = (((const unsigned char
*) (const char *) ("consume"))[2] - __s2[2]); if (__s2_len >
2 && __result == 0) __result = (((const unsigned char
*) (const char *) ("consume"))[3] - __s2[3]); } } __result; }
)))) : __builtin_strcmp (var_val, "consume")))); })) {
2314 oglobals.early_ok = 0;
2315 oglobals.ignore_early_media = 4;
2316 } else if (!strcmp(var_val, "ring_ready")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(var_val) && __builtin_constant_p ("ring_ready") &&
(__s1_len = __builtin_strlen (var_val), __s2_len = __builtin_strlen
("ring_ready"), (!((size_t)(const void *)((var_val) + 1) - (
size_t)(const void *)(var_val) == 1) || __s1_len >= 4) &&
(!((size_t)(const void *)(("ring_ready") + 1) - (size_t)(const
void *)("ring_ready") == 1) || __s2_len >= 4)) ? __builtin_strcmp
(var_val, "ring_ready") : (__builtin_constant_p (var_val) &&
((size_t)(const void *)((var_val) + 1) - (size_t)(const void
*)(var_val) == 1) && (__s1_len = __builtin_strlen (var_val
), __s1_len < 4) ? (__builtin_constant_p ("ring_ready") &&
((size_t)(const void *)(("ring_ready") + 1) - (size_t)(const
void *)("ring_ready") == 1) ? __builtin_strcmp (var_val, "ring_ready"
) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) ("ring_ready"); int __result = (((const
unsigned char *) (const char *) (var_val))[0] - __s2[0]); if
(__s1_len > 0 && __result == 0) { __result = (((const
unsigned char *) (const char *) (var_val))[1] - __s2[1]); if
(__s1_len > 1 && __result == 0) { __result = (((const
unsigned char *) (const char *) (var_val))[2] - __s2[2]); if
(__s1_len > 2 && __result == 0) __result = (((const
unsigned char *) (const char *) (var_val))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p ("ring_ready") &&
((size_t)(const void *)(("ring_ready") + 1) - (size_t)(const
void *)("ring_ready") == 1) && (__s2_len = __builtin_strlen
("ring_ready"), __s2_len < 4) ? (__builtin_constant_p (var_val
) && ((size_t)(const void *)((var_val) + 1) - (size_t
)(const void *)(var_val) == 1) ? __builtin_strcmp (var_val, "ring_ready"
) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (var_val); int __result = (((const unsigned
char *) (const char *) ("ring_ready"))[0] - __s2[0]); if (__s2_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) ("ring_ready"))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) ("ring_ready"))[2] - __s2[2]); if (__s2_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) ("ring_ready"))[3] - __s2[3]); } } __result
; })))) : __builtin_strcmp (var_val, "ring_ready")))); })) {
2317 oglobals.early_ok = 0;
2318 oglobals.ignore_early_media = 2;
2319 }
2320 }
2321
2322 if ((var_val = switch_event_get_header(var_event, "originate_continue_on_timeout")switch_event_get_header_idx(var_event, "originate_continue_on_timeout"
, -1)) && switch_true(var_val)) {
2323 oglobals.continue_on_timeout = 1;
2324 }
2325
2326 if ((var_val = switch_event_get_header(var_event, "ignore_ring_ready")switch_event_get_header_idx(var_event, "ignore_ring_ready", -
1)) && switch_true(var_val)) {
2327 oglobals.ignore_ring_ready = 1;
2328 }
2329
2330 if ((var_val = switch_event_get_header(var_event, "monitor_early_media_ring")switch_event_get_header_idx(var_event, "monitor_early_media_ring"
, -1))) {
2331 oglobals.early_ok = 0;
2332 oglobals.monitor_early_media_ring = 1;
2333 }
2334
2335 if ((var_val = switch_event_get_header(var_event, "monitor_early_media_fail")switch_event_get_header_idx(var_event, "monitor_early_media_fail"
, -1))) {
2336 oglobals.early_ok = 0;
2337 oglobals.monitor_early_media_fail = 1;
2338 }
2339
2340 if ((var_val = switch_event_get_header(var_event, "return_ring_ready")switch_event_get_header_idx(var_event, "return_ring_ready", -
1)) && switch_true(var_val)) {
2341 oglobals.return_ring_ready = 1;
2342 }
2343
2344 if ((var_val = switch_event_get_header(var_event, "ring_ready")switch_event_get_header_idx(var_event, "ring_ready", -1)) && switch_true(var_val)) {
2345 oglobals.ring_ready = 1;
2346 }
2347
2348 if ((var_val = switch_event_get_header(var_event, "instant_ringback")switch_event_get_header_idx(var_event, "instant_ringback", -1
)) && switch_true(var_val)) {
2349 oglobals.instant_ringback = 1;
2350 }
2351
2352 if ((var_val = switch_event_get_header(var_event, "originate_timeout")switch_event_get_header_idx(var_event, "originate_timeout", -
1))) {
2353 int tmp = atoi(var_val);
2354 if (tmp > 0) {
2355 timelimit_sec = (uint32_t) tmp;
2356 }
2357 }
2358
2359 if ((var_val = switch_event_get_header(var_event, "progress_timeout")switch_event_get_header_idx(var_event, "progress_timeout", -1
))) {
2360 int tmp = atoi(var_val);
2361 if (tmp > 0) {
2362 progress_timelimit_sec = (uint32_t) tmp;
2363 }
2364 }
2365
2366 if ((var_val = switch_event_get_header(var_event, "originate_retries")switch_event_get_header_idx(var_event, "originate_retries", -
1)) && switch_true(var_val)) {
2367 int32_t tmp;
2368 tmp = atoi(var_val);
2369 if (tmp > 0 && tmp < 101) {
2370 retries = tmp;
2371 } else {
2372 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2372, (const char*)(session), SWITCH_LOG_WARNING,
2373 "Invalid originate_retries setting of %d ignored, value must be between 1 and 100\n", tmp);
2374 }
2375 }
2376
2377 if ((var_val = switch_event_get_header(var_event, "originate_retry_sleep_ms")switch_event_get_header_idx(var_event, "originate_retry_sleep_ms"
, -1)) && switch_true(var_val)) {
2378 int32_t tmp;
2379 tmp = atoi(var_val);
2380 if (tmp >= 500 && tmp <= 60000) {
2381 sleep_ms = tmp;
2382 } else {
2383 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2383, (const char*)(session), SWITCH_LOG_WARNING,
2384 "Invalid originate_retry_sleep_ms setting of %d ignored, value must be between 500 and 60000\n", tmp);
2385 }
2386 }
2387
2388 /* variable to force ANI / ANIII */
2389 ani_override = switch_event_get_header(var_event, "origination_ani")switch_event_get_header_idx(var_event, "origination_ani", -1);
2390 aniii_override = switch_event_get_header(var_event, "origination_aniii")switch_event_get_header_idx(var_event, "origination_aniii", -
1);
2391
2392 if ((cid_tmp = switch_event_get_header(var_event, "origination_caller_id_name")switch_event_get_header_idx(var_event, "origination_caller_id_name"
, -1))) {
2393 cid_name_override = cid_tmp;
2394 }
2395
2396 if (cid_name_override) {
2397 if (!cid_tmp) {
2398 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_name", cid_name_override);
2399 }
2400 } else {
2401 cid_name_override = switch_event_get_header(var_event, "origination_caller_id_name")switch_event_get_header_idx(var_event, "origination_caller_id_name"
, -1);
2402 }
2403
2404 if ((cid_tmp = switch_event_get_header(var_event, "origination_caller_id_number")switch_event_get_header_idx(var_event, "origination_caller_id_number"
, -1))) {
2405 cid_num_override = cid_tmp;
2406 }
2407
2408 if (cid_num_override) {
2409 if (!cid_tmp) {
2410 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_number", cid_num_override);
2411 }
2412 } else {
2413 cid_num_override = switch_event_get_header(var_event, "origination_caller_id_number")switch_event_get_header_idx(var_event, "origination_caller_id_number"
, -1);
2414 }
2415
2416 if (flags & SOF_NO_LIMITS) {
2417 dftflags |= SOF_NO_LIMITS;
2418 }
2419
2420 if (ani_override) {
2421 dftflags |= SOF_NO_EFFECTIVE_ANI;
2422 }
2423
2424 if (aniii_override) {
2425 dftflags |= SOF_NO_EFFECTIVE_ANIII;
2426 }
2427
2428 if (cid_num_override) {
2429 dftflags |= SOF_NO_EFFECTIVE_CID_NUM;
2430 }
2431
2432 if (cid_name_override) {
2433 dftflags |= SOF_NO_EFFECTIVE_CID_NAME;
2434 }
2435
2436 if (!progress_timelimit_sec) {
2437 progress_timelimit_sec = timelimit_sec;
2438 }
2439
2440 for (try = 0; try < retries; try++) {
2441 switch_safe_free(loop_data)if (loop_data) {free(loop_data);loop_data=((void*)0);};
2442 loop_data = strdup(data)(__extension__ (__builtin_constant_p (data) && ((size_t
)(const void *)((data) + 1) - (size_t)(const void *)(data) ==
1) ? (((const char *) (data))[0] == '\0' ? (char *) calloc (
(size_t) 1, (size_t) 1) : ({ size_t __len = strlen (data) + 1
; char *__retval = (char *) malloc (__len); if (__retval != (
(void*)0)) __retval = (char *) memcpy (__retval, data, __len)
; __retval; })) : __strdup (data)));
2443 switch_assert(loop_data)((loop_data) ? (void) (0) : __assert_fail ("loop_data", "src/switch_ivr_originate.c"
, 2443, __PRETTY_FUNCTION__));
2444 or_argc = switch_separate_string(loop_data, '|', pipe_names, (sizeof(pipe_names) / sizeof(pipe_names[0])));
2445
2446 if ((flags & SOF_NOBLOCK) && or_argc > 1) {
2447 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2447, (const char*)(session), SWITCH_LOG_WARNING, "Only calling the first element in the list in this mode.\n");
2448 or_argc = 1;
2449 }
2450
2451 for (r = 0; r < or_argc && (!cancel_cause || *cancel_cause == 0); r++) {
2452 char *p, *end = NULL((void*)0);
2453 int q = 0, alt = 0;
2454
2455 check_reject = 1;
2456
2457 oglobals.hups = 0;
2458
2459 reason = SWITCH_CAUSE_NONE;
2460 memset(peer_names, 0, sizeof(peer_names));
2461 peer_session = NULL((void*)0);
2462 memset(originate_status, 0, sizeof(originate_status));
2463 new_profile = NULL((void*)0);
2464 new_session = NULL((void*)0);
2465 chan_type = NULL((void*)0);
2466 chan_data = NULL((void*)0);
2467 peer_channel = NULL((void*)0);
2468 start = 0;
2469 read_frame = NULL((void*)0);
2470 oglobals.ringback_ok = 1;
2471 var = NULL((void*)0);
2472 to = 0;
2473 oglobals.sent_ring = 0;
2474 oglobals.progress = 0;
2475 myflags = dftflags;
2476
2477
2478 if (try > 0) {
2479 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2479, (const char*)(session), SWITCH_LOG_NOTICE, "Originate attempt %d/%d in %d ms\n", try + 1, retries,
2480 sleep_ms);
2481 if (caller_channel) {
2482 switch_ivr_sleep(oglobals.session, sleep_ms, SWITCH_TRUE, NULL((void*)0));
2483 if (!switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
2484 status = SWITCH_STATUS_FALSE;
2485 /* set try and retries to 0 */
2486 try = 0;
2487 retries = 0;
2488 goto done;
2489 }
2490 } else {
2491 switch_yield(sleep_ms * 1000)switch_sleep(sleep_ms * 1000);;
2492 }
2493 }
2494
2495 p = pipe_names[r];
2496
2497 while (p && *p) {
2498 if (*p == '[') {
2499 end = switch_find_end_paren(p, '[', ']');
2500 if (*(p+1) == '^' && *(p + 2) == '^') {
2501 alt = 1;
2502 } else {
2503 alt = 0;
2504 }
2505 q = 0;
2506 }
2507
2508 if (*p == '\'') {
2509 q = !q;
2510 }
2511
2512 if (end && p < end && *p == ',' && *(p-1) != '\\') {
2513
2514 if (q || alt) {
2515 *p = QUOTED_ESC_COMMA1;
2516 } else {
2517 *p = UNQUOTED_ESC_COMMA2;
2518 }
2519 }
2520
2521 if (p == end) {
2522 end = switch_strchr_strict(p, '[', " ");
2523 }
2524
2525 p++;
2526 }
2527
2528 and_argc = switch_separate_string(pipe_names[r], ',', peer_names, (sizeof(peer_names) / sizeof(peer_names[0])));
2529
2530 if ((flags & SOF_NOBLOCK) && and_argc > 1) {
2531 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2531, (const char*)(session), SWITCH_LOG_WARNING, "Only calling the first element in the list in this mode.\n");
2532 and_argc = 1;
2533 }
2534
2535 for (i = 0; i < and_argc; i++) {
2536 const char *current_variable;
2537 switch_event_t *local_var_event = NULL((void*)0), *originate_var_event = NULL((void*)0);
2538
2539 end = NULL((void*)0);
2540
2541 chan_type = peer_names[i];
2542
2543
2544 /* strip leading spaces */
2545 while (chan_type && *chan_type && *chan_type == ' ') {
2546 chan_type++;
2547 }
2548
2549 /* extract channel variables, allowing multiple sets of braces */
2550
2551 if (*chan_type == '[') {
2552 switch_event_create_plain(&local_var_event, SWITCH_EVENT_CHANNEL_DATA);
2553 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2553, (const char*)(session), SWITCH_LOG_DEBUG, "Parsing session specific variables\n");
2554 }
2555
2556 while (*chan_type == '[') {
2557 char *parsed = NULL((void*)0);
2558 char *bend = switch_find_end_paren(chan_type, '[', ']');
2559
2560 for (p = chan_type + 1; p && p < bend && *p; p++) {
2561 if (*p == QUOTED_ESC_COMMA1) {
2562 *p = ',';
2563 }
2564 }
2565
2566 if (switch_event_create_brackets(chan_type, '[', ']', UNQUOTED_ESC_COMMA2,
2567 &local_var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
2568 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2568, (const char*)(session), SWITCH_LOG_ERROR, "Parse Error!\n");
2569 switch_goto_status(SWITCH_STATUS_GENERR, done)status = SWITCH_STATUS_GENERR; goto done;
2570 }
2571
2572 if (chan_type == parsed) {
2573 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2573, (const char*)(session), SWITCH_LOG_ERROR, "Parse Error!\n");
2574 switch_goto_status(SWITCH_STATUS_GENERR, done)status = SWITCH_STATUS_GENERR; goto done;
2575 } else {
2576 chan_type = parsed;
2577 }
2578 }
2579
2580
2581 /* strip leading spaces (again) */
2582 while (chan_type && *chan_type && *chan_type == ' ') {
2583 chan_type++;
2584 }
2585
2586 if ((chan_data = strchr(chan_type, '/')(__extension__ (__builtin_constant_p ('/') && !__builtin_constant_p
(chan_type) && ('/') == '\0' ? (char *) __rawmemchr (
chan_type, '/') : __builtin_strchr (chan_type, '/')))) != 0) {
2587 *chan_data = '\0';
2588 chan_data++;
2589 }
2590
2591 if (oglobals.session) {
2592 if (!switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
2593 status = SWITCH_STATUS_FALSE;
2594 goto done;
2595 }
2596
2597 if ((caller_caller_profile = oglobals.caller_profile_override)) {
2598 new_profile = switch_caller_profile_dup(oglobals.pool, caller_caller_profile);
2599 } else {
2600 new_profile = switch_caller_profile_new(oglobals.pool,
2601 NULL((void*)0),
2602 NULL((void*)0),
2603 cid_name_override, cid_num_override, NULL((void*)0), ani_override, aniii_override, NULL((void*)0), __FILE__"src/switch_ivr_originate.c", NULL((void*)0), chan_data);
2604 }
2605
2606 new_profile->uuid = SWITCH_BLANK_STRING"";
2607 new_profile->chan_name = SWITCH_BLANK_STRING"";
2608 new_profile->destination_number = switch_core_strdup(new_profile->pool, chan_data)switch_core_perform_strdup(new_profile->pool, chan_data, "src/switch_ivr_originate.c"
, (const char *)__func__, 2608);
2609
2610 if (ani_override) {
2611 new_profile->ani = switch_core_strdup(new_profile->pool, ani_override)switch_core_perform_strdup(new_profile->pool, ani_override
, "src/switch_ivr_originate.c", (const char *)__func__, 2611);
2612 }
2613 if (aniii_override) {
2614 new_profile->aniii = switch_core_strdup(new_profile->pool, aniii_override)switch_core_perform_strdup(new_profile->pool, aniii_override
, "src/switch_ivr_originate.c", (const char *)__func__, 2614);
2615 }
2616 if (cid_name_override) {
2617 new_profile->caller_id_name = switch_core_strdup(new_profile->pool, cid_name_override)switch_core_perform_strdup(new_profile->pool, cid_name_override
, "src/switch_ivr_originate.c", (const char *)__func__, 2617);
2618 }
2619 if (cid_num_override) {
2620 new_profile->caller_id_number = switch_core_strdup(new_profile->pool, cid_num_override)switch_core_perform_strdup(new_profile->pool, cid_num_override
, "src/switch_ivr_originate.c", (const char *)__func__, 2620);
2621 }
2622 } else {
2623 if (oglobals.caller_profile_override) {
2624 new_profile = switch_caller_profile_dup(oglobals.pool, oglobals.caller_profile_override);
2625 new_profile->destination_number = switch_core_strdup(new_profile->pool, switch_str_nil(chan_data))switch_core_perform_strdup(new_profile->pool, (chan_data ?
chan_data : ""), "src/switch_ivr_originate.c", (const char *
)__func__, 2625);
2626 new_profile->uuid = SWITCH_BLANK_STRING"";
2627 new_profile->chan_name = SWITCH_BLANK_STRING"";
2628 } else {
2629 if (!cid_name_override) {
2630 cid_name_override = SWITCH_DEFAULT_CLID_NAME"";
2631 }
2632 if (!cid_num_override) {
2633 cid_num_override = SWITCH_DEFAULT_CLID_NUMBER"0000000000";
2634 }
2635
2636 new_profile = switch_caller_profile_new(oglobals.pool,
2637 NULL((void*)0),
2638 NULL((void*)0),
2639 cid_name_override, cid_num_override, NULL((void*)0), ani_override, aniii_override, NULL((void*)0), __FILE__"src/switch_ivr_originate.c", NULL((void*)0), chan_data);
2640 }
2641 }
2642
2643 if (zstr(new_profile->destination_number)_zstr(new_profile->destination_number)) {
2644 new_profile->destination_number = switch_core_strdup(new_profile->pool, "service")switch_core_perform_strdup(new_profile->pool, "service", "src/switch_ivr_originate.c"
, (const char *)__func__, 2644);
2645 }
2646
2647 new_profile->callee_id_name = switch_core_strdup(new_profile->pool, "Outbound Call")switch_core_perform_strdup(new_profile->pool, "Outbound Call"
, "src/switch_ivr_originate.c", (const char *)__func__, 2647);
2648 new_profile->callee_id_number = switch_sanitize_number(switch_core_strdup(new_profile->pool, new_profile->destination_number)switch_core_perform_strdup(new_profile->pool, new_profile->
destination_number, "src/switch_ivr_originate.c", (const char
*)__func__, 2648));
2649
2650 originate_status[i].caller_profile = NULL((void*)0);
2651 originate_status[i].peer_channel = NULL((void*)0);
2652 originate_status[i].peer_session = NULL((void*)0);
2653 new_session = NULL((void*)0);
2654
2655 if (and_argc > 1 || or_argc > 1) {
2656 myflags |= SOF_FORKED_DIAL;
2657 }
2658
2659 if (var_event) {
2660 const char *vvar;
2661 if ((vvar = switch_event_get_header(var_event, "forked_dial")switch_event_get_header_idx(var_event, "forked_dial", -1)) && switch_true(vvar)) {
2662 myflags |= SOF_FORKED_DIAL;
2663 }
2664 if ((vvar = switch_event_get_header(var_event, "no_throttle_limits")switch_event_get_header_idx(var_event, "no_throttle_limits", -
1)) && switch_true(vvar)) {
2665 myflags |= SOF_NO_LIMITS;
2666 }
2667 }
2668
2669
2670 /* Valid in both {} and [] with [] taking precedence */
2671
2672 /* make a special var event with mixture of the {} and the [] vars to pass down as global vars to the outgoing channel
2673 so if something like the user channel does another originate our options will be passed down properly
2674 */
2675
2676 switch_event_dup(&originate_var_event, var_event);
2677
2678 if (local_var_event) {
2679 switch_event_merge(originate_var_event, local_var_event);
2680 }
2681
2682 if ((current_variable = switch_event_get_header(originate_var_event, "origination_ani")switch_event_get_header_idx(originate_var_event, "origination_ani"
, -1))) {
2683 new_profile->ani = switch_core_strdup(new_profile->pool, current_variable)switch_core_perform_strdup(new_profile->pool, current_variable
, "src/switch_ivr_originate.c", (const char *)__func__, 2683);
2684 myflags |= SOF_NO_EFFECTIVE_ANI;
2685 }
2686
2687 if ((current_variable = switch_event_get_header(originate_var_event, "origination_aniii")switch_event_get_header_idx(originate_var_event, "origination_aniii"
, -1))) {
2688 new_profile->aniii = switch_core_strdup(new_profile->pool, current_variable)switch_core_perform_strdup(new_profile->pool, current_variable
, "src/switch_ivr_originate.c", (const char *)__func__, 2688);
2689 myflags |= SOF_NO_EFFECTIVE_ANIII;
2690 }
2691
2692 if ((current_variable = switch_event_get_header(originate_var_event, "origination_caller_id_number")switch_event_get_header_idx(originate_var_event, "origination_caller_id_number"
, -1))) {
2693 new_profile->caller_id_number = switch_core_strdup(new_profile->pool, current_variable)switch_core_perform_strdup(new_profile->pool, current_variable
, "src/switch_ivr_originate.c", (const char *)__func__, 2693);
2694 myflags |= SOF_NO_EFFECTIVE_CID_NUM;
2695 }
2696
2697 if ((current_variable = switch_event_get_header(originate_var_event, "origination_caller_id_name")switch_event_get_header_idx(originate_var_event, "origination_caller_id_name"
, -1))) {
2698 new_profile->caller_id_name = switch_core_strdup(new_profile->pool, current_variable)switch_core_perform_strdup(new_profile->pool, current_variable
, "src/switch_ivr_originate.c", (const char *)__func__, 2698);
2699 myflags |= SOF_NO_EFFECTIVE_CID_NAME;
2700 }
2701
2702 if ((current_variable = switch_event_get_header(originate_var_event, "origination_privacy")switch_event_get_header_idx(originate_var_event, "origination_privacy"
, -1))) {
2703 new_profile->flags = SWITCH_CPF_NONE;
2704
2705 if (switch_stristr("screen", current_variable)) {
2706 switch_set_flag(new_profile, SWITCH_CPF_SCREEN)(new_profile)->flags |= (SWITCH_CPF_SCREEN);
2707 }
2708
2709 if (switch_stristr("hide_name", current_variable)) {
2710 switch_set_flag(new_profile, SWITCH_CPF_HIDE_NAME)(new_profile)->flags |= (SWITCH_CPF_HIDE_NAME);
2711 }
2712
2713 if (switch_stristr("hide_number", current_variable)) {
2714 switch_set_flag(new_profile, SWITCH_CPF_HIDE_NUMBER)(new_profile)->flags |= (SWITCH_CPF_HIDE_NUMBER);
2715 }
2716 }
2717
2718 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "originate_early_media", oglobals.early_ok ? "true" : "false");
2719
2720
2721 if (caller_channel && switch_true(switch_channel_get_variable(caller_channel, "push_channel_name")switch_channel_get_variable_dup(caller_channel, "push_channel_name"
, SWITCH_TRUE, -1))) {
2722 char *new_name = switch_core_session_sprintf(session, "%s__B", switch_channel_get_name(caller_channel));
2723 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_channel_name", new_name);
2724 new_name = switch_core_session_sprintf(session, "_%s", switch_channel_get_name(caller_channel));
2725 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "sip_h_X-FS-Channel-Name", new_name);
2726 }
2727
2728
2729 reason = switch_core_session_outgoing_channel(oglobals.session, originate_var_event, chan_type,
2730 new_profile, &new_session, NULL((void*)0), myflags, cancel_cause);
2731
2732 switch_event_destroy(&originate_var_event);
2733
2734 if (reason != SWITCH_CAUSE_SUCCESS) {
2735 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2735, (const char*)(session), SWITCH_LOG_NOTICE, "Cannot create outgoing channel of type [%s] cause: [%s]\n",
2736 chan_type, switch_channel_cause2str(reason));
2737 if (local_var_event) switch_event_destroy(&local_var_event);
2738
2739 if (fail_on_single_reject_var) {
2740 const char *cause_str = switch_channel_cause2str(reason);
2741 int neg = *fail_on_single_reject_var == '!';
2742 int pos = !!switch_stristr(cause_str, fail_on_single_reject_var);
2743
2744 if (neg) {
2745 pos = !pos;
2746 }
2747
2748 check_reject = 0;
2749
2750 if (fail_on_single_reject == 1 || pos) {
2751 force_reason = reason;
2752 status = SWITCH_STATUS_FALSE;
2753 goto outer_for;
2754 }
2755 }
2756 continue;
2757 }
2758
2759 if (switch_core_session_read_lock(new_session) != SWITCH_STATUS_SUCCESS) {
2760 status = SWITCH_STATUS_FALSE;
2761 if (local_var_event) switch_event_destroy(&local_var_event);
2762 goto done;
2763 }
2764
2765 originate_status[i].peer_channel = switch_core_session_get_channel(new_session);
2766 originate_status[i].caller_profile = switch_channel_get_caller_profile(originate_status[i].peer_channel);
2767 originate_status[i].peer_session = new_session;
2768
2769 switch_channel_set_flag(originate_status[i].peer_channel, CF_ORIGINATING)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_ORIGINATING, 1);
2770
2771 if (caller_channel) {
2772 switch_channel_set_variable(originate_status[i].peer_channel, "call_uuid", switch_channel_get_variable(caller_channel, "call_uuid"))switch_channel_set_variable_var_check(originate_status[i].peer_channel
, "call_uuid", switch_channel_get_variable_dup(caller_channel
, "call_uuid", SWITCH_TRUE, -1), SWITCH_TRUE);
2773 }
2774
2775
2776 if (local_var_event) {
2777 const char *device_id = switch_event_get_header(local_var_event, "device_id")switch_event_get_header_idx(local_var_event, "device_id", -1);
2778 switch_channel_set_profile_var(originate_status[i].peer_channel, "device_id", device_id);
2779 }
2780
2781 if ((lc = switch_event_get_header(var_event, "local_var_clobber")switch_event_get_header_idx(var_event, "local_var_clobber", -
1))) {
2782 local_clobber = switch_true(lc);
2783 }
2784
2785 if (switch_channel_test_flag(originate_status[i].peer_channel, CF_NO_PRESENCE)) {
2786 if (var_event) {
2787 switch_event_del_header(var_event, "presence_id")switch_event_del_header_val(var_event, "presence_id", ((void*
)0));
2788 }
2789 if (local_var_event) {
2790 switch_event_del_header(local_var_event, "presence_id")switch_event_del_header_val(local_var_event, "presence_id", (
(void*)0));
2791 }
2792 }
2793
2794
2795 if (local_clobber) {
2796 if (var_event) {
2797 switch_event_header_t *header;
2798 /* install the vars from the {} params */
2799 for (header = var_event->headers; header; header = header->next) {
2800 switch_channel_set_variable_var_check(originate_status[i].peer_channel, header->name, header->value, oglobals.check_vars);
2801 }
2802 }
2803 }
2804
2805 /* copy local originate vars to the channel */
2806 if (local_var_event) {
2807 switch_event_header_t *header;
2808 for (header = local_var_event->headers; header; header = header->next) {
2809 switch_channel_set_variable_var_check(originate_status[i].peer_channel, header->name, header->value, oglobals.check_vars);
2810 }
2811 switch_event_destroy(&local_var_event);
2812 }
2813
2814 if (!local_clobber) {
2815 if (var_event) {
2816 switch_event_header_t *header;
2817 /* install the vars from the {} params */
2818 for (header = var_event->headers; header; header = header->next) {
2819 switch_channel_set_variable_var_check(originate_status[i].peer_channel, header->name, header->value, oglobals.check_vars);
2820 }
2821 }
2822 }
2823
2824 if (originate_status[i].peer_channel) {
2825 const char *vvar;
2826
2827 if (switch_true(switch_channel_get_variable(originate_status[i].peer_channel, "leg_required")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "leg_required", SWITCH_TRUE, -1))) {
2828 originate_status[i].tagged = 1;
2829 }
2830
2831 if ((vvar = switch_channel_get_variable(originate_status[i].peer_channel, "origination_channel_name")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "origination_channel_name", SWITCH_TRUE, -1))) {
2832 switch_channel_set_name(originate_status[i].peer_channel, vvar);
2833 }
2834
2835 if ((vvar = switch_channel_get_variable(originate_status[i].peer_channel, "origination_callee_id_name")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "origination_callee_id_name", SWITCH_TRUE, -1))) {
2836 switch_channel_set_profile_var(originate_status[i].peer_channel, "callee_id_name", vvar);
2837 }
2838
2839 if ((vvar = switch_channel_get_variable(originate_status[i].peer_channel, "origination_callee_id_number")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "origination_callee_id_number", SWITCH_TRUE, -1))) {
2840 switch_channel_set_profile_var(originate_status[i].peer_channel, "callee_id_number", vvar);
2841 }
2842
2843 if ((vvar = switch_channel_get_variable(originate_status[i].peer_channel, "leg_timeout")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "leg_timeout", SWITCH_TRUE, -1))) {
2844 int val = atoi(vvar);
2845
2846 if (val > 0) {
2847 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2847, (const char*)(session), SWITCH_LOG_DEBUG, "%s Setting leg timeout to %d\n",
2848 switch_channel_get_name(originate_status[i].peer_channel), val);
2849 originate_status[i].per_channel_timelimit_sec = (uint32_t) val;
2850 }
2851 }
2852
2853 if ((vvar = switch_channel_get_variable(originate_status[i].peer_channel, "leg_progress_timeout")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "leg_progress_timeout", SWITCH_TRUE, -1))) {
2854 int val = atoi(vvar);
2855 if (val > 0) {
2856 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2856, (const char*)(session), SWITCH_LOG_DEBUG, "%s Setting leg progress timeout to %d\n",
2857 switch_channel_get_name(originate_status[i].peer_channel), val);
2858 originate_status[i].per_channel_progress_timelimit_sec = (uint32_t) val;
2859 }
2860 }
2861
2862 if ((vvar = switch_channel_get_variable(originate_status[i].peer_channel, "leg_delay_start")switch_channel_get_variable_dup(originate_status[i].peer_channel
, "leg_delay_start", SWITCH_TRUE, -1))) {
2863 int val = atoi(vvar);
2864 if (val > 0) {
2865 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 2865, (const char*)(session), SWITCH_LOG_DEBUG, "%s Setting leg delay start to %d\n",
2866 switch_channel_get_name(originate_status[i].peer_channel), val);
2867 originate_status[i].per_channel_delay_start = (uint32_t) val;
2868
2869 if (originate_status[i].per_channel_progress_timelimit_sec != 0) {
2870 originate_status[i].per_channel_progress_timelimit_sec += originate_status[i].per_channel_delay_start;
2871 }
2872
2873 if (originate_status[i].per_channel_timelimit_sec != 0) {
2874 originate_status[i].per_channel_timelimit_sec += originate_status[i].per_channel_delay_start;
2875 }
2876 }
2877 }
2878
2879 if (!zstr(ent_aleg_uuid)_zstr(ent_aleg_uuid)) {
2880 l_session = switch_core_session_locate(ent_aleg_uuid)switch_core_session_perform_locate(ent_aleg_uuid, "src/switch_ivr_originate.c"
, (const char *)__func__, 2880);
2881 a_session = l_session;
2882 }
2883
2884 if (a_session) {
2885 switch_channel_t *channel = switch_core_session_get_channel(a_session);
2886 char *val =
2887 switch_core_session_sprintf(a_session, "%s;%s;%s",
2888 switch_core_session_get_uuid(originate_status[i].peer_session),
2889 switch_str_nil(switch_channel_get_variable(originate_status[i].peer_channel, "callee_id_name"))(switch_channel_get_variable_dup(originate_status[i].peer_channel
, "callee_id_name", SWITCH_TRUE, -1) ? switch_channel_get_variable_dup
(originate_status[i].peer_channel, "callee_id_name", SWITCH_TRUE
, -1) : ""),
2890 switch_str_nil(switch_channel_get_variable(originate_status[i].peer_channel, "callee_id_number"))(switch_channel_get_variable_dup(originate_status[i].peer_channel
, "callee_id_number", SWITCH_TRUE, -1) ? switch_channel_get_variable_dup
(originate_status[i].peer_channel, "callee_id_number", SWITCH_TRUE
, -1) : ""));
2891
2892
2893 switch_channel_set_variable(originate_status[i].peer_channel, "originating_leg_uuid", switch_core_session_get_uuid(a_session))switch_channel_set_variable_var_check(originate_status[i].peer_channel
, "originating_leg_uuid", switch_core_session_get_uuid(a_session
), SWITCH_TRUE);
2894
2895 switch_channel_add_variable_var_check(channel, "originated_legs", val, SWITCH_FALSE, SWITCH_STACK_PUSH);
2896
2897 }
2898
2899 if (l_session) {
2900 switch_core_session_rwunlock(l_session);
2901 l_session = NULL((void*)0);
2902 }
2903
2904 switch_channel_execute_on(originate_status[i].peer_channel, SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE"execute_on_originate");
2905 switch_channel_api_on(originate_status[i].peer_channel, SWITCH_CHANNEL_API_ON_ORIGINATE_VARIABLE"api_on_originate");
2906 }
2907
2908 if (table) {
2909 switch_channel_add_state_handler(originate_status[i].peer_channel, table);
2910 }
2911
2912 if (oglobals.monitor_early_media_ring || oglobals.monitor_early_media_fail || oglobals.ignore_early_media == 4) {
2913 switch_channel_set_flag(originate_status[i].peer_channel, CF_CONSUME_ON_ORIGINATE)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_CONSUME_ON_ORIGINATE, 1);
2914 }
2915
2916 switch_channel_add_state_handler(originate_status[i].peer_channel, &originate_state_handlers);
2917
2918 if ((flags & SOF_NOBLOCK) && originate_status[i].peer_session) {
2919 status = SWITCH_STATUS_SUCCESS;
2920 *bleg = originate_status[i].peer_session;
2921 *cause = SWITCH_CAUSE_SUCCESS;
2922 goto outer_for;
2923 }
2924
2925 if (!switch_core_session_running(originate_status[i].peer_session)) {
2926 if (originate_status[i].per_channel_delay_start) {
2927 switch_channel_set_flag(originate_status[i].peer_channel, CF_BLOCK_STATE)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_BLOCK_STATE, 1);
2928 }
2929 switch_core_session_thread_launch(originate_status[i].peer_session);
2930 }
2931 }
2932
2933 switch_epoch_time_now(&start);
2934
2935 for (;;) {
2936 uint32_t valid_channels = 0;
2937 for (i = 0; i < and_argc; i++) {
2938 int state;
2939 time_t elapsed;
2940
2941 if (!originate_status[i].peer_channel) {
2942 continue;
2943 }
2944
2945 state = switch_channel_get_state(originate_status[i].peer_channel);
2946
2947 if (state < CS_HANGUP) {
2948 valid_channels++;
2949 } else {
2950 continue;
2951 }
2952
2953 if (state >= CS_ROUTING) {
2954 goto endfor1;
2955 }
2956
2957 if (caller_channel && !switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
2958 goto notready;
2959 }
2960
2961 elapsed = switch_epoch_time_now(NULL((void*)0)) - start;
2962
2963 if (elapsed > (time_t) timelimit_sec) {
2964 to++;
2965 oglobals.idx = IDX_TIMEOUT;
2966 goto notready;
2967 }
2968
2969 if (!oglobals.sent_ring && !oglobals.ignore_ring_ready &&
2970 !oglobals.progress && (progress_timelimit_sec && elapsed > (time_t) progress_timelimit_sec)) {
2971 to++;
2972 oglobals.idx = IDX_TIMEOUT;
2973 if (force_reason == SWITCH_CAUSE_NONE) {
2974 force_reason = SWITCH_CAUSE_PROGRESS_TIMEOUT;
2975 }
2976 goto notready;
2977 }
2978
2979 switch_cond_next();
2980 }
2981
2982 check_per_channel_timeouts(&oglobals, originate_status, and_argc, start, &force_reason);
2983
2984
2985 if (valid_channels == 0) {
2986 status = SWITCH_STATUS_GENERR;
2987 goto done;
2988 }
2989
2990 }
2991
2992 endfor1:
2993
2994 if (caller_channel) {
2995 if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) ||
2996 switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA) || switch_channel_test_flag(caller_channel, CF_DISABLE_RINGBACK)) {
2997 ringback_data = NULL((void*)0);
2998 }
2999 }
3000
3001
3002#if 0
3003 /* changing behaviour ignore_early_media=true must also be explicitly set for previous behaviour */
3004 if (ringback_data) {
3005 oglobals.early_ok = 0;
3006 }
3007#endif
3008
3009 if (ringback_data) {
3010 oglobals.sending_ringback = 1;
3011 } else {
3012 oglobals.ringback_ok = 0;
3013 }
3014
3015 if (caller_channel) {
3016 soft_holding = switch_channel_get_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE)switch_channel_get_variable_dup(caller_channel, "soft_holding_uuid"
, SWITCH_TRUE, -1);
3017 }
3018
3019 while ((!caller_channel || switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
) || switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) &&
3020 check_channel_status(&oglobals, originate_status, and_argc, &force_reason)) {
3021 time_t elapsed = switch_epoch_time_now(NULL((void*)0)) - start;
3022
3023 read_packet = 0;
3024
3025 if (cancel_cause && *cancel_cause > 0) {
3026 if (force_reason == SWITCH_CAUSE_NONE) {
3027 force_reason = *cancel_cause;
3028 }
3029 oglobals.idx = IDX_CANCEL;
3030 goto notready;
3031 }
3032
3033 check_per_channel_timeouts(&oglobals, originate_status, and_argc, start, &force_reason);
3034
3035 if (oglobals.session) {
3036 switch_ivr_parse_all_events(oglobals.session);
3037 }
3038
3039 if (!oglobals.sent_ring && !oglobals.progress && (progress_timelimit_sec && elapsed > (time_t) progress_timelimit_sec)) {
3040 oglobals.idx = IDX_TIMEOUT;
3041 if (force_reason == SWITCH_CAUSE_NONE) {
3042 force_reason = SWITCH_CAUSE_PROGRESS_TIMEOUT;
3043 }
3044 goto notready;
3045 }
3046
3047 if ((to = (uint8_t) (elapsed >= (time_t) timelimit_sec)) || (fail_on_single_reject && oglobals.hups)) {
3048 int ok = 0;
3049
3050 if (fail_on_single_reject_var) {
3051 if (!switch_true(fail_on_single_reject_var)) {
3052 ok = 1;
3053
3054 for (i = 0; i < and_argc; i++) {
3055 switch_channel_t *pchannel;
3056 const char *cause_str;
3057
3058 if (!originate_status[i].peer_session) {
3059 continue;
3060 }
3061 pchannel = switch_core_session_get_channel(originate_status[i].peer_session);
3062
3063 if (switch_channel_down_nosig(pchannel)(switch_channel_get_state(pchannel) >= CS_HANGUP)) {
3064 int neg, pos;
3065 cause_str = switch_channel_cause2str(switch_channel_get_cause(pchannel));
3066 neg = *fail_on_single_reject_var == '!';
3067 pos = !!switch_stristr(cause_str, fail_on_single_reject_var);
3068
3069 if (neg) {
3070 pos = !pos;
3071 }
3072
3073 if (pos) {
3074 ok = 0;
3075 break;
3076 }
3077 }
3078 }
3079 }
3080 }
3081 if (!ok) {
3082 oglobals.idx = IDX_TIMEOUT;
3083 goto notready;
3084 }
3085 }
3086
3087 /* read from the channel while we wait if the audio is up on it */
3088 if (oglobals.session &&
3089 !switch_channel_test_flag(caller_channel, CF_PROXY_MODE) &&
3090 !switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA) &&
3091 !switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE) &&
3092 (oglobals.ringback_ok
3093 || (switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)))) {
3094
3095 switch_status_t tstatus = SWITCH_STATUS_SUCCESS;
3096 int silence = 0;
3097
3098 if (caller_channel && cancel_key) {
3099 if (switch_channel_has_dtmf(caller_channel)) {
3100 switch_dtmf_t dtmf = { 0, 0 };
3101 if (switch_channel_dequeue_dtmf(caller_channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
3102 if (dtmf.digit == *cancel_key) {
3103 oglobals.idx = IDX_KEY_CANCEL;
3104 goto notready;
3105 }
3106 }
3107 }
3108 }
3109
3110 if (switch_channel_media_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_TRUE
)) {
3111 tstatus = switch_core_session_read_frame(oglobals.session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
3112 if (!SWITCH_READ_ACCEPTABLE(tstatus)(tstatus == SWITCH_STATUS_SUCCESS || tstatus == SWITCH_STATUS_BREAK
|| tstatus == SWITCH_STATUS_INUSE)) {
3113 if (soft_holding) {
3114 switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE)switch_channel_set_flag_value(caller_channel, CF_XFER_ZOMBIE,
1);
3115 }
3116
3117 if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
3118 goto do_continue;
3119 }
3120 break;
3121 }
3122
3123 read_packet++;
3124 } else {
3125 read_frame = NULL((void*)0);
3126 }
3127
3128
3129 if (oglobals.ringback_ok && (oglobals.ring_ready || oglobals.instant_ringback ||
3130 oglobals.sending_ringback > 1 || oglobals.bridge_early_media > -1)) {
3131 if (oglobals.ringback_ok == 1) {
3132 switch_status_t rst;
3133
3134 rst = setup_ringback(&oglobals, originate_status, and_argc, ringback_data, &ringback, &write_frame, &write_codec);
3135
3136 if (oglobals.bridge_early_media > -1) {
3137 switch_threadattr_t *thd_attr = NULL((void*)0);
3138 switch_threadattr_create(&thd_attr, switch_core_session_get_pool(session));
3139 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE240 * 1024);
3140 early_state.oglobals = &oglobals;
3141 early_state.originate_status = originate_status;
3142 early_state.ready = 1;
3143 early_state.ringback = &ringback;
3144 early_state.ttl = and_argc;
3145 switch_mutex_init(&early_state.mutex, SWITCH_MUTEX_NESTED0x1, switch_core_session_get_pool(session));
3146 switch_buffer_create_dynamic(&early_state.buffer, 1024, 1024, 0);
3147 switch_thread_create(&oglobals.ethread, thd_attr, early_thread_run, &early_state, switch_core_session_get_pool(session));
3148 }
3149
3150
3151 switch (rst) {
3152 case SWITCH_STATUS_SUCCESS:
3153 oglobals.ringback_ok++;
3154 break;
3155 case SWITCH_STATUS_FALSE:
3156 goto notready;
3157 break;
3158 case SWITCH_STATUS_BREAK:
3159 status = SWITCH_STATUS_FALSE;
3160 goto done;
3161 break;
3162 default:
3163 ringback_data = NULL((void*)0);
3164 oglobals.ringback_ok = 0;
3165 oglobals.sending_ringback = 0;
3166 break;
3167 }
3168
3169 goto do_continue;
3170 }
3171
3172 if (oglobals.bridge_early_media > -1) {
3173 write_frame.datalen = 0;
3174 switch_mutex_lock(early_state.mutex);
3175 if (ringback.asis) {
3176 uint16_t mlen;
3177 switch_size_t buflen = switch_buffer_inuse(early_state.buffer);
3178 if (buflen > sizeof(uint16_t)) {
3179 switch_buffer_peek(early_state.buffer, &mlen, sizeof(uint16_t));
3180 if (buflen >= (mlen + sizeof(uint16_t))) {
3181 switch_buffer_toss(early_state.buffer, sizeof(uint16_t));
3182 write_frame.datalen = (uint32_t)switch_buffer_read(early_state.buffer, write_frame.data, mlen);
3183 }
3184 }
3185 } else {
3186 if (switch_buffer_inuse(early_state.buffer) >= write_frame.codec->implementation->decoded_bytes_per_packet) {
3187 write_frame.datalen = (uint32_t)switch_buffer_read(early_state.buffer, write_frame.data,
3188 write_frame.codec->implementation->decoded_bytes_per_packet);
3189 }
3190 }
3191 switch_mutex_unlock(early_state.mutex);
3192 } else if (ringback.fh) {
3193 switch_size_t mlen, olen;
3194 unsigned int pos = 0;
3195
3196 if (ringback.asis) {
3197 mlen = write_frame.codec->implementation->encoded_bytes_per_packet;
3198 } else {
3199 mlen = write_frame.codec->implementation->samples_per_packet;
3200 }
3201
3202 olen = mlen;
3203
3204 //if (ringback.fh->resampler && ringback.fh->resampler->rfactor > 1) {
3205 //olen = (switch_size_t) (olen * ringback.fh->resampler->rfactor);
3206 //}
3207
3208 switch_core_file_read(ringback.fh, write_frame.data, &olen);
3209
3210 if (olen == 0) {
3211 olen = mlen;
3212 ringback.fh->speed = 0;
3213 switch_core_file_seek(ringback.fh, &pos, 0, SEEK_SET0);
3214 switch_core_file_read(ringback.fh, write_frame.data, &olen);
3215 if (olen == 0) {
3216 break;
3217 }
3218 }
3219 write_frame.datalen = (uint32_t) (ringback.asis ? olen : olen * 2 * ringback.fh->channels);
3220 write_frame.samples = (uint32_t) olen;
3221
3222 } else if (ringback.audio_buffer) {
3223 if ((write_frame.datalen = (uint32_t) switch_buffer_read_loop(ringback.audio_buffer,
3224 write_frame.data,
3225 write_frame.codec->implementation->decoded_bytes_per_packet)) <=
3226 0) {
3227
3228 if (soft_holding) {
3229 switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE)switch_channel_set_flag_value(caller_channel, CF_XFER_ZOMBIE,
1);
3230 goto do_continue;
3231 }
3232
3233 break;
3234 }
3235 } else if (ringback.silence) {
3236 silence = ringback.silence;
3237 }
3238 } else {
3239 silence = 600;
3240 }
3241
3242 if ((ringback.fh || silence || ringback.audio_buffer || oglobals.bridge_early_media > -1) && write_frame.codec && write_frame.codec->implementation && write_frame.datalen) {
3243 if (silence) {
3244 write_frame.datalen = read_impl.decoded_bytes_per_packet;
3245 switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.datalen / 2, write_frame.codec->implementation->number_of_channels, silence);
3246 }
3247
3248 if (switch_core_session_write_frame(oglobals.session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
3249 if (soft_holding) {
3250 switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE)switch_channel_set_flag_value(caller_channel, CF_XFER_ZOMBIE,
1);
3251 }
3252 if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
3253 goto do_continue;
3254 }
3255 break;
3256 }
3257 }
3258
3259 }
3260
3261 do_continue:
3262
3263 if (!read_packet) {
3264 switch_yield(20000)switch_sleep(20000);;
3265 }
3266 }
3267
3268 notready:
3269
3270 if (caller_channel) {
3271 holding = switch_channel_get_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE)switch_channel_get_variable_dup(caller_channel, "holding_uuid"
, SWITCH_TRUE, -1);
3272 switch_channel_set_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "holding_uuid"
, ((void*)0), SWITCH_TRUE);
3273
3274 if (soft_holding && switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
3275 holding = soft_holding;
3276 soft_holding = NULL((void*)0);
3277 switch_channel_set_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "soft_holding_uuid"
, ((void*)0), SWITCH_TRUE);
3278 }
3279 }
3280
3281 if (caller_channel && !switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
) && !switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
3282 oglobals.idx = IDX_CANCEL;
3283 }
3284
3285 if (oglobals.session && (ringback_data || !(switch_channel_test_flag(caller_channel, CF_PROXY_MODE) ||
3286 switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)))) {
3287 switch_core_session_reset(oglobals.session, SWITCH_FALSE, SWITCH_TRUE);
3288 }
3289
3290 if (holding) {
3291 if (oglobals.idx > IDX_NADA) {
3292 peer_session = originate_status[oglobals.idx].peer_session;
3293 peer_channel = originate_status[oglobals.idx].peer_channel;
3294 originate_status[oglobals.idx].peer_channel = NULL((void*)0);
3295 } else if (and_argc == 1) {
3296 peer_session = originate_status[0].peer_session;
3297 peer_channel = originate_status[0].peer_channel;
3298 originate_status[0].peer_channel = NULL((void*)0);
3299 } else {
3300 for (i = 0; i < and_argc; i++) {
3301 if (!peer_eligible(originate_status[i].peer_channel)(originate_status[i].peer_channel && !(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)))) {
3302 continue;
3303 }
3304 if (switch_channel_media_ready(originate_status[i].peer_channel)switch_channel_test_ready(originate_status[i].peer_channel, SWITCH_TRUE
, SWITCH_TRUE)) {
3305 peer_session = originate_status[i].peer_session;
3306 peer_channel = originate_status[i].peer_channel;
3307 originate_status[i].peer_channel = NULL((void*)0);
3308 goto end_search;
3309 }
3310 }
3311 for (i = 0; i < and_argc; i++) {
3312 if (!peer_eligible(originate_status[i].peer_channel)(originate_status[i].peer_channel && !(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)))) {
3313 continue;
3314 }
3315 if (switch_channel_up_nosig(originate_status[i].peer_channel)(switch_channel_get_state(originate_status[i].peer_channel) <
CS_HANGUP)) {
3316 peer_session = originate_status[i].peer_session;
3317 peer_channel = originate_status[i].peer_channel;
3318 originate_status[i].peer_channel = NULL((void*)0);
3319 break;
3320 }
3321 }
3322 }
3323
3324 end_search:
3325
3326 if (peer_channel && switch_channel_down_nosig(peer_channel)(switch_channel_get_state(peer_channel) >= CS_HANGUP)) {
3327 switch_core_session_rwunlock(peer_session);
3328 peer_session = NULL((void*)0);
3329 peer_channel = NULL((void*)0);
3330
3331 }
3332
3333 if (oglobals.idx == IDX_TIMEOUT || to || oglobals.idx == IDX_KEY_CANCEL || oglobals.idx == IDX_CANCEL ||
3334 (!peer_session && oglobals.idx == IDX_NADA)) {
3335 const char *dest = NULL((void*)0);
3336 const char *context = NULL((void*)0);
3337 const char *dialplan = NULL((void*)0);
3338 switch_core_session_t *holding_session;
3339
3340 if (caller_channel) {
3341 if (zstr(context)_zstr(context)) {
3342 context = switch_channel_get_variable(caller_channel, "context")switch_channel_get_variable_dup(caller_channel, "context", SWITCH_TRUE
, -1);
3343 }
3344 if (zstr(dialplan)_zstr(dialplan)) {
3345 dialplan = switch_channel_get_variable(caller_channel, "dialplan")switch_channel_get_variable_dup(caller_channel, "dialplan", SWITCH_TRUE
, -1);
3346 }
3347 }
3348
3349 if (zstr(context)_zstr(context)) {
3350 context = "default";
3351 }
3352
3353 if (zstr(context)_zstr(context)) {
3354 dialplan = "XML";
3355 }
3356
3357 if ((holding_session = switch_core_session_locate(holding)switch_core_session_perform_locate(holding, "src/switch_ivr_originate.c"
, (const char *)__func__, 3357))) {
3358 switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);
3359 switch_status_t mstatus = SWITCH_STATUS_FALSE;
3360
3361 if (caller_channel) {
3362 if ((mstatus = switch_channel_caller_extension_masquerade(caller_channel, holding_channel, 0)) == SWITCH_STATUS_SUCCESS) {
3363 switch_channel_restart(holding_channel);
3364 }
3365 }
3366
3367 if (mstatus != SWITCH_STATUS_SUCCESS) {
3368 if (peer_channel) {
3369 dest = switch_channel_get_variable(peer_channel, "destination_number")switch_channel_get_variable_dup(peer_channel, "destination_number"
, SWITCH_TRUE, -1);
3370 context = switch_channel_get_variable(peer_channel, "context")switch_channel_get_variable_dup(peer_channel, "context", SWITCH_TRUE
, -1);
3371 dialplan = switch_channel_get_variable(peer_channel, "dialplan")switch_channel_get_variable_dup(peer_channel, "dialplan", SWITCH_TRUE
, -1);
3372 } else if (caller_channel) {
3373 dest = switch_channel_get_variable(caller_channel, "destination_number")switch_channel_get_variable_dup(caller_channel, "destination_number"
, SWITCH_TRUE, -1);
3374 }
3375 if (dest) {
3376 switch_ivr_session_transfer(holding_session, dest, dialplan, context);
3377 }
3378 }
3379
3380 switch_core_session_rwunlock(holding_session);
3381 holding = NULL((void*)0);
3382 holding_session = NULL((void*)0);
3383 }
3384
3385 if (peer_channel) {
3386 switch_channel_hangup(peer_channel, SWITCH_CAUSE_ATTENDED_TRANSFER)switch_channel_perform_hangup(peer_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3386, SWITCH_CAUSE_ATTENDED_TRANSFER
);
3387 switch_core_session_rwunlock(peer_session);
3388 }
3389 if (force_reason == SWITCH_CAUSE_NONE) {
3390 force_reason = SWITCH_CAUSE_ATTENDED_TRANSFER;
3391 }
3392 } else if (zstr(soft_holding)_zstr(soft_holding)) {
3393
3394 if (peer_channel && switch_channel_ready(peer_channel)switch_channel_test_ready(peer_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
3395 switch_core_session_t *holding_session;
3396
3397 if (force_reason == SWITCH_CAUSE_NONE) {
3398 force_reason = SWITCH_CAUSE_ATTENDED_TRANSFER;
3399 }
3400
3401 if ((holding_session = switch_core_session_locate(holding)switch_core_session_perform_locate(holding, "src/switch_ivr_originate.c"
, (const char *)__func__, 3401))) {
3402 switch_channel_set_variable(switch_core_session_get_channel(holding_session), SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true")switch_channel_set_variable_var_check(switch_core_session_get_channel
(holding_session), "hangup_after_bridge", "true", SWITCH_TRUE
);
3403 switch_core_session_rwunlock(holding_session);
3404 }
3405 switch_channel_set_flag(peer_channel, CF_LAZY_ATTENDED_TRANSFER)switch_channel_set_flag_value(peer_channel, CF_LAZY_ATTENDED_TRANSFER
, 1);
3406 switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(peer_session));
3407 holding = NULL((void*)0);
3408 oglobals.idx = IDX_XFER;
3409 if (caller_channel && switch_channel_up_nosig(caller_channel)(switch_channel_get_state(caller_channel) < CS_HANGUP) && !switch_channel_test_flag(caller_channel, CF_INTERCEPTED)) {
3410 switch_channel_hangup(caller_channel, SWITCH_CAUSE_ATTENDED_TRANSFER)switch_channel_perform_hangup(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3410, SWITCH_CAUSE_ATTENDED_TRANSFER
);
3411 }
3412 caller_channel = NULL((void*)0);
3413 oglobals.session = NULL((void*)0);
3414 session = NULL((void*)0);
3415 switch_core_session_rwunlock(peer_session);
3416 } else {
3417 switch_core_session_t *holding_session;
3418
3419 if ((holding_session = switch_core_session_locate(holding)switch_core_session_perform_locate(holding, "src/switch_ivr_originate.c"
, (const char *)__func__, 3419))) {
3420 switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);
3421
3422 if (caller_channel && switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
3423 switch_channel_set_variable(holding_channel, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true")switch_channel_set_variable_var_check(holding_channel, "hangup_after_bridge"
, "true", SWITCH_TRUE);
3424 switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(session));
3425 holding = NULL((void*)0);
3426 } else {
3427 switch_channel_hangup(holding_channel, SWITCH_CAUSE_NORMAL_UNSPECIFIED)switch_channel_perform_hangup(holding_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3427, SWITCH_CAUSE_NORMAL_UNSPECIFIED
);
3428 }
3429 switch_core_session_rwunlock(holding_session);
3430 }
3431 }
3432 }
3433
3434 peer_session = NULL((void*)0);
3435 peer_channel = NULL((void*)0);
3436 }
3437
3438 for (i = 0; i < and_argc; i++) {
3439 if (!peer_eligible(originate_status[i].peer_channel)(originate_status[i].peer_channel && !(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)))) {
3440 continue;
3441 }
3442
3443 if (i != oglobals.idx) {
3444 holding = NULL((void*)0);
3445
3446 if (oglobals.idx == IDX_TIMEOUT || to) {
3447 reason = SWITCH_CAUSE_NO_ANSWER;
3448 } else {
3449 if (oglobals.idx == IDX_CANCEL) {
3450 reason = SWITCH_CAUSE_ORIGINATOR_CANCEL;
3451 } else {
3452 if (and_argc > 1) {
3453 reason = SWITCH_CAUSE_LOSE_RACE;
3454 } else if (!switch_channel_ready(originate_status[i].peer_channel)switch_channel_test_ready(originate_status[i].peer_channel, SWITCH_TRUE
, SWITCH_FALSE)) {
3455 wait_for_cause(originate_status[i].peer_channel);
3456 if (switch_channel_down_nosig(originate_status[i].peer_channel)(switch_channel_get_state(originate_status[i].peer_channel) >=
CS_HANGUP)) {
3457 reason = switch_channel_get_cause(originate_status[i].peer_channel);
3458 }
3459 } else {
3460 reason = SWITCH_CAUSE_NO_ANSWER;
3461 }
3462 }
3463 }
3464 if (switch_channel_up_nosig(originate_status[i].peer_channel)(switch_channel_get_state(originate_status[i].peer_channel) <
CS_HANGUP)) {
3465 if (caller_channel && i == 0) {
3466 holding = switch_channel_get_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE)switch_channel_get_variable_dup(caller_channel, "soft_holding_uuid"
, SWITCH_TRUE, -1);
3467 switch_channel_set_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "soft_holding_uuid"
, ((void*)0), SWITCH_TRUE);
3468 }
3469
3470 if (holding && oglobals.idx != IDX_TIMEOUT && oglobals.idx != IDX_KEY_CANCEL && oglobals.idx < 0) {
3471 switch_core_session_t *holding_session;
3472
3473 if ((holding_session = switch_core_session_locate(holding)switch_core_session_perform_locate(holding, "src/switch_ivr_originate.c"
, (const char *)__func__, 3473))) {
3474 switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);
3475
3476 switch_channel_set_variable(holding_channel, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true")switch_channel_set_variable_var_check(holding_channel, "hangup_after_bridge"
, "true", SWITCH_TRUE);
3477
3478 if (caller_channel && switch_true(switch_channel_get_variable(caller_channel, "recording_follow_transfer")switch_channel_get_variable_dup(caller_channel, "recording_follow_transfer"
, SWITCH_TRUE, -1))) {
3479 switch_core_media_bug_transfer_recordings(session, originate_status[i].peer_session);
3480 }
3481
3482 if (switch_true(switch_channel_get_variable(holding_channel, "recording_follow_transfer")switch_channel_get_variable_dup(holding_channel, "recording_follow_transfer"
, SWITCH_TRUE, -1))) {
3483 switch_core_media_bug_transfer_recordings(holding_session, originate_status[i].peer_session);
3484 }
3485
3486 switch_core_session_rwunlock(holding_session);
3487 }
3488 switch_channel_set_flag(originate_status[i].peer_channel, CF_LAZY_ATTENDED_TRANSFER)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_LAZY_ATTENDED_TRANSFER, 1);
3489 switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(originate_status[i].peer_session));
3490 holding = NULL((void*)0);
3491 } else {
3492 if (force_reason == SWITCH_CAUSE_LOSE_RACE || reason == SWITCH_CAUSE_LOSE_RACE) {
3493 switch_channel_set_variable(originate_status[i].peer_channel, "group_dial_status", "loser")switch_channel_set_variable_var_check(originate_status[i].peer_channel
, "group_dial_status", "loser", SWITCH_TRUE);
3494 }
3495 switch_channel_hangup(originate_status[i].peer_channel, force_reason ? force_reason : reason)switch_channel_perform_hangup(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 3495,
force_reason ? force_reason : reason);
3496 }
3497 }
3498 }
3499 }
3500
3501
3502
3503 if (oglobals.idx > IDX_NADA) {
3504 if ((peer_session = originate_status[oglobals.idx].peer_session)) {
3505 peer_channel = switch_core_session_get_channel(originate_status[oglobals.idx].peer_session);
3506 }
3507 } else {
3508 status = SWITCH_STATUS_FALSE;
3509 if (caller_channel && peer_channel) {
3510 switch_process_import(oglobals.session, peer_channel, "import", NULL((void*)0));
3511 }
3512 peer_channel = NULL((void*)0);
3513 goto done;
3514 }
3515
3516 if (caller_channel) {
3517 if (switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
3518 switch_channel_pass_callee_id(peer_channel, caller_channel);
3519 if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
3520 status = SWITCH_STATUS_SUCCESS;
3521 } else {
3522 status = switch_channel_answer(caller_channel)switch_channel_perform_answer(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3522);
3523 }
3524 } else if (switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) {
3525 if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
3526 status = SWITCH_STATUS_SUCCESS;
3527 } else {
3528 switch_channel_pass_callee_id(peer_channel, caller_channel);
3529 status = switch_channel_pre_answer(caller_channel)switch_channel_perform_pre_answer(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3529);
3530 }
3531 } else {
3532 status = SWITCH_STATUS_SUCCESS;
3533 }
3534
3535 if (status != SWITCH_STATUS_SUCCESS) {
3536 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(peer_channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 3536, (const char*)switch_channel_get_session
(peer_channel), SWITCH_LOG_DEBUG, "%s Media Establishment Failed.\n",
3537 switch_channel_get_name(caller_channel));
3538 switch_channel_hangup(peer_channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION)switch_channel_perform_hangup(peer_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3538, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION
);
3539 }
3540 }
3541
3542 if (switch_channel_test_flag(peer_channel, CF_ANSWERED) ||
3543 (oglobals.early_ok && switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) ||
3544 (oglobals.return_ring_ready && switch_channel_test_flag(peer_channel, CF_RING_READY))
3545 ) {
3546 *bleg = peer_session;
3547
3548 if (oglobals.monitor_early_media_ring || oglobals.monitor_early_media_fail) {
3549 switch_ivr_stop_tone_detect_session(peer_session);
3550 switch_channel_set_private(peer_channel, "_oglobals_", NULL((void*)0));
3551 }
3552
3553 status = SWITCH_STATUS_SUCCESS;
3554 } else {
3555 status = SWITCH_STATUS_FALSE;
3556 }
3557
3558 done:
3559
3560 *cause = SWITCH_CAUSE_NONE;
3561
3562 if (caller_channel && !switch_channel_ready(caller_channel)switch_channel_test_ready(caller_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
3563 status = SWITCH_STATUS_FALSE;
3564 }
3565
3566 if (status == SWITCH_STATUS_SUCCESS) {
3567 if (caller_channel) {
3568 switch_channel_set_variable(caller_channel, "originate_disposition", "call accepted")switch_channel_set_variable_var_check(caller_channel, "originate_disposition"
, "call accepted", SWITCH_TRUE);
3569 if (peer_channel) {
3570 switch_process_import(oglobals.session, peer_channel, "import", NULL((void*)0));
3571
3572 if (switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
3573 switch_channel_set_variable(caller_channel, "DIALSTATUS", "EARLY")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "EARLY", SWITCH_TRUE);
3574 } else {
3575 switch_channel_set_variable(caller_channel, "DIALSTATUS", "ANSWER")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "ANSWER", SWITCH_TRUE);
3576 }
3577
3578 }
3579 }
3580 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 3580, (const char*)(oglobals.session), SWITCH_LOG_DEBUG, "Originate Resulted in Success: [%s]\n",
3581 switch_channel_get_name(peer_channel));
3582 *cause = SWITCH_CAUSE_SUCCESS;
3583
3584 } else {
3585 const char *cdr_var = NULL((void*)0);
3586 const char *json_cdr_var = NULL((void*)0);
3587
3588 switch_xml_t cdr = NULL((void*)0);
3589 cJSON *json_cdr = NULL((void*)0);
3590
3591 char *json_text;
3592 char *xml_text;
3593 char buf[128] = "", buf2[128] = "";
3594
3595 if (caller_channel) {
3596 cdr_var = switch_channel_get_variable(caller_channel, "failed_xml_cdr_prefix")switch_channel_get_variable_dup(caller_channel, "failed_xml_cdr_prefix"
, SWITCH_TRUE, -1);
3597 }
3598
3599 if (caller_channel) {
3600 json_cdr_var = switch_channel_get_variable(caller_channel, "failed_json_cdr_prefix")switch_channel_get_variable_dup(caller_channel, "failed_json_cdr_prefix"
, SWITCH_TRUE, -1);
3601 }
3602
3603 if (peer_channel) {
3604 wait_for_cause(peer_channel);
3605 *cause = switch_channel_get_cause(peer_channel);
3606 } else {
3607 for (i = 0; i < and_argc; i++) {
3608 if (!originate_status[i].peer_channel) {
3609 continue;
3610 }
3611 *cause = switch_channel_get_cause(originate_status[i].peer_channel);
3612 break;
3613 }
3614 }
3615
3616 if (cdr_var) {
3617 for (i = 0; i < and_argc; i++) {
3618 switch_channel_t *channel;
3619
3620 if (!originate_status[i].peer_session) {
3621 continue;
3622 }
3623
3624 channel = switch_core_session_get_channel(originate_status[i].peer_session);
3625
3626 switch_channel_wait_for_state_timeout(channel, CS_REPORTING, 5000);
3627
3628 if (!switch_channel_test_flag(channel, CF_TIMESTAMP_SET)) {
3629 switch_channel_set_timestamps(channel);
3630 }
3631
3632 if (switch_ivr_generate_xml_cdr(originate_status[i].peer_session, &cdr) == SWITCH_STATUS_SUCCESS) {
3633 if ((xml_text = switch_xml_toxml(cdr, SWITCH_FALSE))) {
3634 switch_snprintf(buf, sizeof(buf), "%s_%d", cdr_var, ++cdr_total);
3635 switch_channel_set_variable(caller_channel, buf, xml_text)switch_channel_set_variable_var_check(caller_channel, buf, xml_text
, SWITCH_TRUE);
3636 switch_safe_free(xml_text)if (xml_text) {free(xml_text);xml_text=((void*)0);};
3637 }
3638 switch_xml_free(cdr);
3639 cdr = NULL((void*)0);
3640 }
3641
3642 }
3643 switch_snprintf(buf, sizeof(buf), "%s_total", cdr_var);
3644 switch_snprintf(buf2, sizeof(buf2), "%d", cdr_total ? cdr_total : 0);
3645 switch_channel_set_variable(caller_channel, buf, buf2)switch_channel_set_variable_var_check(caller_channel, buf, buf2
, SWITCH_TRUE);
3646 }
3647
3648 if (json_cdr_var) {
3649 for (i = 0; i < and_argc; i++) {
3650 switch_channel_t *channel;
3651
3652 if (!originate_status[i].peer_session) {
3653 continue;
3654 }
3655
3656 channel = switch_core_session_get_channel(originate_status[i].peer_session);
3657
3658 switch_channel_wait_for_state_timeout(channel, CS_REPORTING, 5000);
3659
3660 if (!switch_channel_test_flag(channel, CF_TIMESTAMP_SET)) {
3661 switch_channel_set_timestamps(channel);
3662 }
3663
3664 if (switch_ivr_generate_json_cdr(originate_status[i].peer_session, &json_cdr, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
3665 json_text = cJSON_PrintUnformatted(json_cdr);
3666 switch_snprintf(buf, sizeof(buf), "%s_%d", json_cdr_var, ++cdr_total);
3667 switch_channel_set_variable(caller_channel, buf, json_text)switch_channel_set_variable_var_check(caller_channel, buf, json_text
, SWITCH_TRUE);
3668 // switch_safe_free(json_text);
3669 cJSON_Delete(json_cdr);
3670 json_cdr = NULL((void*)0);
3671 }
3672
3673 }
3674 switch_snprintf(buf, sizeof(buf), "%s_total", json_cdr_var);
3675 switch_snprintf(buf2, sizeof(buf2), "%d", cdr_total ? cdr_total : 0);
3676 switch_channel_set_variable(caller_channel, buf, buf2)switch_channel_set_variable_var_check(caller_channel, buf, buf2
, SWITCH_TRUE);
3677 }
3678
3679 if (caller_channel && switch_channel_test_flag(caller_channel, CF_INTERCEPTED)) {
3680 *cause = SWITCH_CAUSE_PICKED_OFF;
3681 }
3682
3683 if (!*cause) {
3684 if (reason) {
3685 *cause = reason;
3686 } else if (caller_channel) {
3687 *cause = switch_channel_get_cause(caller_channel);
3688 } else {
3689 *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
3690 for (i = 0; i < and_argc; i++) {
3691 if (!peer_eligible(originate_status[i].peer_channel)(originate_status[i].peer_channel && !(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)))) {
3692 continue;
3693 }
3694
3695 wait_for_cause(originate_status[i].peer_channel);
3696
3697 if (switch_channel_down_nosig(originate_status[i].peer_channel)(switch_channel_get_state(originate_status[i].peer_channel) >=
CS_HANGUP)) {
3698 *cause = switch_channel_get_cause(originate_status[i].peer_channel);
3699 break;
3700 }
3701
3702 }
3703 }
3704 }
3705
3706 if (*cause == SWITCH_CAUSE_SUCCESS || *cause == SWITCH_CAUSE_NONE) {
3707 *cause = SWITCH_CAUSE_ORIGINATOR_CANCEL;
3708 }
3709
3710 if (oglobals.idx == IDX_CANCEL) {
3711 *cause = SWITCH_CAUSE_ORIGINATOR_CANCEL;
3712 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 3712, (const char*)(oglobals.session), SWITCH_LOG_DEBUG,
3713 "Originate Cancelled by originator termination Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause));
3714
3715 } else if (oglobals.idx == IDX_TIMEOUT) {
3716 *cause = SWITCH_CAUSE_NO_ANSWER;
3717 } else {
3718 if (oglobals.idx == IDX_XFER) {
3719 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 3719, (const char*)(oglobals.session), SWITCH_LOG_DEBUG,
3720 "Originate Resulted in Attended Transfer Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause));
3721 } else {
3722
3723 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session)SWITCH_CHANNEL_ID_SESSION, "src/switch_ivr_originate.c", (const
char *)__func__, 3723, (const char*)(oglobals.session), SWITCH_LOG_DEBUG,
3724 "Originate Resulted in Error Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause));
3725 }
3726 }
3727 }
3728
3729 if (caller_channel) {
3730 switch_channel_set_variable(caller_channel, "originate_disposition", switch_channel_cause2str(*cause))switch_channel_set_variable_var_check(caller_channel, "originate_disposition"
, switch_channel_cause2str(*cause), SWITCH_TRUE);
3731
3732 switch (*cause) {
3733 case SWITCH_CAUSE_ORIGINATOR_CANCEL:
3734 switch_channel_set_variable(caller_channel, "DIALSTATUS", "CANCEL")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "CANCEL", SWITCH_TRUE);
3735 break;
3736 case SWITCH_CAUSE_USER_BUSY:
3737 switch_channel_set_variable(caller_channel, "DIALSTATUS", "BUSY")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "BUSY", SWITCH_TRUE);
3738 break;
3739 case SWITCH_CAUSE_NO_ANSWER:
3740 switch_channel_set_variable(caller_channel, "DIALSTATUS", "NOANSWER")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "NOANSWER", SWITCH_TRUE);
3741 break;
3742 case SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER:
3743 case SWITCH_CAUSE_INVALID_PROFILE:
3744 switch_channel_set_variable(caller_channel, "DIALSTATUS", "INVALIDARGS")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "INVALIDARGS", SWITCH_TRUE);
3745 break;
3746 case SWITCH_CAUSE_CALL_REJECTED:
3747 switch_channel_set_variable(caller_channel, "DIALSTATUS", "DONTCALL")switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, "DONTCALL", SWITCH_TRUE);
3748 break;
3749 default:
3750 switch_channel_set_variable(caller_channel, "DIALSTATUS", switch_channel_cause2str(*cause))switch_channel_set_variable_var_check(caller_channel, "DIALSTATUS"
, switch_channel_cause2str(*cause), SWITCH_TRUE);
3751 break;
3752 }
3753 }
3754
3755 early_state.ready = 0;
3756
3757 if (oglobals.ethread) {
3758 switch_status_t st;
3759 switch_thread_join(&st, oglobals.ethread);
3760 }
3761
3762 if (early_state.buffer) {
3763 switch_buffer_destroy(&early_state.buffer);
3764 }
3765
3766 if (ringback.fh) {
3767 switch_core_file_close(ringback.fh);
3768 ringback.fh = NULL((void*)0);
3769 } else if (ringback.audio_buffer) {
3770 teletone_destroy_session(&ringback.ts);
3771 switch_buffer_destroy(&ringback.audio_buffer);
3772 }
3773
3774 if (oglobals.session) {
3775 switch_core_session_reset(oglobals.session, SWITCH_FALSE, SWITCH_TRUE);
3776 }
3777
3778 if (switch_core_codec_ready(&write_codec)) {
3779 switch_core_codec_destroy(&write_codec);
3780 }
3781
3782 for (i = 0; i < and_argc; i++) {
3783 switch_channel_state_t state;
3784 switch_core_session_t *peer_session;
3785 char *val;
3786
3787 if (!originate_status[i].peer_channel) {
3788 continue;
3789 }
3790
3791 if (session) {
3792 val = switch_core_session_sprintf(originate_status[i].peer_session, "%s;%s",
3793 switch_core_session_get_uuid(originate_status[i].peer_session),
3794 switch_channel_cause2str(switch_channel_get_cause(originate_status[i].peer_channel)));
3795
3796 switch_channel_add_variable_var_check(switch_core_session_get_channel(session), "originate_causes", val, SWITCH_FALSE, SWITCH_STACK_PUSH);
3797 }
3798
3799 if (status == SWITCH_STATUS_SUCCESS) {
3800 switch_channel_clear_flag(originate_status[i].peer_channel, CF_ORIGINATING);
3801 if (bleg && *bleg && *bleg == originate_status[i].peer_session) {
3802 continue;
3803 }
3804 } else if ((state = switch_channel_get_state(originate_status[i].peer_channel)) < CS_HANGUP &&
3805 switch_channel_test_flag(originate_status[i].peer_channel, CF_ORIGINATING)) {
3806 if (!(state == CS_RESET || switch_channel_test_flag(originate_status[i].peer_channel, CF_TRANSFER) ||
3807 switch_channel_test_flag(originate_status[i].peer_channel, CF_REDIRECT) ||
3808 switch_channel_test_flag(originate_status[i].peer_channel, CF_BRIDGED))) {
3809 if (caller_channel && switch_channel_test_flag(caller_channel, CF_INTERCEPTED)) {
3810 switch_channel_set_flag(originate_status[i].peer_channel, CF_INTERCEPT)switch_channel_set_flag_value(originate_status[i].peer_channel
, CF_INTERCEPT, 1);
3811 }
3812 switch_channel_hangup(originate_status[i].peer_channel, *cause)switch_channel_perform_hangup(originate_status[i].peer_channel
, "src/switch_ivr_originate.c", (const char *)__func__, 3812,
*cause);
3813 }
3814 }
3815 switch_channel_clear_flag(originate_status[i].peer_channel, CF_ORIGINATING);
3816
3817 peer_session = originate_status[i].peer_session;
3818 originate_status[i].peer_session = NULL((void*)0);
3819 originate_status[i].peer_channel = NULL((void*)0);
3820 switch_core_session_rwunlock(peer_session);
3821 }
3822
3823 if (status == SWITCH_STATUS_SUCCESS || oglobals.idx == IDX_XFER) {
3824 goto outer_for;
3825 } else {
3826 int ok = 1;
3827
3828 if (fail_on_single_reject && check_reject && !switch_true(fail_on_single_reject_var)) {
3829 for (i = 0; i < and_argc; i++) {
3830 switch_channel_t *pchannel;
3831 const char *cause_str;
3832
3833 if (!originate_status[i].peer_session) {
3834 continue;
3835 }
3836
3837 pchannel = switch_core_session_get_channel(originate_status[i].peer_session);
3838 wait_for_cause(pchannel);
3839
3840 if (switch_channel_down_nosig(pchannel)(switch_channel_get_state(pchannel) >= CS_HANGUP)) {
3841 int neg, pos;
3842
3843 cause_str = switch_channel_cause2str(switch_channel_get_cause(pchannel));
3844
3845 neg = *fail_on_single_reject_var == '!';
3846 pos = !!switch_stristr(cause_str, fail_on_single_reject_var);
3847
3848 if (neg) {
3849 pos = !pos;
3850 }
3851
3852
3853 if (pos) {
3854 ok = 0;
3855 break;
3856 }
3857 }
3858 }
3859 }
3860
3861 if (!ok) {
3862 goto outer_for;
3863 }
3864
3865 if (to && !oglobals.continue_on_timeout) {
3866 goto outer_for;
3867 }
3868 }
3869 }
3870 }
3871 outer_for:
3872 switch_safe_free(loop_data)if (loop_data) {free(loop_data);loop_data=((void*)0);};
3873 switch_safe_free(odata)if (odata) {free(odata);odata=((void*)0);};
3874 switch_safe_free(oglobals.file)if (oglobals.file) {free(oglobals.file);oglobals.file=((void*
)0);};
3875 switch_safe_free(oglobals.error_file)if (oglobals.error_file) {free(oglobals.error_file);oglobals.
error_file=((void*)0);};
3876
3877 if (bleg && status != SWITCH_STATUS_SUCCESS) {
3878 *bleg = NULL((void*)0);
3879 }
3880
3881 if (bleg && !*bleg && status == SWITCH_STATUS_SUCCESS) {
3882 status = SWITCH_STATUS_FALSE;
3883 }
3884
3885 if (bleg && *bleg) {
3886 switch_channel_t *bchan = switch_core_session_get_channel(*bleg);
3887
3888 if (session && caller_channel) {
3889 switch_caller_profile_t *cloned_profile, *peer_profile = switch_channel_get_caller_profile(switch_core_session_get_channel(*bleg));
3890
3891 if (peer_profile) {
3892 if ((cloned_profile = switch_caller_profile_clone(session, peer_profile)) != 0) {
3893 switch_channel_set_originatee_caller_profile(caller_channel, cloned_profile);
3894 }
3895 }
3896
3897 switch_channel_set_variable(caller_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(*bleg))switch_channel_set_variable_var_check(caller_channel, "signal_bond"
, switch_core_session_get_uuid(*bleg), SWITCH_TRUE);
3898 // Now main SWITCH_SIGNAL_BOND_VARIABLE is populated, don't need this one anymore...
3899 switch_channel_set_variable(caller_channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, NULL)switch_channel_set_variable_var_check(caller_channel, "originate_signal_bond"
, ((void*)0), SWITCH_TRUE);
3900 }
3901
3902
3903 switch_channel_execute_on(bchan, SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE"execute_on_post_originate");
3904 switch_channel_api_on(bchan, SWITCH_CHANNEL_API_ON_POST_ORIGINATE_VARIABLE"api_on_post_originate");
3905
3906
3907 while(switch_channel_state_change_pending(bchan)) {
3908 switch_cond_next();
3909 }
3910
3911 switch_channel_audio_sync(bchan)switch_channel_perform_audio_sync(bchan, "src/switch_ivr_originate.c"
, (const char *)__func__, 3911);
3912
3913 if (caller_channel) {
3914 switch_channel_audio_sync(caller_channel)switch_channel_perform_audio_sync(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3914);
3915 }
3916 }
3917
3918 if (oglobals.session) {
3919 switch_ivr_parse_all_events(oglobals.session);
3920 }
3921
3922 if (oglobals.session && status == SWITCH_STATUS_SUCCESS) {
3923 switch_ivr_sleep(oglobals.session, 0, SWITCH_TRUE, NULL((void*)0));
3924 }
3925
3926 if (var_event && var_event != ovars) {
3927 switch_event_destroy(&var_event);
3928 }
3929
3930 switch_safe_free(write_frame.data)if (write_frame.data) {free(write_frame.data);write_frame.data
=((void*)0);};
3931 switch_safe_free(fail_on_single_reject_var)if (fail_on_single_reject_var) {free(fail_on_single_reject_var
);fail_on_single_reject_var=((void*)0);};
3932
3933 if (force_reason != SWITCH_CAUSE_NONE) {
3934 *cause = force_reason;
3935 }
3936
3937 if (caller_channel) {
3938
3939 switch_channel_execute_on(caller_channel, SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE"execute_on_post_originate");
3940 switch_channel_api_on(caller_channel, SWITCH_CHANNEL_API_ON_POST_ORIGINATE_VARIABLE"api_on_post_originate");
3941
3942 switch_channel_clear_flag(caller_channel, CF_ORIGINATOR);
3943 switch_channel_clear_flag(caller_channel, CF_XFER_ZOMBIE);
3944
3945 if (hangup_on_single_reject) {
3946 switch_channel_hangup(caller_channel, *cause)switch_channel_perform_hangup(caller_channel, "src/switch_ivr_originate.c"
, (const char *)__func__, 3946, *cause);
3947 }
3948 }
3949
3950
3951 switch_core_destroy_memory_pool(&oglobals.pool)switch_core_perform_destroy_memory_pool(&oglobals.pool, "src/switch_ivr_originate.c"
, (const char *)__func__, 3951);
3952
3953 return status;
3954}
3955
3956/* For Emacs:
3957 * Local Variables:
3958 * mode:c
3959 * indent-tabs-mode:t
3960 * tab-width:4
3961 * c-basic-offset:4
3962 * End:
3963 * For VIM:
3964 * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
3965 */