RTS API Documentation  1.10.11
switch_core_session.c
Go to the documentation of this file.
1 /*
2  * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
3  * Copyright (C) 2005-2021, 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  * Paul D. Tinsley <pdt at jackhammer.org>
29  * Joseph Sullivan <jossulli@amazon.com>
30  *
31  *
32  * switch_core_session.c -- Main Core Library (session routines)
33  *
34  */
35 
36 #include "switch.h"
37 #include "switch_core.h"
38 #include "private/switch_core_pvt.h"
39 
40 #define DEBUG_THREAD_POOL
41 
42 struct switch_session_manager session_manager;
43 
44 SWITCH_DECLARE(void) switch_core_session_set_dmachine(switch_core_session_t *session, switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)
45 {
46  int i = (int) target;
47 
48  if (i == 0 || i == 1) {
49  if (dmachine) {
50  switch_ivr_dmachine_set_target(dmachine, target);
51  }
52  session->dmachine[i] = dmachine;
53  }
54 }
55 
56 SWITCH_DECLARE(switch_ivr_dmachine_t *) switch_core_session_get_dmachine(switch_core_session_t *session, switch_digit_action_target_t target)
57 {
58  int i = (int) target;
59 
60  if (i == 0 || i == 1) {
61  return session->dmachine[i];
62  }
63 
64  return NULL;
65 }
66 
67 
68 SWITCH_DECLARE(switch_jb_t *) switch_core_session_get_jb(switch_core_session_t *session, switch_media_type_t type)
69 {
70  if (session->endpoint_interface->io_routines->get_jb) {
71  return session->endpoint_interface->io_routines->get_jb(session, type);
72  }
73 
74  return NULL;
75 }
76 
77 SWITCH_DECLARE(void) switch_core_session_soft_lock(switch_core_session_t *session, uint32_t sec)
78 {
79  session->soft_lock = sec;
80 }
81 
82 SWITCH_DECLARE(void) switch_core_session_soft_unlock(switch_core_session_t *session)
83 {
84  session->soft_lock = 0;
85 }
86 
87 SWITCH_DECLARE(switch_status_t) switch_core_session_set_codec_slin(switch_core_session_t *session, switch_slin_data_t *data)
88 
89 {
90  switch_codec_implementation_t read_impl = { 0 };
91  int interval;
92 
93  switch_core_session_get_read_impl(session, &read_impl);
94  interval = read_impl.microseconds_per_packet / 1000;
95  data->session = session;
96 
97  if (switch_core_codec_init(&data->codec,
98  "L16",
99  NULL,
100  NULL,
101  read_impl.actual_samples_per_second,
102  interval,
103  read_impl.number_of_channels, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, NULL) == SWITCH_STATUS_SUCCESS) {
104  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
105  SWITCH_LOG_DEBUG, "Codec Activated L16@%uhz %dms\n", read_impl.actual_samples_per_second, interval);
106 
107  memset(&data->write_frame, 0, sizeof(data->write_frame));
108 
109  data->write_frame.codec = &data->codec;
110  data->write_frame.data = data->frame_data;
111  data->write_frame.buflen = sizeof(data->frame_data);
112  data->write_frame.datalen = 0;
113  switch_core_session_set_read_codec(session, &data->codec);
114  return SWITCH_STATUS_SUCCESS;
115  }
116 
117  return SWITCH_STATUS_FALSE;
118 }
119 
120 
121 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_locate(const char *uuid_str, const char *file, const char *func, int line)
122 {
123  switch_core_session_t *session = NULL;
124 
125  if (uuid_str) {
126  switch_mutex_lock(runtime.session_hash_mutex);
127  if ((session = switch_core_hash_find(session_manager.session_table, uuid_str))) {
128  /* Acquire a read lock on the session */
129 #ifdef SWITCH_DEBUG_RWLOCKS
130  if (switch_core_session_perform_read_lock(session, file, func, line) != SWITCH_STATUS_SUCCESS) {
131 #if EMACS_CC_MODE_IS_BUGGY
132  }
133 #endif
134 #else
135  if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
136 #endif
137  /* not available, forget it */
138  session = NULL;
139  }
140  }
141  switch_mutex_unlock(runtime.session_hash_mutex);
142  }
143 
144  /* if its not NULL, now it's up to you to rwunlock this */
145  return session;
146 }
147 
148 
149 
150 
151 
152 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_force_locate(const char *uuid_str, const char *file, const char *func, int line)
153 {
154  switch_core_session_t *session = NULL;
155  switch_status_t status;
156 
157  if (uuid_str) {
158  switch_mutex_lock(runtime.session_hash_mutex);
159  if ((session = switch_core_hash_find(session_manager.session_table, uuid_str))) {
160  /* Acquire a read lock on the session */
161 
162  if (switch_test_flag(session, SSF_DESTROYED)) {
163  status = SWITCH_STATUS_FALSE;
164 #ifdef SWITCH_DEBUG_RWLOCKS
165  switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, uuid_str, SWITCH_LOG_ERROR, "%s %s Read lock FAIL\n",
166  switch_core_session_get_uuid(session), switch_channel_get_name(session->channel));
167 #endif
168  } else {
169  status = (switch_status_t) switch_thread_rwlock_tryrdlock(session->rwlock);
170 #ifdef SWITCH_DEBUG_RWLOCKS
171  switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, uuid_str, SWITCH_LOG_ERROR, "%s %s Read lock ACQUIRED\n",
172  switch_core_session_get_uuid(session), switch_channel_get_name(session->channel));
173 #endif
174  }
175 
176  if (status != SWITCH_STATUS_SUCCESS) {
177  /* not available, forget it */
178  session = NULL;
179  }
180  }
181  switch_mutex_unlock(runtime.session_hash_mutex);
182  }
183 
184  /* if its not NULL, now it's up to you to rwunlock this */
185  return session;
186 }
187 
188 
189 SWITCH_DECLARE(switch_status_t) switch_core_session_perform_get_partner(switch_core_session_t *session, switch_core_session_t **partner,
190  const char *file, const char *func, int line)
191 {
192  const char *uuid;
193  char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
194 
195  if ((uuid = switch_channel_get_partner_uuid_copy(session->channel, uuid_str, sizeof(uuid_str)))) {
196  if ((*partner = switch_core_session_perform_locate(uuid, file, func, line))) {
197  return SWITCH_STATUS_SUCCESS;
198  }
199  }
200 
201  *partner = NULL;
202  return SWITCH_STATUS_FALSE;
203 }
204 
205 
206 struct str_node {
207  char *str;
208  struct str_node *next;
209 };
210 
211 SWITCH_DECLARE(uint32_t) switch_core_session_hupall_matching_vars_ans(switch_event_t *vars, switch_call_cause_t cause, switch_hup_type_t type)
212 {
213  switch_hash_index_t *hi;
214  void *val;
215  switch_core_session_t *session;
216  switch_memory_pool_t *pool;
217  struct str_node *head = NULL, *np;
218  uint32_t r = 0;
219 
220  switch_core_new_memory_pool(&pool);
221 
222  if (!vars || !vars->headers)
223  return r;
224 
225  switch_mutex_lock(runtime.session_hash_mutex);
226  for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
227  switch_core_hash_this(hi, NULL, NULL, &val);
228  if (val) {
229  session = (switch_core_session_t *) val;
230  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
231  int ans = switch_channel_test_flag(switch_core_session_get_channel(session), CF_ANSWERED);
232  if ((ans && (type & SHT_ANSWERED)) || (!ans && (type & SHT_UNANSWERED))) {
233  np = switch_core_alloc(pool, sizeof(*np));
234  np->str = switch_core_strdup(pool, session->uuid_str);
235  np->next = head;
236  head = np;
237  }
238  switch_core_session_rwunlock(session);
239  }
240  }
241  }
242  switch_mutex_unlock(runtime.session_hash_mutex);
243 
244  for(np = head; np; np = np->next) {
245  if ((session = switch_core_session_locate(np->str))) {
246  const char *this_value;
247  if (switch_channel_up_nosig(session->channel)) {
248  /* check if all conditions are satisfied */
249  int do_hangup = 1;
250  switch_event_header_t *hp;
251  for (hp = vars->headers; hp; hp = hp->next) {
252  const char *var_name = hp->name;
253  const char *var_value = hp->value;
254  if (!(this_value = switch_channel_get_variable(session->channel, var_name)) || (strcmp(this_value, var_value))) {
255  do_hangup = 0;
256  break;
257  }
258  }
259  if (do_hangup) {
260  switch_channel_hangup(session->channel, cause);
261  r++;
262  }
263  }
264  switch_core_session_rwunlock(session);
265  }
266  }
267 
268  switch_core_destroy_memory_pool(&pool);
269 
270  return r;
271 }
272 
273 SWITCH_DECLARE(uint32_t) switch_core_session_hupall_matching_var_ans(const char *var_name, const char *var_val, switch_call_cause_t cause,
274  switch_hup_type_t type)
275 {
276  switch_event_t *vars;
277  int r = 0;
278 
279  if (!var_val || !var_name)
280  return r;
281 
282  switch_event_create(&vars, SWITCH_EVENT_CLONE);
283  switch_event_add_header_string(vars, SWITCH_STACK_BOTTOM, var_name, var_val);
284  r = switch_core_session_hupall_matching_vars_ans(vars, cause, type);
285  switch_event_destroy(&vars);
286  return r;
287 }
288 
289 SWITCH_DECLARE(switch_console_callback_match_t *) switch_core_session_findall_matching_var(const char *var_name, const char *var_val)
290 {
291  switch_hash_index_t *hi;
292  void *val;
293  switch_core_session_t *session;
294  switch_memory_pool_t *pool;
295  struct str_node *head = NULL, *np;
296  switch_console_callback_match_t *my_matches = NULL;
297  const char *like = NULL;
298 
299  if (var_val && *var_val == '~') {
300  like = var_val + 1;
301  }
302 
303  switch_core_new_memory_pool(&pool);
304 
305  switch_mutex_lock(runtime.session_hash_mutex);
306  for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
307  switch_core_hash_this(hi, NULL, NULL, &val);
308  if (val) {
309  session = (switch_core_session_t *) val;
310  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
311  np = switch_core_alloc(pool, sizeof(*np));
312  np->str = switch_core_strdup(pool, session->uuid_str);
313  np->next = head;
314  head = np;
315  switch_core_session_rwunlock(session);
316  }
317  }
318  }
319  switch_mutex_unlock(runtime.session_hash_mutex);
320 
321  for(np = head; np; np = np->next) {
322  if ((session = switch_core_session_locate(np->str))) {
323  const char *this_val;
324  if (switch_channel_up_nosig(session->channel) &&
325  (this_val = switch_channel_get_variable_dup(session->channel, var_name, SWITCH_FALSE, -1)) &&
326  (!var_val || (like && switch_stristr(like, var_val)) || !strcmp(this_val, var_val))) {
327  switch_console_push_match(&my_matches, (const char *) np->str);
328  }
329  switch_core_session_rwunlock(session);
330  }
331  }
332 
333  switch_core_destroy_memory_pool(&pool);
334 
335 
336  return my_matches;
337 }
338 
339 SWITCH_DECLARE(void) switch_core_session_hupall_endpoint(const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause)
340 {
341  switch_hash_index_t *hi;
342  void *val;
343  switch_core_session_t *session;
344  switch_memory_pool_t *pool;
345  struct str_node *head = NULL, *np;
346 
347  switch_core_new_memory_pool(&pool);
348 
349  switch_mutex_lock(runtime.session_hash_mutex);
350  for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
351  switch_core_hash_this(hi, NULL, NULL, &val);
352  if (val) {
353  session = (switch_core_session_t *) val;
354  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
355  if (session->endpoint_interface == endpoint_interface) {
356  np = switch_core_alloc(pool, sizeof(*np));
357  np->str = switch_core_strdup(pool, session->uuid_str);
358  np->next = head;
359  head = np;
360  }
361  switch_core_session_rwunlock(session);
362  }
363  }
364  }
365  switch_mutex_unlock(runtime.session_hash_mutex);
366 
367  for(np = head; np; np = np->next) {
368  if ((session = switch_core_session_locate(np->str))) {
369  switch_channel_hangup(session->channel, cause);
370  switch_core_session_rwunlock(session);
371  }
372  }
373 
374  switch_core_destroy_memory_pool(&pool);
375 
376 }
377 
378 SWITCH_DECLARE(void) switch_core_session_hupall(switch_call_cause_t cause)
379 {
380  switch_hash_index_t *hi;
381  void *val;
382  switch_core_session_t *session;
383  switch_memory_pool_t *pool;
384  struct str_node *head = NULL, *np;
385 
386  switch_core_new_memory_pool(&pool);
387 
388 
389  switch_mutex_lock(runtime.session_hash_mutex);
390  for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
391  switch_core_hash_this(hi, NULL, NULL, &val);
392  if (val) {
393  session = (switch_core_session_t *) val;
394  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
395  np = switch_core_alloc(pool, sizeof(*np));
396  np->str = switch_core_strdup(pool, session->uuid_str);
397  np->next = head;
398  head = np;
399  switch_core_session_rwunlock(session);
400  }
401  }
402  }
403  switch_mutex_unlock(runtime.session_hash_mutex);
404 
405  for(np = head; np; np = np->next) {
406  if ((session = switch_core_session_locate(np->str))) {
407  switch_channel_hangup(session->channel, cause);
408  switch_core_session_rwunlock(session);
409  }
410  }
411 
412  switch_core_destroy_memory_pool(&pool);
413 
414 }
415 
416 
417 SWITCH_DECLARE(switch_console_callback_match_t *) switch_core_session_findall(void)
418 {
419  switch_hash_index_t *hi;
420  void *val;
421  switch_core_session_t *session;
422  switch_console_callback_match_t *my_matches = NULL;
423 
424  switch_mutex_lock(runtime.session_hash_mutex);
425  for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
426  switch_core_hash_this(hi, NULL, NULL, &val);
427  if (val) {
428  session = (switch_core_session_t *) val;
429  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
430  switch_console_push_match(&my_matches, session->uuid_str);
431  switch_core_session_rwunlock(session);
432  }
433  }
434  }
435  switch_mutex_unlock(runtime.session_hash_mutex);
436 
437  return my_matches;
438 }
439 
440 SWITCH_DECLARE(switch_status_t) switch_core_session_message_send(const char *uuid_str, switch_core_session_message_t *message)
441 {
442  switch_core_session_t *session = NULL;
443  switch_status_t status = SWITCH_STATUS_FALSE;
444 
445  switch_mutex_lock(runtime.session_hash_mutex);
446  if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) {
447  /* Acquire a read lock on the session or forget it the channel is dead */
448  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
449  if (switch_channel_up_nosig(session->channel)) {
450  status = switch_core_session_receive_message(session, message);
451  }
452  switch_core_session_rwunlock(session);
453  }
454  }
455  switch_mutex_unlock(runtime.session_hash_mutex);
456 
457  return status;
458 }
459 
460 SWITCH_DECLARE(switch_status_t) switch_core_session_event_send(const char *uuid_str, switch_event_t **event)
461 {
462  switch_core_session_t *session = NULL;
463  switch_status_t status = SWITCH_STATUS_FALSE;
464 
465  switch_mutex_lock(runtime.session_hash_mutex);
466  if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) {
467  /* Acquire a read lock on the session or forget it the channel is dead */
468  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
469  if (switch_channel_up_nosig(session->channel)) {
470  status = switch_core_session_queue_event(session, event);
471  }
472  switch_core_session_rwunlock(session);
473  }
474  }
475  switch_mutex_unlock(runtime.session_hash_mutex);
476 
477  return status;
478 }
479 
480 
481 SWITCH_DECLARE(void *) switch_core_session_get_private_class(switch_core_session_t *session, switch_pvt_class_t index)
482 {
483  if ((int)index >= SWITCH_CORE_SESSION_MAX_PRIVATES) {
484  return NULL;
485  }
486 
487  switch_assert(session != NULL);
488  return session->private_info[index];
489 }
490 
491 
492 SWITCH_DECLARE(switch_status_t) switch_core_session_set_private_class(switch_core_session_t *session, void *private_info, switch_pvt_class_t index)
493 {
494  switch_assert(session != NULL);
495 
496  if ((int)index >= SWITCH_CORE_SESSION_MAX_PRIVATES) {
497  return SWITCH_STATUS_FALSE;
498  }
499 
500  session->private_info[index] = private_info;
501  return SWITCH_STATUS_SUCCESS;
502 }
503 
504 SWITCH_DECLARE(int) switch_core_session_add_stream(switch_core_session_t *session, void *private_info)
505 {
506  session->streams[session->stream_count++] = private_info;
507  return session->stream_count - 1;
508 }
509 
510 SWITCH_DECLARE(void *) switch_core_session_get_stream(switch_core_session_t *session, int index)
511 {
512  return session->streams[index];
513 }
514 
515 
516 SWITCH_DECLARE(int) switch_core_session_get_stream_count(switch_core_session_t *session)
517 {
518  return session->stream_count;
519 }
520 
521 SWITCH_DECLARE(switch_call_cause_t) switch_core_session_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,
522  const char *endpoint_name,
523  switch_caller_profile_t *caller_profile,
524  switch_core_session_t **new_session,
525  switch_memory_pool_t **pool,
526  switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
527 {
528  switch_io_event_hook_outgoing_channel_t *ptr;
529  switch_endpoint_interface_t *endpoint_interface;
530  switch_channel_t *channel = NULL;
531  switch_caller_profile_t *outgoing_profile = caller_profile;
532  switch_call_cause_t cause = SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL;
533  const char *forwardvar;
534  int forwardval = 70;
535 
536  if ((endpoint_interface = switch_loadable_module_get_endpoint_interface(endpoint_name)) == 0) {
537  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Could not locate channel type %s\n", endpoint_name);
538  return SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED;
539  }
540 
541  if (!endpoint_interface->io_routines->outgoing_channel) {
542  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Could not locate outgoing channel interface for %s\n", endpoint_name);
543  return SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED;
544  }
545 
546  if (session) {
547  channel = switch_core_session_get_channel(session);
548 
549  switch_assert(channel != NULL);
550 
551  forwardvar = switch_channel_get_variable(channel, SWITCH_MAX_FORWARDS_VARIABLE);
552  if (!zstr(forwardvar)) {
553  forwardval = atoi(forwardvar) - 1;
554  }
555  if (forwardval <= 0) {
556  return SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR;
557  }
558 
559  if (caller_profile) {
560  const char *eani = NULL, *eaniii = NULL;
561  const char *ecaller_id_name = NULL, *ecaller_id_number = NULL;
562 
563  if (!(flags & SOF_NO_EFFECTIVE_ANI)) {
564  eani = switch_channel_get_variable(channel, "effective_ani");
565  }
566 
567  if (!(flags & SOF_NO_EFFECTIVE_ANIII)) {
568  eaniii = switch_channel_get_variable(channel, "effective_aniii");
569  }
570 
571  if (!(flags & SOF_NO_EFFECTIVE_CID_NAME)) {
572  ecaller_id_name = switch_channel_get_variable(channel, "effective_caller_id_name");
573  }
574 
575  if (!(flags & SOF_NO_EFFECTIVE_CID_NUM)) {
576  ecaller_id_number = switch_channel_get_variable(channel, "effective_caller_id_number");
577  }
578 
579  if (eani || eaniii || ecaller_id_name || ecaller_id_number) {
580  outgoing_profile = switch_caller_profile_clone(session, caller_profile);
581 
582  if (eani) {
583  outgoing_profile->ani = eani;
584  }
585  if (eaniii) {
586  outgoing_profile->aniii = eaniii;
587  }
588  if (ecaller_id_name) {
589  outgoing_profile->caller_id_name = ecaller_id_name;
590  }
591  if (ecaller_id_number) {
592  outgoing_profile->caller_id_number = ecaller_id_number;
593  }
594  }
595  }
596  if (!outgoing_profile) {
597  outgoing_profile = switch_channel_get_caller_profile(channel);
598  }
599  }
600 
601  if ((cause =
602  endpoint_interface->io_routines->outgoing_channel(session, var_event, outgoing_profile, new_session, pool, flags,
603  cancel_cause)) != SWITCH_CAUSE_SUCCESS) {
604  UNPROTECT_INTERFACE(endpoint_interface);
605  return cause;
606  }
607 
608  if (session) {
609  for (ptr = session->event_hooks.outgoing_channel; ptr; ptr = ptr->next) {
610  if (ptr->outgoing_channel(session, var_event, caller_profile, *new_session, flags) != SWITCH_STATUS_SUCCESS) {
611  break;
612  }
613  }
614  }
615 
616  if (!*new_session) {
617  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT,
618  "Outgoing method for endpoint: [%s] returned: [%s] but there is no new session!\n", endpoint_name,
619  switch_channel_cause2str(cause));
620  UNPROTECT_INTERFACE(endpoint_interface);
621  return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
622  } else {
623  switch_caller_profile_t *profile = NULL, *cloned_profile = NULL;
624  switch_event_t *event;
625  switch_channel_t *peer_channel = switch_core_session_get_channel(*new_session);
626  const char *use_uuid;
627  const char *use_external_id;
628  switch_core_session_t *other_session = NULL;
629 
630  switch_assert(peer_channel);
631 
632  if (channel && switch_true(switch_channel_get_variable(channel, "session_copy_loglevel"))) {
633  (*new_session)->loglevel = session->loglevel;
634  }
635 
636 
637  if ((use_uuid = switch_event_get_header(var_event, "origination_uuid"))) {
638  use_uuid = switch_core_session_strdup(*new_session, use_uuid);
639  if (switch_core_session_set_uuid(*new_session, use_uuid) == SWITCH_STATUS_SUCCESS) {
640  switch_event_del_header(var_event, "origination_uuid");
641  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_DEBUG, "%s set UUID=%s\n", switch_channel_get_name(peer_channel),
642  use_uuid);
643  } else {
644  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_CRIT, "%s set UUID=%s FAILED\n",
645  switch_channel_get_name(peer_channel), use_uuid);
646  }
647  }
648 
649  if ((use_external_id = switch_event_get_header(var_event, "origination_external_id"))) {
650  if (switch_core_session_set_external_id(*new_session, use_external_id) == SWITCH_STATUS_SUCCESS) {
651  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_DEBUG, "%s set external_id=%s\n", switch_channel_get_name(peer_channel),
652  use_external_id);
653  switch_event_del_header(var_event, "origination_external_id");
654  } else {
655  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_CRIT, "%s set external_id=%s FAILED\n",
656  switch_channel_get_name(peer_channel), use_external_id);
657  }
658  }
659 
660  if (!channel && var_event) {
661  const char *other_uuid;
662 
663  if ((other_uuid = switch_event_get_header(var_event, "origination_aleg_uuid")) && (other_session = switch_core_session_locate(other_uuid))) {
664  channel = switch_core_session_get_channel(other_session);
665  session = other_session;
666  }
667  }
668 
669  if (channel) {
670  const char *val;
671  switch_codec_t *vid_read_codec = NULL, *read_codec = switch_core_session_get_read_codec(session);
672  const char *ep = NULL, *max_forwards = switch_core_session_sprintf(session, "%d", forwardval);
673 
674  switch_channel_set_variable(peer_channel, SWITCH_MAX_FORWARDS_VARIABLE, max_forwards);
675 
676  profile = switch_channel_get_caller_profile(channel);
677 
678  vid_read_codec = switch_core_session_get_video_read_codec(session);
679 
680  ep = switch_channel_get_variable(channel, "ep_codec_string");
681 
682  if (read_codec && read_codec->implementation && switch_core_codec_ready(read_codec)) {
683  char rc[80] = "", vrc[80] = "", tmp[160] = "";
684 
685  switch_codec2str(read_codec, rc, sizeof(rc));
686  if (vid_read_codec && vid_read_codec->implementation && switch_core_codec_ready(vid_read_codec)) {
687  vrc[0] = ',';
688  switch_codec2str(vid_read_codec, vrc + 1, sizeof(vrc) - 1);
689  switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_VIDEO_CODEC_VARIABLE, vrc + 1);
690  }
691 
692  switch_snprintf(tmp, sizeof(tmp), "%s%s", rc, vrc);
693  switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_CODEC_VARIABLE, tmp);
694  } else if (ep) {
695  switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_CODEC_VARIABLE, ep);
696  }
697 
698 
699  if (switch_channel_test_flag(channel, CF_MSRPS) || switch_channel_test_flag(channel, CF_WANT_MSRPS)) {
700  switch_channel_set_flag(peer_channel, CF_WANT_MSRPS);
701  } else if (switch_channel_test_flag(channel, CF_MSRP) || switch_channel_test_flag(channel, CF_WANT_MSRP)) {
702  switch_channel_set_flag(peer_channel, CF_WANT_MSRP);
703  }
704 
705  if (switch_channel_test_flag(channel, CF_RTT) || switch_channel_test_flag(channel, CF_WANT_RTT)) {
706  switch_channel_set_flag(peer_channel, CF_WANT_RTT);
707  }
708 
709 
710  switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_VARIABLE, switch_core_session_get_uuid(session));
711  switch_channel_set_variable(peer_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(session));
712  // Needed by 3PCC proxy so that aleg can find bleg to pass SDP to, when final ACK arrives.
713  switch_channel_set_variable(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(*new_session));
714 
715  if ((val = switch_channel_get_variable(channel, SWITCH_PROCESS_CDR_VARIABLE))) {
716  switch_channel_set_variable(peer_channel, SWITCH_PROCESS_CDR_VARIABLE, val);
717  }
718 
719  if ((val = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE))) {
720  switch_channel_pass_sdp(channel, peer_channel, val);
721  }
722 
723  if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
724  if (switch_channel_test_cap(peer_channel, CC_BYPASS_MEDIA)) {
725  switch_channel_set_flag(peer_channel, CF_PROXY_MODE);
726  } else {
727  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
728  "%s does not support the proxy feature, disabling.\n", switch_channel_get_name(peer_channel));
729  switch_channel_clear_flag(channel, CF_PROXY_MODE);
730  }
731  }
732 
733  if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
734  if (switch_channel_test_cap(peer_channel, CC_PROXY_MEDIA)) {
735  switch_channel_set_flag(peer_channel, CF_PROXY_MEDIA);
736  if (switch_channel_test_flag(channel, CF_VIDEO)) {
737  switch_channel_set_flag(peer_channel, CF_VIDEO);
738  }
739  } else {
740  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
741  "%s does not support the proxy feature, disabling.\n", switch_channel_get_name(peer_channel));
742  switch_channel_clear_flag(channel, CF_PROXY_MEDIA);
743  }
744  }
745 
746  if (profile) {
747  if ((cloned_profile = switch_caller_profile_clone(*new_session, profile)) != 0) {
748  switch_channel_set_originator_caller_profile(peer_channel, cloned_profile);
749  }
750  }
751 
752 
753  if ((profile = switch_channel_get_caller_profile(peer_channel))) {
754  if ((cloned_profile = switch_caller_profile_clone(session, profile)) != 0) {
755  switch_channel_set_origination_caller_profile(channel, cloned_profile);
756  }
757  }
758 
759  }
760 
761  if (other_session) {
762  switch_core_session_rwunlock(other_session);
763  channel = NULL;
764  session = NULL;
765  }
766 
767 
768  if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_OUTGOING) == SWITCH_STATUS_SUCCESS) {
769  switch_channel_event_set_data(peer_channel, event);
770  switch_event_fire(&event);
771  }
772  }
773 
774  UNPROTECT_INTERFACE(endpoint_interface);
775  return cause;
776 }
777 
778 static const char *message_names[] = {
779  "REDIRECT_AUDIO",
780  "TRANSMIT_TEXT",
781  "ANSWER",
782  "ACKNOWLEDGE_CALL",
783  "PROGRESS",
784  "BRIDGE",
785  "UNBRIDGE",
786  "TRANSFER",
787  "RINGING",
788  "ALERTING",
789  "MEDIA",
790  "3P_MEDIA",
791  "NOMEDIA",
792  "3P_NOMEDIA",
793  "HOLD",
794  "UNHOLD",
795  "REDIRECT",
796  "RESPOND",
797  "BROADCAST",
798  "MEDIA_REDIRECT",
799  "DEFLECT",
800  "VIDEO_REFRESH_REQ",
801  "DISPLAY",
802  "MEDIA_PARAMS",
803  "TRANSCODING_NECESSARY",
804  "AUDIO_SYNC",
805  "VIDEO_SYNC",
806  "REQUEST_IMAGE_MEDIA",
807  "UUID_CHANGE",
808  "SIMPLIFY",
809  "DEBUG_MEDIA",
810  "PROXY_MEDIA",
811  "APPLICATION_EXEC",
812  "APPLICATION_EXEC_COMPLETE",
813  "PHONE_EVENT",
814  "T38_DESCRIPTION",
815  "UDPTL_MODE",
816  "CLEAR_PROGRESS",
817  "JITTER_BUFFER",
818  "RECOVERY_REFRESH",
819  "SIGNAL_DATA",
820  "MESSAGE",
821  "INFO",
822  "AUDIO_DATA",
823  "BLIND_TRANSFER_RESPONSE",
824  "STUN_ERROR",
825  "MEDIA_RENEG",
826  "KEEPALIVE",
827  "HARD_MUTE",
828  "BITRATE_REQ",
829  "BITRATE_ACK",
830  "CODEC_DEBUG_REQ",
831  "CODEC_SPECIFIC_REQ",
832  "REFER_EVENT",
833  "ANSWER_EVENT",
834  "PROGRESS_EVENT",
835  "RING_EVENT",
836  "RESAMPLE_EVENT",
837  "HEARTBEAT_EVENT",
838  "SESSION_ID",
839  "PROMPT",
840  "INVALID"
841 };
842 
843 SWITCH_DECLARE(switch_status_t) switch_core_session_perform_receive_message(switch_core_session_t *session,
844  switch_core_session_message_t *message,
845  const char *file, const char *func, int line)
846 {
847  switch_io_event_hook_receive_message_t *ptr;
848  switch_status_t status = SWITCH_STATUS_SUCCESS;
849 
850  switch_assert(session != NULL);
851 
852  if (message->message_id == SWITCH_MESSAGE_INDICATE_SIGNAL_DATA) {
853  if (session->endpoint_interface->io_routines->receive_message) {
854  status = session->endpoint_interface->io_routines->receive_message(session, message);
855  }
856 
857  switch_core_session_free_message(&message);
858  return status;
859  }
860 
861  if ((status = switch_core_session_read_lock_hangup(session)) != SWITCH_STATUS_SUCCESS) {
862  return status;
863  }
864 
865  if (!message->_file) {
866  message->_file = file;
867  }
868 
869  if (!message->_func) {
870  message->_func = func;
871  }
872 
873  if (!message->_line) {
874  message->_line = line;
875  }
876 
877  if (message->message_id > SWITCH_MESSAGE_INVALID-1) {
878  message->message_id = SWITCH_MESSAGE_INVALID-1;
879  }
880 
881  switch_log_printf(SWITCH_CHANNEL_ID_LOG, message->_file, message->_func, message->_line,
882  switch_core_session_get_uuid(session), SWITCH_LOG_DEBUG1, "%s receive message [%s]\n",
883  switch_channel_get_name(session->channel), message_names[message->message_id]);
884 
885 
886  if (message->message_id == SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS) {
887  switch_channel_clear_flag(session->channel, CF_EARLY_MEDIA);
888  }
889 
890  if (message->message_id == SWITCH_MESSAGE_INDICATE_MEDIA) {
891  switch_channel_set_flag(session->channel, CF_PROXY_OFF);
892  }
893 
894  if (message->message_id == SWITCH_MESSAGE_INDICATE_DISPLAY) {
895  char *arg = NULL;
896 
897  if (zstr(message->string_array_arg[0]) && !zstr(message->string_arg)) {
898  arg = switch_core_session_strdup(session, message->string_arg);
899  switch_separate_string(arg, '|', (char **)message->string_array_arg, 2);
900  }
901 
902  if (!zstr(message->string_array_arg[0])) {
903  switch_channel_set_variable(session->channel, "last_sent_callee_id_name", message->string_array_arg[0]);
904  }
905 
906  if (!zstr(message->string_array_arg[1])) {
907  switch_channel_set_variable(session->channel, "last_sent_callee_id_number", message->string_array_arg[1]);
908  }
909 
910 
911  if (switch_true(switch_channel_get_variable(session->channel, SWITCH_IGNORE_DISPLAY_UPDATES_VARIABLE))) {
912  switch_log_printf(SWITCH_CHANNEL_ID_LOG, message->_file, message->_func, message->_line,
913  switch_core_session_get_uuid(session), SWITCH_LOG_DEBUG1, "Ignoring display update.\n");
914  status = SWITCH_STATUS_SUCCESS;
915  goto end;
916  }
917 
918  }
919 
920  if (switch_channel_down_nosig(session->channel)) {
921  switch_log_printf(SWITCH_CHANNEL_ID_LOG, message->_file, message->_func, message->_line,
922  switch_core_session_get_uuid(session), SWITCH_LOG_DEBUG, "%s skip receive message [%s] (channel is hungup already)\n",
923  switch_channel_get_name(session->channel), message_names[message->message_id]);
924 
925  } else {
926  if (session->media_handle) {
927  status = switch_core_media_receive_message(session, message);
928  }
929  if (status == SWITCH_STATUS_SUCCESS) {
930  if (session->endpoint_interface->io_routines->receive_message) {
931  status = session->endpoint_interface->io_routines->receive_message(session, message);
932  }
933  }
934  }
935 
936  if (status == SWITCH_STATUS_SUCCESS) {
937  for (ptr = session->event_hooks.receive_message; ptr; ptr = ptr->next) {
938  if ((status = ptr->receive_message(session, message)) != SWITCH_STATUS_SUCCESS) {
939  break;
940  }
941  }
942 
943 
944  if (message->message_id == SWITCH_MESSAGE_INDICATE_BRIDGE &&
945  switch_channel_test_flag(session->channel, CF_CONFIRM_BLIND_TRANSFER)) {
946  switch_core_session_t *other_session;
947  const char *uuid = switch_channel_get_variable(session->channel, "blind_transfer_uuid");
948 
949  switch_channel_clear_flag(session->channel, CF_CONFIRM_BLIND_TRANSFER);
950 
951  if (!zstr(uuid) && (other_session = switch_core_session_locate(uuid))) {
952  switch_core_session_message_t msg = { 0 };
953  msg.message_id = SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE;
954  msg.from = __FILE__;
955  msg.numeric_arg = 1;
956  switch_core_session_receive_message(other_session, &msg);
957  switch_core_session_rwunlock(other_session);
958  }
959  }
960  }
961 
962 
963  message->_file = NULL;
964  message->_func = NULL;
965  message->_line = 0;
966 
967  if (switch_channel_up_nosig(session->channel)) {
968  if (message->message_id == SWITCH_MESSAGE_INDICATE_BRIDGE || message->message_id == SWITCH_MESSAGE_INDICATE_UNBRIDGE) {
969  switch_core_media_bug_flush_all(session);
970  switch_core_recovery_track(session);
971  }
972 
973  switch (message->message_id) {
974  case SWITCH_MESSAGE_REDIRECT_AUDIO:
975  case SWITCH_MESSAGE_INDICATE_ANSWER:
976  case SWITCH_MESSAGE_INDICATE_PROGRESS:
977  case SWITCH_MESSAGE_INDICATE_BRIDGE:
978  case SWITCH_MESSAGE_INDICATE_UNBRIDGE:
979  case SWITCH_MESSAGE_INDICATE_TRANSFER:
980  case SWITCH_MESSAGE_INDICATE_RINGING:
981  case SWITCH_MESSAGE_INDICATE_MEDIA:
982  case SWITCH_MESSAGE_INDICATE_NOMEDIA:
983  case SWITCH_MESSAGE_INDICATE_HOLD:
984  case SWITCH_MESSAGE_INDICATE_UNHOLD:
985  case SWITCH_MESSAGE_INDICATE_REDIRECT:
986  case SWITCH_MESSAGE_INDICATE_RESPOND:
987  case SWITCH_MESSAGE_INDICATE_BROADCAST:
988  case SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT:
989  case SWITCH_MESSAGE_INDICATE_DEFLECT:
990  switch_channel_set_flag(session->channel, CF_VIDEO_BREAK);
991  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
992  break;
993  default:
994  break;
995  }
996  }
997 
998  end:
999 
1000  if (message->message_id == SWITCH_MESSAGE_INDICATE_MEDIA) {
1001  switch_channel_clear_flag(session->channel, CF_PROXY_OFF);
1002  }
1003 
1004  switch_core_session_free_message(&message);
1005  switch_core_session_rwunlock(session);
1006 
1007  return status;
1008 }
1009 
1010 SWITCH_DECLARE(switch_status_t) switch_core_session_pass_indication(switch_core_session_t *session, switch_core_session_message_types_t indication)
1011 {
1012  switch_core_session_message_t msg = { 0 };
1013  switch_core_session_t *other_session;
1014  const char *uuid;
1015  switch_channel_t *channel = switch_core_session_get_channel(session);
1016  switch_status_t status = SWITCH_STATUS_SUCCESS;
1017 
1018  if (((uuid = switch_channel_get_partner_uuid(channel))) && (other_session = switch_core_session_locate(uuid))) {
1019  msg.message_id = indication;
1020  msg.from = __FILE__;
1021  status = switch_core_session_receive_message(other_session, &msg);
1022  switch_core_session_rwunlock(other_session);
1023  } else {
1024  status = SWITCH_STATUS_FALSE;
1025  }
1026 
1027  return status;
1028 }
1029 
1030 SWITCH_DECLARE(switch_status_t) switch_core_session_queue_indication(switch_core_session_t *session, switch_core_session_message_types_t indication)
1031 {
1032  switch_core_session_message_t *msg;
1033 
1034  if ((msg = malloc(sizeof(*msg)))) {
1035  memset(msg, 0, sizeof(*msg));
1036  msg->message_id = indication;
1037  msg->from = __FILE__;
1038  switch_set_flag(msg, SCSMF_DYNAMIC);
1039 
1040  if (switch_core_session_queue_message(session, msg) == SWITCH_STATUS_SUCCESS) {
1041  return SWITCH_STATUS_SUCCESS;
1042  }
1043 
1044  free(msg);
1045  }
1046 
1047  return SWITCH_STATUS_FALSE;
1048 }
1049 
1050 SWITCH_DECLARE(switch_status_t) switch_core_session_queue_message(switch_core_session_t *session, switch_core_session_message_t *message)
1051 {
1052  switch_status_t status = SWITCH_STATUS_FALSE;
1053 
1054  switch_assert(session != NULL);
1055 
1056  if (session->message_queue) {
1057  if (switch_queue_trypush(session->message_queue, message) == SWITCH_STATUS_SUCCESS) {
1058  status = SWITCH_STATUS_SUCCESS;
1059  }
1060 
1061  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
1062 
1063  switch_core_session_wake_session_thread(session);
1064 
1065  }
1066 
1067  return status;
1068 }
1069 
1070 SWITCH_DECLARE(void) switch_core_session_free_message(switch_core_session_message_t **message)
1071 {
1072  switch_core_session_message_t *to_free = *message;
1073  int i;
1074  char *s;
1075 
1076  *message = NULL;
1077 
1078  if (switch_test_flag(to_free, SCSMF_DYNAMIC)) {
1079  s = (char *) to_free->string_arg;
1080  switch_safe_free(s);
1081  switch_safe_free(to_free->pointer_arg);
1082 
1083  for (i = 0; i < MESSAGE_STRING_ARG_MAX; i++) {
1084  s = (char *) to_free->string_array_arg[i];
1085  switch_safe_free(s);
1086  }
1087 
1088  switch_safe_free(to_free);
1089  }
1090 }
1091 
1092 SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_message(switch_core_session_t *session, switch_core_session_message_t **message)
1093 {
1094  switch_status_t status = SWITCH_STATUS_FALSE;
1095  void *pop;
1096 
1097  switch_assert(session != NULL);
1098 
1099  if (session->message_queue) {
1100  if ((status = (switch_status_t) switch_queue_trypop(session->message_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
1101  *message = (switch_core_session_message_t *) pop;
1102  if ((*message)->delivery_time && (*message)->delivery_time > switch_epoch_time_now(NULL)) {
1103  switch_core_session_queue_message(session, *message);
1104  *message = NULL;
1105  status = SWITCH_STATUS_FALSE;
1106  }
1107  }
1108  }
1109 
1110  return status;
1111 }
1112 
1113 SWITCH_DECLARE(switch_status_t) switch_core_session_flush_message(switch_core_session_t *session)
1114 {
1115  void *pop;
1116  switch_core_session_message_t *message;
1117 
1118  switch_assert(session != NULL);
1119 
1120  if (session->message_queue) {
1121  while (switch_queue_trypop(session->message_queue, &pop) == SWITCH_STATUS_SUCCESS) {
1122  message = (switch_core_session_message_t *) pop;
1123  switch_ivr_process_indications(session, message);
1124  switch_core_session_free_message(&message);
1125  }
1126  }
1127 
1128  return SWITCH_STATUS_SUCCESS;
1129 }
1130 
1131 SWITCH_DECLARE(switch_status_t) switch_core_session_queue_signal_data(switch_core_session_t *session, void *signal_data)
1132 {
1133  switch_status_t status = SWITCH_STATUS_FALSE;
1134 
1135  switch_assert(session != NULL);
1136 
1137  if (session->signal_data_queue) {
1138  if (switch_queue_push(session->signal_data_queue, signal_data) == SWITCH_STATUS_SUCCESS) {
1139  status = SWITCH_STATUS_SUCCESS;
1140  }
1141 
1142  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
1143 
1144  switch_core_session_wake_session_thread(session);
1145 
1146  }
1147 
1148  return status;
1149 }
1150 
1151 SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_signal_data(switch_core_session_t *session, void **signal_data)
1152 {
1153  switch_status_t status = SWITCH_STATUS_FALSE;
1154  void *pop;
1155 
1156  switch_assert(session != NULL);
1157 
1158  if (session->signal_data_queue) {
1159  if ((status = (switch_status_t) switch_queue_trypop(session->signal_data_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
1160  *signal_data = pop;
1161  }
1162  }
1163 
1164  return status;
1165 }
1166 
1167 SWITCH_DECLARE(switch_status_t) switch_core_session_receive_event(switch_core_session_t *session, switch_event_t **event)
1168 {
1169  switch_io_event_hook_receive_event_t *ptr;
1170  switch_status_t status = SWITCH_STATUS_FALSE;
1171 
1172  switch_assert(session != NULL);
1173 
1174  /* Acquire a read lock on the session or forget it the channel is dead */
1175  if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
1176  if (switch_channel_up_nosig(session->channel)) {
1177  if (session->endpoint_interface->io_routines->receive_event) {
1178  status = session->endpoint_interface->io_routines->receive_event(session, *event);
1179  }
1180 
1181  if (status == SWITCH_STATUS_SUCCESS) {
1182  for (ptr = session->event_hooks.receive_event; ptr; ptr = ptr->next) {
1183  if ((status = ptr->receive_event(session, *event)) != SWITCH_STATUS_SUCCESS) {
1184  break;
1185  }
1186  }
1187  }
1188 
1189  if (status == SWITCH_STATUS_BREAK) {
1190  status = SWITCH_STATUS_SUCCESS;
1191  }
1192 
1193  if (status == SWITCH_STATUS_SUCCESS) {
1194  switch_event_destroy(event);
1195  }
1196  }
1197  switch_core_session_rwunlock(session);
1198  }
1199 
1200  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
1201 
1202  return status;
1203 }
1204 
1205 SWITCH_DECLARE(switch_status_t) switch_core_session_queue_event(switch_core_session_t *session, switch_event_t **event)
1206 {
1207  switch_status_t status = SWITCH_STATUS_FALSE;
1208 
1209  switch_assert(session != NULL);
1210 
1211  if (session->event_queue) {
1212  if (switch_queue_trypush(session->event_queue, *event) == SWITCH_STATUS_SUCCESS) {
1213  *event = NULL;
1214  status = SWITCH_STATUS_SUCCESS;
1215 
1216  switch_core_session_wake_session_thread(session);
1217  }
1218  }
1219 
1220  return status;
1221 }
1222 
1223 SWITCH_DECLARE(uint32_t) switch_core_session_messages_waiting(switch_core_session_t *session)
1224 {
1225  int x = 0;
1226 
1227  if (session->private_event_queue) {
1228  x += switch_queue_size(session->private_event_queue);
1229  }
1230 
1231  if (session->message_queue) {
1232  x += switch_queue_size(session->message_queue);
1233  }
1234 
1235  return x;
1236 }
1237 
1238 SWITCH_DECLARE(uint32_t) switch_core_session_event_count(switch_core_session_t *session)
1239 {
1240  if (session->event_queue) {
1241  return switch_queue_size(session->event_queue);
1242  }
1243 
1244  return 0;
1245 }
1246 
1247 SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_event(switch_core_session_t *session, switch_event_t **event, switch_bool_t force)
1248 {
1249  switch_status_t status = SWITCH_STATUS_FALSE;
1250  void *pop;
1251 
1252  switch_assert(session != NULL);
1253 
1254  if (session->event_queue && (force || !switch_channel_test_flag(session->channel, CF_DIVERT_EVENTS))) {
1255  if ((status = (switch_status_t) switch_queue_trypop(session->event_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
1256  *event = (switch_event_t *) pop;
1257  }
1258  }
1259 
1260  return status;
1261 }
1262 
1263 SWITCH_DECLARE(switch_status_t) switch_core_session_queue_private_event(switch_core_session_t *session, switch_event_t **event, switch_bool_t priority)
1264 {
1265  switch_status_t status = SWITCH_STATUS_FALSE;
1266  switch_queue_t *queue;
1267 
1268  switch_assert(session != NULL);
1269  switch_assert(event != NULL);
1270 
1271  if (session->private_event_queue) {
1272  queue = priority ? session->private_event_queue_pri : session->private_event_queue;
1273 
1274  (*event)->event_id = SWITCH_EVENT_PRIVATE_COMMAND;
1275  if (switch_queue_trypush(queue, *event) == SWITCH_STATUS_SUCCESS) {
1276  *event = NULL;
1277  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
1278  status = SWITCH_STATUS_SUCCESS;
1279  }
1280  }
1281 
1282  return status;
1283 }
1284 
1285 #define check_media(session) \
1286  { \
1287  if (switch_channel_test_flag(session->channel, CF_BROADCAST_DROP_MEDIA)) { \
1288  switch_channel_clear_flag(session->channel, CF_BROADCAST_DROP_MEDIA); \
1289  switch_ivr_nomedia(session->uuid_str, SMF_REBRIDGE); \
1290  } \
1291  } \
1292 
1293 SWITCH_DECLARE(uint32_t) switch_core_session_private_event_count(switch_core_session_t *session)
1294 {
1295  switch_channel_t *channel = switch_core_session_get_channel(session);
1296  uint32_t count = 0;
1297 
1298  if (session->private_event_queue) {
1299 
1300  if (!switch_channel_test_flag(channel, CF_EVENT_LOCK)) {
1301  count = switch_queue_size(session->private_event_queue);
1302  }
1303 
1304  if (!switch_channel_test_flag(channel, CF_EVENT_LOCK_PRI)) {
1305  count += switch_queue_size(session->private_event_queue_pri);
1306  }
1307 
1308  if (count == 0) {
1309  check_media(session);
1310  }
1311  }
1312 
1313  return count;
1314 }
1315 
1316 SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_private_event(switch_core_session_t *session, switch_event_t **event)
1317 {
1318  switch_status_t status = SWITCH_STATUS_FALSE;
1319  void *pop;
1320  switch_channel_t *channel = switch_core_session_get_channel(session);
1321  switch_queue_t *queue;
1322 
1323  if (session->private_event_queue) {
1324  if (switch_queue_size(session->private_event_queue_pri)) {
1325  queue = session->private_event_queue_pri;
1326 
1327  if (switch_channel_test_flag(channel, CF_EVENT_LOCK_PRI)) {
1328  return SWITCH_STATUS_FALSE;
1329  }
1330  } else {
1331  queue = session->private_event_queue;
1332 
1333  if (switch_channel_test_flag(channel, CF_EVENT_LOCK)) {
1334  return SWITCH_STATUS_FALSE;
1335  }
1336  }
1337 
1338  if ((status = (switch_status_t) switch_queue_trypop(queue, &pop)) == SWITCH_STATUS_SUCCESS) {
1339  *event = (switch_event_t *) pop;
1340  } else {
1341  check_media(session);
1342  }
1343  }
1344 
1345  return status;
1346 }
1347 
1348 SWITCH_DECLARE(uint32_t) switch_core_session_flush_private_events(switch_core_session_t *session)
1349 {
1350  int x = 0;
1351  void *pop;
1352 
1353  if (session->private_event_queue) {
1354  while (switch_queue_trypop(session->private_event_queue_pri, &pop) == SWITCH_STATUS_SUCCESS) {
1355  if (pop) {
1356  switch_event_t *event = (switch_event_t *) pop;
1357  switch_event_destroy(&event);
1358  }
1359  x++;
1360  }
1361  while (switch_queue_trypop(session->private_event_queue, &pop) == SWITCH_STATUS_SUCCESS) {
1362  if (pop) {
1363  switch_event_t *event = (switch_event_t *) pop;
1364  switch_event_destroy(&event);
1365  }
1366  x++;
1367  }
1368  check_media(session);
1369  }
1370 
1371  return x;
1372 }
1373 
1374 SWITCH_DECLARE(switch_status_t) switch_core_session_try_reset(switch_core_session_t* session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
1375 {
1376  switch_status_t status = SWITCH_STATUS_FALSE;
1377 
1378  if (switch_mutex_trylock(session->codec_read_mutex) == SWITCH_STATUS_SUCCESS) {
1379  if (switch_mutex_trylock(session->codec_write_mutex) == SWITCH_STATUS_SUCCESS) {
1380  switch_core_session_reset(session, flush_dtmf, reset_read_codec);
1381  switch_mutex_unlock(session->codec_write_mutex);
1382  status = SWITCH_STATUS_SUCCESS;
1383  }
1384 
1385  switch_mutex_unlock(session->codec_read_mutex);
1386  }
1387 
1388  return status;
1389 }
1390 
1391 SWITCH_DECLARE(void) switch_core_session_reset(switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
1392 {
1393  switch_channel_t *channel = switch_core_session_get_channel(session);
1394 
1395  if (reset_read_codec) {
1396  switch_core_session_set_read_codec(session, NULL);
1397  if (session->sdata && switch_core_codec_ready(&session->sdata->codec)) {
1398  switch_core_codec_destroy(&session->sdata->codec);
1399  }
1400  }
1401 
1402  /* clear resamplers */
1403  switch_mutex_lock(session->resample_mutex);
1404  switch_resample_destroy(&session->read_resampler);
1405  switch_resample_destroy(&session->write_resampler);
1406  switch_mutex_unlock(session->resample_mutex);
1407  /* clear indications */
1408  switch_core_session_flush_message(session);
1409 
1410  /* wipe these, they will be recreated if need be */
1411  switch_mutex_lock(session->codec_write_mutex);
1412  switch_buffer_destroy(&session->raw_write_buffer);
1413  switch_mutex_unlock(session->codec_write_mutex);
1414 
1415  switch_mutex_lock(session->codec_read_mutex);
1416  switch_buffer_destroy(&session->raw_read_buffer);
1417  switch_mutex_unlock(session->codec_read_mutex);
1418 
1419  if (flush_dtmf) {
1420  while (switch_channel_has_dtmf(channel)) {
1421  switch_channel_flush_dtmf(channel);
1422  }
1423  }
1424 
1425  switch_clear_flag(session, SSF_WARN_TRANSCODE);
1426  switch_ivr_deactivate_unicast(session);
1427  switch_channel_clear_flag(channel, CF_BREAK);
1428 }
1429 
1430 
1431 SWITCH_DECLARE(switch_channel_t *) switch_core_session_get_channel(switch_core_session_t *session)
1432 {
1433  switch_assert(session->channel);
1434  return session->channel;
1435 }
1436 
1437 SWITCH_DECLARE(switch_mutex_t *) switch_core_session_get_mutex(switch_core_session_t *session)
1438 {
1439  return session->mutex;
1440 }
1441 
1442 SWITCH_DECLARE(switch_status_t) switch_core_session_wake_session_thread(switch_core_session_t *session)
1443 {
1444  switch_status_t status;
1445  int tries = 0;
1446 
1447  /* If trylock fails the signal is already awake so we needn't bother ..... or do we????*/
1448 
1449  top:
1450 
1451  status = switch_mutex_trylock(session->mutex);
1452 
1453  if (status == SWITCH_STATUS_SUCCESS) {
1454  switch_thread_cond_signal(session->cond);
1455  switch_mutex_unlock(session->mutex);
1456  } else {
1457  if (switch_channel_state_thread_trylock(session->channel) == SWITCH_STATUS_SUCCESS) {
1458  /* We've beat them for sure, as soon as we release this lock, they will be checking their queue on the next line. */
1459  switch_channel_set_flag(session->channel, CF_STATE_REPEAT);
1460  switch_channel_state_thread_unlock(session->channel);
1461  } else {
1462  /* What luck! The channel has already started going to sleep *after* we checked if we need to wake it up.
1463  It will miss any messages in its queue because they were inserted after *it* checked its queue. (catch-22)
1464  So, it's not asleep yet, but it's too late for us to be sure they know we want them to stay awake and check its queue again.
1465  Now *we* need to sleep instead but just for 1ms so we can circle back and try again.
1466  This is so rare (yet possible) to happen that we can be fairly certian it will not happen 2x in a row but we'll try 10x just in case.
1467  */
1468  if (++tries < 10) {
1469  switch_cond_next();
1470  goto top;
1471  }
1472  }
1473  }
1474 
1475  return status;
1476 }
1477 
1478 SWITCH_DECLARE(void) switch_core_session_signal_state_change(switch_core_session_t *session)
1479 {
1480  switch_status_t status = SWITCH_STATUS_SUCCESS;
1481  switch_io_event_hook_state_change_t *ptr;
1482 
1483  switch_core_session_wake_session_thread(session);
1484 
1485  if (session->endpoint_interface->io_routines->state_change) {
1486  status = session->endpoint_interface->io_routines->state_change(session);
1487  }
1488 
1489  if (status == SWITCH_STATUS_SUCCESS) {
1490  for (ptr = session->event_hooks.state_change; ptr; ptr = ptr->next) {
1491  if (ptr->state_change(session) != SWITCH_STATUS_SUCCESS) {
1492  break;
1493  }
1494  }
1495  }
1496  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
1497 }
1498 
1499 SWITCH_DECLARE(unsigned int) switch_core_session_running(switch_core_session_t *session)
1500 {
1501  return switch_test_flag(session, SSF_THREAD_RUNNING) ? 1 : 0;
1502 }
1503 
1504 SWITCH_DECLARE(unsigned int) switch_core_session_started(switch_core_session_t *session)
1505 {
1506  return switch_test_flag(session, SSF_THREAD_STARTED) ? 1 : 0;
1507 }
1508 
1509 SWITCH_DECLARE(int) switch_core_session_sync_clock(void)
1510 {
1511  int doit = 0;
1512 
1513  switch_mutex_lock(runtime.session_hash_mutex);
1514  if (session_manager.session_count == 0) {
1515  doit = 1;
1516  } else {
1517  switch_set_flag((&runtime), SCF_SYNC_CLOCK_REQUESTED);
1518  }
1519  switch_mutex_unlock(runtime.session_hash_mutex);
1520 
1521  if (doit) {
1522  switch_time_sync();
1523  }
1524 
1525  return doit;
1526 
1527 }
1528 
1529 SWITCH_DECLARE(void) switch_core_session_perform_destroy(switch_core_session_t **session, const char *file, const char *func, int line)
1530 {
1531  switch_memory_pool_t *pool;
1532  switch_event_t *event;
1533  switch_endpoint_interface_t *endpoint_interface = (*session)->endpoint_interface;
1534  int i;
1535 
1536 
1537  switch_core_session_flush_private_events(*session);
1538 
1539  if (switch_core_session_running(*session) && !switch_test_flag((*session), SSF_DESTROYABLE)) {
1540  switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_core_session_get_uuid(*session), SWITCH_LOG_ERROR,
1541  "Cowardly ignoring an attempt to call destroy on a running session.\n");
1542  }
1543 
1544  switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_core_session_get_uuid(*session), SWITCH_LOG_NOTICE, "Close Channel %s [%s]\n",
1545  switch_channel_get_name((*session)->channel), switch_channel_state_name(switch_channel_get_state((*session)->channel)));
1546 
1547 
1548  if ((*session)->text_buffer) {
1549  switch_buffer_destroy(&(*session)->text_buffer);
1550  }
1551 
1552  if ((*session)->text_line_buffer) {
1553  switch_buffer_destroy(&(*session)->text_line_buffer);
1554  }
1555 
1556  switch_core_session_reset(*session, SWITCH_TRUE, SWITCH_TRUE);
1557 
1558  switch_core_media_bug_remove_all(*session);
1559  switch_ivr_deactivate_unicast(*session);
1560 
1561  switch_scheduler_del_task_group((*session)->uuid_str);
1562 
1563  switch_mutex_lock(runtime.session_hash_mutex);
1564  switch_core_hash_delete(session_manager.session_table, (*session)->uuid_str);
1565  if ((*session)->external_id) {
1566  switch_core_hash_delete(session_manager.session_table, (*session)->external_id);
1567  }
1568  if (session_manager.session_count) {
1569  session_manager.session_count--;
1570  if (session_manager.session_count == 0) {
1571  if (switch_test_flag((&runtime), SCF_SYNC_CLOCK_REQUESTED)) {
1572  switch_time_sync();
1573  switch_clear_flag((&runtime), SCF_SYNC_CLOCK_REQUESTED);
1574  }
1575  }
1576  }
1577  switch_mutex_unlock(runtime.session_hash_mutex);
1578 
1579  if ((*session)->plc) {
1580  switch_plc_free((*session)->plc);
1581  (*session)->plc = NULL;
1582  }
1583 
1584  if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_DESTROY) == SWITCH_STATUS_SUCCESS) {
1585  switch_channel_event_set_data((*session)->channel, event);
1586  switch_event_fire(&event);
1587  }
1588 
1589  switch_core_session_destroy_state(*session);
1590 
1591  switch_buffer_destroy(&(*session)->raw_read_buffer);
1592  switch_buffer_destroy(&(*session)->raw_write_buffer);
1593  switch_ivr_clear_speech_cache(*session);
1594  switch_channel_uninit((*session)->channel);
1595 
1596  for (i = 0; i < 2; i++) {
1597  if ((*session)->dmachine[i]) {
1598  switch_ivr_dmachine_destroy(&(*session)->dmachine[i]);
1599  }
1600  }
1601 
1602  if ((*session)->event_queue) {
1603  void *pop;
1604  while (switch_queue_trypop((*session)->event_queue, &pop) == SWITCH_STATUS_SUCCESS) {
1605  if (pop) {
1606  switch_event_t *event = (switch_event_t *) pop;
1607  switch_event_destroy(&event);
1608  }
1609  }
1610  }
1611 
1612  pool = (*session)->pool;
1613  //#ifndef NDEBUG
1614  //memset(*session, 0, sizeof(switch_core_session_t));
1615  //#endif
1616  *session = NULL;
1617  switch_core_destroy_memory_pool(&pool);
1618 
1619  UNPROTECT_INTERFACE(endpoint_interface);
1620 }
1621 
1622 
1623 
1624 SWITCH_STANDARD_SCHED_FUNC(sch_heartbeat_callback)
1625 {
1626  switch_event_t *event;
1627  switch_core_session_t *session;
1628  char *uuid = task->cmd_arg;
1629  switch_core_session_message_t msg = { 0 };
1630 
1631  if ((session = switch_core_session_locate(uuid))) {
1632  switch_event_create(&event, SWITCH_EVENT_SESSION_HEARTBEAT);
1633  switch_channel_event_set_data(session->channel, event);
1634  switch_event_fire(&event);
1635 
1636  /* reschedule this task */
1637  task->runtime = switch_epoch_time_now(NULL) + session->track_duration;
1638 
1639  msg.message_id = SWITCH_MESSAGE_HEARTBEAT_EVENT;
1640  msg.numeric_arg = session->track_duration;
1641  switch_core_session_receive_message(session, &msg);
1642 
1643  switch_core_session_rwunlock(session);
1644  }
1645 }
1646 
1647 SWITCH_DECLARE(void) switch_core_session_unsched_heartbeat(switch_core_session_t *session)
1648 {
1649  if (session->track_id) {
1650  switch_scheduler_del_task_id(session->track_id);
1651  session->track_id = 0;
1652  }
1653 }
1654 
1655 SWITCH_DECLARE(void) switch_core_session_sched_heartbeat(switch_core_session_t *session, uint32_t seconds)
1656 {
1657  time_t when;
1658 
1659  switch_core_session_unsched_heartbeat(session);
1660  if (switch_true(switch_channel_get_variable(session->channel, "heartbeat_fire_on_set"))) {
1661  when = switch_epoch_time_now(NULL);
1662  } else {
1663  when = switch_epoch_time_now(NULL) + session->track_duration;
1664  }
1665 
1666  session->track_id = switch_scheduler_add_task(when, sch_heartbeat_callback, (char *) __SWITCH_FUNC__,
1667  switch_core_session_get_uuid(session), 0, strdup(switch_core_session_get_uuid(session)), SSHF_FREE_ARG);
1668 }
1669 
1670 SWITCH_DECLARE(void) switch_core_session_enable_heartbeat(switch_core_session_t *session, uint32_t seconds)
1671 {
1672  switch_assert(session != NULL);
1673 
1674  if (!seconds) {
1675  seconds = 60;
1676  }
1677 
1678  session->track_duration = seconds;
1679 
1680  if (switch_channel_test_flag(session->channel, CF_PROXY_MODE) || !switch_channel_media_ready(session->channel) ||
1681  switch_true(switch_channel_get_variable_dup(session->channel, "heartbeat_use_scheduler", SWITCH_FALSE, -1)) ||
1682  switch_true(switch_channel_get_variable_dup(session->channel, "bypass_media", SWITCH_FALSE, -1)) ||
1683  switch_true(switch_channel_get_variable_dup(session->channel, "bypass_media_after_bridge", SWITCH_FALSE, -1))) {
1684  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s using scheduler due to bypass media or media is not established.\n",
1685  switch_channel_get_name(session->channel));
1686  switch_core_session_sched_heartbeat(session, seconds);
1687  return;
1688  }
1689 
1690  if (switch_true(switch_channel_get_variable(session->channel, "heartbeat_fire_on_set"))) {
1691  session->read_frame_count = 0;
1692  } else {
1693  session->read_frame_count = (session->read_impl.samples_per_second / session->read_impl.samples_per_packet) * seconds;
1694  }
1695 
1696  switch_core_session_unsched_heartbeat(session);
1697 
1698  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "%s setting session heartbeat to %u second(s).\n",
1699  switch_channel_get_name(session->channel), seconds);
1700 
1701 }
1702 
1703 SWITCH_DECLARE(void) switch_core_session_disable_heartbeat(switch_core_session_t *session)
1704 {
1705  switch_core_session_unsched_heartbeat(session);
1706  switch_assert(session != NULL);
1707  session->read_frame_count = 0;
1708  session->track_duration = 0;
1709 
1710 }
1711 
1712 SWITCH_DECLARE(switch_bool_t) switch_core_session_in_thread(switch_core_session_t *session)
1713 {
1714  return switch_thread_equal(switch_thread_self(), session->thread_id) ? SWITCH_TRUE : SWITCH_FALSE;
1715 }
1716 
1717 static void *SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread_t *thread, void *obj)
1718 {
1719  switch_core_session_t *session = obj;
1720  switch_event_t *event;
1721  char *event_str = NULL;
1722  const char *val;
1723 
1724  session->thread = thread;
1725  session->thread_id = switch_thread_self();
1726 
1727  switch_core_session_run(session);
1728  switch_core_media_bug_remove_all(session);
1729 
1730  if (session->soft_lock) {
1731  uint32_t loops = session->soft_lock * 10;
1732 
1733  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Session %" SWITCH_SIZE_T_FMT " (%s) Soft-Locked, "
1734  "Waiting %u for external entities\n",
1735  session->id, switch_channel_get_name(session->channel), session->soft_lock);
1736 
1737  while(--loops > 0) {
1738  if (!session->soft_lock) break;
1739  switch_yield(100000);
1740  }
1741 
1742  }
1743 
1744  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Session %" SWITCH_SIZE_T_FMT " (%s) Locked, Waiting on external entities\n",
1745  session->id, switch_channel_get_name(session->channel));
1746  switch_core_session_write_lock(session);
1747  switch_set_flag(session, SSF_DESTROYED);
1748 
1749  if ((val = switch_channel_get_variable(session->channel, "memory_debug")) && switch_true(val)) {
1750  if (switch_event_create(&event, SWITCH_EVENT_GENERAL) == SWITCH_STATUS_SUCCESS) {
1751  switch_channel_event_set_data(session->channel, event);
1752  switch_event_serialize(event, &event_str, SWITCH_FALSE);
1753  switch_assert(event_str);
1754  switch_core_memory_pool_tag(switch_core_session_get_pool(session), switch_core_session_strdup(session, event_str));
1755  free(event_str);
1756  switch_event_destroy(&event);
1757  }
1758  }
1759 
1760  switch_core_session_rwunlock(session);
1761 
1762  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Session %" SWITCH_SIZE_T_FMT " (%s) Ended\n",
1763  session->id, switch_channel_get_name(session->channel));
1764 
1765  switch_set_flag(session, SSF_DESTROYABLE);
1766  switch_core_session_destroy(&session);
1767  return NULL;
1768 }
1769 
1770 typedef struct switch_thread_pool_node_s {
1771  switch_memory_pool_t *pool;
1772 } switch_thread_pool_node_t;
1773 
1774 static void *SWITCH_THREAD_FUNC switch_core_session_thread_pool_worker(switch_thread_t *thread, void *obj)
1775 {
1776  switch_thread_pool_node_t *node = (switch_thread_pool_node_t *) obj;
1777  switch_memory_pool_t *pool = node->pool;
1778 #ifdef DEBUG_THREAD_POOL
1779  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Started\n", (long) (intptr_t) thread);
1780 #endif
1781  for (;;) {
1782  void *pop;
1783  switch_status_t check_status = switch_queue_pop_timeout(session_manager.thread_queue, &pop, 5000000);
1784  if (check_status == SWITCH_STATUS_SUCCESS) {
1785  switch_thread_data_t *td = (switch_thread_data_t *) pop;
1786 
1787 #ifdef DEBUG_THREAD_POOL
1788  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Processing\n", (long) (intptr_t) thread);
1789 #endif
1790  td->running = 1;
1791  td->func(thread, td->obj);
1792  td->running = 0;
1793 
1794  if (td->pool) {
1795  switch_memory_pool_t *pool = td->pool;
1796  td = NULL;
1797  switch_core_destroy_memory_pool(&pool);
1798  } else if (td->alloc) {
1799  free(td);
1800  }
1801 #ifdef DEBUG_THREAD_POOL
1802  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Done Processing\n", (long)(intptr_t) thread);
1803 #endif
1804  switch_mutex_lock(session_manager.mutex);
1805  session_manager.busy--;
1806  switch_mutex_unlock(session_manager.mutex);
1807  } else {
1808  switch_mutex_lock(session_manager.mutex);
1809  if (!switch_status_is_timeup(check_status) || session_manager.running > session_manager.busy) {
1810  if (!--session_manager.running) {
1811  switch_thread_cond_signal(session_manager.cond);
1812  }
1813  switch_mutex_unlock(session_manager.mutex);
1814  break;
1815  }
1816  switch_mutex_unlock(session_manager.mutex);
1817  }
1818  }
1819 #ifdef DEBUG_THREAD_POOL
1820  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Ended\n", (long)(intptr_t) thread);
1821 #endif
1822  switch_core_destroy_memory_pool(&pool);
1823  return NULL;
1824 }
1825 
1826 static void thread_launch_failure(void)
1827 {
1828  uint32_t sess_count;
1829 
1830  switch_mutex_lock(session_manager.mutex);
1831 
1832  sess_count = switch_core_session_count();
1833 
1834  if (sess_count > 110) {
1835 
1836  switch_core_session_limit(sess_count - 10);
1837  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "LUKE: I'm hit, but not bad.\n");
1838  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
1839  "LUKE'S VOICE: Artoo, see what you can do with it. Hang on back there....\n"
1840  "Green laserfire moves past the beeping little robot as his head turns. "
1841  "After a few beeps and a twist of his mechanical arm,\n"
1842  "Artoo reduces the max sessions to %d thus, saving the switch from certain doom.\n", sess_count - 10);
1843 
1844  }
1845 
1846  switch_mutex_unlock(session_manager.mutex);
1847 }
1848 
1849 static switch_status_t check_queue(void)
1850 {
1851  switch_status_t status = SWITCH_STATUS_FALSE;
1852  switch_mutex_lock(session_manager.mutex);
1853  if (session_manager.running >= ++session_manager.busy) {
1854  switch_mutex_unlock(session_manager.mutex);
1855  return SWITCH_STATUS_SUCCESS;
1856  }
1857  ++session_manager.running;
1858  switch_mutex_unlock(session_manager.mutex);
1859 
1860  {
1861  switch_thread_t *thread;
1862  switch_threadattr_t *thd_attr;
1863  switch_memory_pool_t *pool;
1864  switch_thread_pool_node_t *node;
1865 
1866  switch_core_new_memory_pool(&pool);
1867  node = switch_core_alloc(pool, sizeof(*node));
1868  node->pool = pool;
1869 
1870  switch_threadattr_create(&thd_attr, node->pool);
1871  switch_threadattr_detach_set(thd_attr, 1);
1872  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
1873  switch_threadattr_priority_set(thd_attr, SWITCH_PRI_LOW);
1874 
1875  if (switch_thread_create(&thread, thd_attr, switch_core_session_thread_pool_worker, node, node->pool) != SWITCH_STATUS_SUCCESS) {
1876  switch_mutex_lock(session_manager.mutex);
1877  if (!--session_manager.running) {
1878  switch_thread_cond_signal(session_manager.cond);
1879  }
1880  switch_mutex_unlock(session_manager.mutex);
1881  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread Failure!\n");
1882  switch_core_destroy_memory_pool(&pool);
1883  status = SWITCH_STATUS_GENERR;
1884  thread_launch_failure();
1885  } else {
1886  status = SWITCH_STATUS_SUCCESS;
1887  }
1888  }
1889  return status;
1890 }
1891 
1892 
1893 SWITCH_DECLARE(switch_status_t) switch_thread_pool_launch_thread(switch_thread_data_t **tdp)
1894 {
1895  switch_status_t status = SWITCH_STATUS_SUCCESS;
1896  switch_thread_data_t *td;
1897 
1898  switch_assert(tdp);
1899 
1900  td = *tdp;
1901  *tdp = NULL;
1902 
1903  status = switch_queue_push(session_manager.thread_queue, td);
1904  check_queue();
1905 
1906  return status;
1907 }
1908 
1909 SWITCH_DECLARE(switch_status_t) switch_thread_pool_wait(switch_thread_data_t *td, int ms)
1910 {
1911  while(!td->running && --ms > 0) {
1912  switch_cond_next();
1913  }
1914 
1915  return ms > 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_TIMEOUT;
1916 }
1917 
1918 SWITCH_DECLARE(switch_status_t) switch_core_session_thread_pool_launch(switch_core_session_t *session)
1919 {
1920  switch_status_t status = SWITCH_STATUS_INUSE;
1921  switch_thread_data_t *td;
1922 
1923  switch_mutex_lock(session->mutex);
1924  if (switch_test_flag(session, SSF_THREAD_RUNNING)) {
1925  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot double-launch thread!\n");
1926  } else if (switch_test_flag(session, SSF_THREAD_STARTED)) {
1927  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot launch thread again after it has already been run!\n");
1928  } else {
1929  switch_set_flag(session, SSF_THREAD_RUNNING);
1930  switch_set_flag(session, SSF_THREAD_STARTED);
1931  td = switch_core_session_alloc(session, sizeof(*td));
1932  td->obj = session;
1933  td->func = switch_core_session_thread;
1934  status = switch_queue_push(session_manager.thread_queue, td);
1935  check_queue();
1936  }
1937  switch_mutex_unlock(session->mutex);
1938 
1939  return status;
1940 }
1941 
1942 SWITCH_DECLARE(switch_status_t) switch_core_session_thread_launch(switch_core_session_t *session)
1943 {
1944  switch_status_t status = SWITCH_STATUS_FALSE;
1945  switch_thread_t *thread;
1946  switch_threadattr_t *thd_attr;
1947 
1948  if (switch_test_flag(session, SSF_THREAD_RUNNING) || switch_test_flag(session, SSF_THREAD_STARTED)) {
1949  status = SWITCH_STATUS_INUSE;
1950  goto end;
1951  }
1952 
1953 
1954  if (switch_test_flag((&runtime), SCF_SESSION_THREAD_POOL)) {
1955  return switch_core_session_thread_pool_launch(session);
1956  }
1957 
1958  switch_mutex_lock(session->mutex);
1959 
1960  if (switch_test_flag(session, SSF_THREAD_RUNNING)) {
1961  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot double-launch thread!\n");
1962  } else if (switch_test_flag(session, SSF_THREAD_STARTED)) {
1963  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot launch thread again after it has already been run!\n");
1964  } else {
1965  switch_set_flag(session, SSF_THREAD_RUNNING);
1966  switch_set_flag(session, SSF_THREAD_STARTED);
1967 
1968  switch_threadattr_create(&thd_attr, session->pool);
1969  switch_threadattr_detach_set(thd_attr, 1);
1970  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
1971 
1972  if (switch_thread_create(&thread, thd_attr, switch_core_session_thread, session, session->pool) == SWITCH_STATUS_SUCCESS) {
1973  switch_set_flag(session, SSF_THREAD_STARTED);
1974  status = SWITCH_STATUS_SUCCESS;
1975  } else {
1976  switch_clear_flag(session, SSF_THREAD_RUNNING);
1977  switch_clear_flag(session, SSF_THREAD_STARTED);
1978  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot create thread!\n");
1979  thread_launch_failure();
1980  }
1981  }
1982 
1983  switch_mutex_unlock(session->mutex);
1984 
1985  end:
1986 
1987  return status;
1988 }
1989 
1990 SWITCH_DECLARE(const char *) switch_core_session_get_text_buffer(switch_core_session_t *session)
1991 {
1992  const char *buf = NULL;
1993 
1994  if (session->text_buffer) {
1995  switch_mutex_lock(session->text_mutex);
1996  buf = (const char *)switch_core_session_strdup(session, (const char *) switch_buffer_get_head_pointer(session->text_buffer));
1997  switch_mutex_unlock(session->text_mutex);
1998  }
1999 
2000  return buf;
2001 }
2002 
2003 SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session_t *session, switch_thread_start_t func, void *obj)
2004 {
2005  switch_thread_t *thread;
2006  switch_threadattr_t *thd_attr = NULL;
2007  switch_threadattr_create(&thd_attr, session->pool);
2008  switch_threadattr_detach_set(thd_attr, 1);
2009 
2010  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
2011  if (switch_thread_create(&thread, thd_attr, func, obj, session->pool) != SWITCH_STATUS_SUCCESS) {
2012  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot create thread!\n");
2013  thread_launch_failure();
2014  }
2015 
2016 }
2017 
2018 SWITCH_DECLARE(switch_status_t) switch_core_session_set_uuid(switch_core_session_t *session, const char *use_uuid)
2019 {
2020  switch_event_t *event;
2021  switch_core_session_message_t msg = { 0 };
2022  switch_caller_profile_t *profile;
2023 
2024  switch_assert(use_uuid);
2025 
2026  if (!strcmp(use_uuid, session->uuid_str)) {
2027  return SWITCH_STATUS_SUCCESS;
2028  }
2029 
2030 
2031  switch_mutex_lock(runtime.session_hash_mutex);
2032  if (switch_core_hash_find(session_manager.session_table, use_uuid)) {
2033  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Duplicate UUID!\n");
2034  switch_mutex_unlock(runtime.session_hash_mutex);
2035  return SWITCH_STATUS_FALSE;
2036  }
2037 
2038  msg.message_id = SWITCH_MESSAGE_INDICATE_UUID_CHANGE;
2039  msg.from = switch_channel_get_name(session->channel);
2040  msg.string_array_arg[0] = session->uuid_str;
2041  msg.string_array_arg[1] = use_uuid;
2042  switch_core_session_receive_message(session, &msg);
2043 
2044  if ((profile = switch_channel_get_caller_profile(session->channel))) {
2045  profile->uuid = switch_core_strdup(profile->pool, use_uuid);
2046  }
2047 
2048  switch_channel_set_variable(session->channel, "uuid", use_uuid);
2049  switch_channel_set_variable(session->channel, "call_uuid", use_uuid);
2050 
2051  switch_event_create(&event, SWITCH_EVENT_CHANNEL_UUID);
2052  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Old-Unique-ID", session->uuid_str);
2053  switch_core_hash_delete(session_manager.session_table, session->uuid_str);
2054  switch_set_string(session->uuid_str, use_uuid);
2055  switch_core_hash_insert(session_manager.session_table, session->uuid_str, session);
2056  switch_mutex_unlock(runtime.session_hash_mutex);
2057  switch_channel_event_set_data(session->channel, event);
2058  switch_event_fire(&event);
2059 
2060 
2061  return SWITCH_STATUS_SUCCESS;
2062 }
2063 
2064 SWITCH_DECLARE(switch_status_t) switch_core_session_set_external_id(switch_core_session_t *session, const char *use_external_id)
2065 {
2066  switch_assert(use_external_id);
2067 
2068  if (session->external_id && !strcmp(use_external_id, session->external_id)) {
2069  return SWITCH_STATUS_SUCCESS;
2070  }
2071 
2072 
2073  switch_mutex_lock(runtime.session_hash_mutex);
2074  if (strcmp(use_external_id, session->uuid_str) && switch_core_hash_find(session_manager.session_table, use_external_id)) {
2075  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Duplicate External ID!\n");
2076  switch_mutex_unlock(runtime.session_hash_mutex);
2077  return SWITCH_STATUS_FALSE;
2078  }
2079 
2080  switch_channel_set_variable(session->channel, "session_external_id", use_external_id);
2081 
2082  if (session->external_id && strcmp(session->external_id, session->uuid_str)) {
2083  switch_core_hash_delete(session_manager.session_table, session->external_id);
2084  }
2085 
2086  session->external_id = switch_core_session_strdup(session, use_external_id);
2087 
2088  if (strcmp(session->external_id, session->uuid_str)) {
2089  switch_core_hash_insert(session_manager.session_table, session->external_id, session);
2090  }
2091  switch_mutex_unlock(runtime.session_hash_mutex);
2092 
2093  return SWITCH_STATUS_SUCCESS;
2094 }
2095 
2096 static char *xml_find_var(switch_xml_t vars, const char *name)
2097 {
2098  switch_xml_t var;
2099  if ((var = switch_xml_child(vars, name)) && var->txt) {
2100  return var->txt;
2101  }
2102 
2103  return NULL;
2104 }
2105 
2106 static void parse_array(const char *str, uint32_t *array, int32_t array_len)
2107 {
2108  char *p, *v, *dup, *next = NULL;
2109 
2110  if (zstr(str)) {
2111  return;
2112  }
2113 
2114  dup = strdup(str);
2115 
2116  p = dup;
2117  while (p) {
2118  if ((next = strchr(p, ';'))) {
2119  *next++ = '\0';
2120  }
2121 
2122  if ((v = strchr(p, '='))) {
2123  *v++ = '\0';
2124  }
2125 
2126  if (p && v) {
2127  int x = 0, y = 0;
2128 
2129  x = atoi(p);
2130  y = atoi(v);
2131 
2132  if (x < array_len) {
2133  array[x] = y;
2134  }
2135  }
2136 
2137  p = next;
2138 
2139  }
2140 
2141  free(dup);
2142 }
2143 
2144 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request_xml(switch_endpoint_interface_t *endpoint_interface,
2145  switch_memory_pool_t **pool, switch_xml_t xml)
2146 {
2147  switch_core_session_t *session;
2148  switch_channel_t *channel;
2149  switch_xml_t tag, tag2, tag3, vars, callflow;
2150  switch_call_direction_t direction = SWITCH_CALL_DIRECTION_OUTBOUND;
2151  char *flag_str = NULL, *cap_str = NULL, *direction_s = NULL, *uuid = NULL;
2152  uint32_t flags[CF_FLAG_MAX] = { 0 };
2153  uint32_t caps[CC_FLAG_MAX] = { 0 };
2154  int i;
2155 
2156  vars = switch_xml_child(xml, "variables");
2157  uuid = xml_find_var(vars, "uuid");
2158 
2159  if ((tag = switch_xml_child(xml, "channel_data"))) {
2160  direction_s = xml_find_var(tag, "direction");
2161  direction = !strcmp(direction_s, "outbound") ? SWITCH_CALL_DIRECTION_OUTBOUND : SWITCH_CALL_DIRECTION_INBOUND;
2162  flag_str = xml_find_var(tag, "flags");
2163  cap_str = xml_find_var(tag, "caps");
2164  }
2165 
2166  parse_array(flag_str, flags, CF_FLAG_MAX);
2167  parse_array(cap_str, caps, CC_FLAG_MAX);
2168 
2169  flags[CF_RECOVERING] = 0;
2170  flags[CF_RECOVERING_BRIDGE] = 0;
2171  flags[CF_TRACKED] = 0;
2172  flags[CF_TRANSFER] = 0;
2173  flags[CF_ACCEPT_CNG] = 0;
2174  flags[CF_REDIRECT] = 0;
2175  flags[CF_BRIDGED] = 0;
2176  flags[CF_HOLD] = 0;
2177  flags[CF_SERVICE] = 0;
2178  flags[CF_TAGGED] = 0;
2179  flags[CF_WINNER] = 0;
2180  flags[CF_EARLY_OK] = 0;
2181  flags[CF_CONTROLLED] = 0;
2182  flags[CF_SUSPEND] = 0;
2183  flags[CF_EVENT_PARSE] = 0;
2184  flags[CF_GEN_RINGBACK] = 0;
2185  flags[CF_BREAK] = 0;
2186  flags[CF_BROADCAST] = 0;
2187  flags[CF_UNICAST] = 0;
2188  flags[CF_EVENT_LOCK] = 0;
2189  flags[CF_EVENT_LOCK_PRI] = 0;
2190  flags[CF_RESET] = 0;
2191  flags[CF_ORIGINATING] = 0;
2192  flags[CF_STOP_BROADCAST] = 0;
2193  flags[CF_INNER_BRIDGE] = 0;
2194  flags[CF_REQ_MEDIA] = 0;
2195  flags[CF_PAUSE_BUGS] = 0;
2196  flags[CF_DIVERT_EVENTS] = 0;
2197  flags[CF_BLOCK_STATE] = 0;
2198  flags[CF_FS_RTP] = 0;
2199  flags[CF_REPORTING] = 0;
2200  flags[CF_PARK] = 0;
2201  flags[CF_TIMESTAMP_SET] = 0;
2202  flags[CF_ORIGINATOR] = 0;
2203  flags[CF_XFER_ZOMBIE] = 0;
2204  flags[CF_MEDIA_ACK] = 0;
2205  flags[CF_THREAD_SLEEPING] = 0;
2206  flags[CF_DISABLE_RINGBACK] = 0;
2207  flags[CF_NOT_READY] = 0;
2208  flags[CF_SIGNAL_BRIDGE_TTL] = 0;
2209  flags[CF_MEDIA_BRIDGE_TTL] = 0;
2210  flags[CF_BYPASS_MEDIA_AFTER_BRIDGE] = 0;
2211  flags[CF_LEG_HOLDING] = 0;
2212  flags[CF_BROADCAST_DROP_MEDIA] = 0;
2213  flags[CF_EARLY_HANGUP] = 0;
2214  flags[CF_MEDIA_SET] = 0;
2215  flags[CF_CONSUME_ON_ORIGINATE] = 0;
2216  flags[CF_PASSTHRU_PTIME_MISMATCH] = 0;
2217  flags[CF_BRIDGE_NOWRITE] = 0;
2218  flags[CF_RECOVERED] = 0;
2219  flags[CF_JITTERBUFFER] = 0;
2220  flags[CF_JITTERBUFFER_PLC] = 0;
2221  flags[CF_DIALPLAN] = 0;
2222  flags[CF_BLOCK_BROADCAST_UNTIL_MEDIA] = 0;
2223  flags[CF_CNG_PLC] = 0;
2224  flags[CF_ATTENDED_TRANSFER] = 0;
2225  flags[CF_LAZY_ATTENDED_TRANSFER] = 0;
2226  flags[CF_SIGNAL_DATA] = 0;
2227  flags[CF_SIMPLIFY] = 0;
2228  flags[CF_VIDEO_READY] = 0;
2229  flags[CF_VIDEO_DECODED_READ] = 0;
2230 
2231  if (!(session = switch_core_session_request_uuid(endpoint_interface, direction, SOF_NO_LIMITS, pool, uuid))) {
2232  return NULL;
2233  }
2234 
2235  channel = switch_core_session_get_channel(session);
2236 
2237  for (i = 0; i < CF_FLAG_MAX; i++) {
2238  if (flags[i]) {
2239  switch_channel_set_flag_value(channel, i, flags[i]);
2240  }
2241  }
2242 
2243  for (i = 0; i < CC_FLAG_MAX; i++) {
2244  if (caps[i]) {
2245  switch_channel_set_cap_value(channel, i, caps[i]);
2246  }
2247  }
2248 
2249  if ((tag2 = switch_xml_child(xml, "variables"))) {
2250  for (tag = tag2->child; tag; tag = tag->sibling) {
2251  if (tag->name && tag->txt) {
2252  char *p = strdup(tag->txt);
2253  char *val = p;
2254  switch_url_decode(val);
2255  switch_channel_set_variable(channel, tag->name, val);
2256  if (!strcasecmp(tag->name, "channel_name")) {
2257  switch_channel_set_name(channel, val);
2258  }
2259  free(p);
2260  }
2261  }
2262  }
2263 
2264  if ((callflow = switch_xml_child(xml, "callflow"))) {
2265  if ((tag2 = switch_xml_child(callflow, "caller_profile"))) {
2266  switch_caller_profile_t *caller_profile;
2267  char *tmp;
2268 
2269  caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
2270  xml_find_var(tag2, "username"),
2271  xml_find_var(tag2, "dialplan"),
2272  xml_find_var(tag2, "caller_id_name"),
2273  xml_find_var(tag2, "caller_id_number"),
2274  xml_find_var(tag2, "network_addr"),
2275  xml_find_var(tag2, "ani"),
2276  xml_find_var(tag2, "aniii"),
2277  xml_find_var(tag2, "rdnis"),
2278  xml_find_var(tag2, "source"),
2279  xml_find_var(tag2, "context"), xml_find_var(tag2, "destination_number"));
2280 
2281  if ((tmp = xml_find_var(tag2, "callee_id_name"))) {
2282  caller_profile->callee_id_name = switch_core_session_strdup(session, tmp);
2283  }
2284 
2285  if ((tmp = xml_find_var(tag2, "callee_id_number"))) {
2286  caller_profile->callee_id_number = switch_core_session_strdup(session, tmp);
2287  }
2288 
2289  if ((tag3 = switch_xml_child(callflow, "times"))) {
2290  caller_profile->times = (switch_channel_timetable_t *) switch_core_session_alloc(session, sizeof(*caller_profile->times));
2291 
2292  caller_profile->times->resurrected = switch_time_now();
2293 
2294  for (tag3 = tag3->child; tag3; tag3 = tag3->sibling) {
2295  int64_t v;
2296 
2297  if (tag3->name && tag3->txt) {
2298  v = atoll(tag3->txt);
2299  if (!strcmp(tag3->name, "created_time")) {
2300  caller_profile->times->created = v;
2301  } else if (!strcmp(tag3->name, "profile_created_time")) {
2302  caller_profile->times->profile_created = v;
2303  } else if (!strcmp(tag3->name, "progress_time")) {
2304  caller_profile->times->progress = v;
2305  } else if (!strcmp(tag3->name, "progress_media_time")) {
2306  caller_profile->times->progress_media = v;
2307  } else if (!strcmp(tag3->name, "answered_time")) {
2308  caller_profile->times->answered = v;
2309  } else if (!strcmp(tag3->name, "hangup_time")) {
2310  caller_profile->times->hungup = v;
2311  } else if (!strcmp(tag3->name, "transfer_time")) {
2312  caller_profile->times->transferred = v;
2313  }
2314  }
2315 
2316  }
2317  }
2318 
2319  switch_channel_set_caller_profile(channel, caller_profile);
2320  if ((tag = switch_xml_child(tag2, "originator")) && (tag = tag->child)) {
2321  caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
2322  xml_find_var(tag, "username"),
2323  xml_find_var(tag, "dialplan"),
2324  xml_find_var(tag, "caller_id_name"),
2325  xml_find_var(tag, "caller_id_number"),
2326  xml_find_var(tag, "network_addr"),
2327  xml_find_var(tag, "ani"),
2328  xml_find_var(tag, "aniii"),
2329  xml_find_var(tag, "rdnis"),
2330  xml_find_var(tag, "source"),
2331  xml_find_var(tag, "context"), xml_find_var(tag, "destination_number"));
2332 
2333  switch_channel_set_originator_caller_profile(channel, caller_profile);
2334  }
2335 
2336  if ((tag = switch_xml_child(tag2, "originatee")) && (tag = tag->child)) {
2337  caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
2338  xml_find_var(tag, "username"),
2339  xml_find_var(tag, "dialplan"),
2340  xml_find_var(tag, "caller_id_name"),
2341  xml_find_var(tag, "caller_id_number"),
2342  xml_find_var(tag, "network_addr"),
2343  xml_find_var(tag, "ani"),
2344  xml_find_var(tag, "aniii"),
2345  xml_find_var(tag, "rdnis"),
2346  xml_find_var(tag, "source"),
2347  xml_find_var(tag, "context"), xml_find_var(tag, "destination_number"));
2348 
2349  switch_channel_set_originatee_caller_profile(channel, caller_profile);
2350  }
2351 
2352  }
2353 
2354 
2355  switch_channel_set_flag(channel, CF_RECOVERED);
2356  }
2357 
2358 
2359  if (!channel || !switch_channel_get_caller_profile(channel)) {
2360  if (session) {
2361  switch_core_session_destroy(&session);
2362  }
2363  }
2364 
2365 
2366  return session;
2367 }
2368 
2369 
2370 
2371 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request_uuid(switch_endpoint_interface_t
2372  *endpoint_interface,
2373  switch_call_direction_t direction,
2374  switch_originate_flag_t originate_flags,
2375  switch_memory_pool_t **pool, const char *use_uuid)
2376 {
2377  switch_memory_pool_t *usepool;
2378  switch_core_session_t *session;
2379  switch_uuid_t uuid;
2380  uint32_t count = 0;
2381  int32_t sps = 0;
2382 
2383 
2384  if (direction == SWITCH_CALL_DIRECTION_INBOUND && !switch_core_ready_inbound()) {
2385  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The system cannot create any inbound sessions at this time.\n");
2386  return NULL;
2387  }
2388 
2389  if (direction == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_core_ready_outbound()) {
2390  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The system cannot create any outbound sessions at this time.\n");
2391  return NULL;
2392  }
2393 
2394  if (!switch_core_ready() || endpoint_interface == NULL) {
2395  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The system cannot create any sessions at this time.\n");
2396  return NULL;
2397  }
2398 
2399  if (runtime.min_idle_time > 0 && runtime.profile_time < runtime.min_idle_time) {
2400  return NULL;
2401  }
2402 
2403  PROTECT_INTERFACE(endpoint_interface);
2404 
2405  switch_mutex_lock(runtime.session_hash_mutex);
2406  if (use_uuid && switch_core_hash_find(session_manager.session_table, use_uuid)) {
2407  switch_mutex_unlock(runtime.session_hash_mutex);
2408  UNPROTECT_INTERFACE(endpoint_interface);
2409  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Duplicate UUID!\n");
2410 
2411  return NULL;
2412  }
2413 
2414  if (!(originate_flags & SOF_NO_LIMITS)) {
2415  switch_mutex_lock(runtime.throttle_mutex);
2416  count = session_manager.session_count;
2417  sps = --runtime.sps;
2418  switch_mutex_unlock(runtime.throttle_mutex);
2419 
2420  if (sps <= 0) {
2421  switch_mutex_unlock(runtime.session_hash_mutex);
2422  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Throttle Error! %d\n", session_manager.session_count);
2423  UNPROTECT_INTERFACE(endpoint_interface);
2424  return NULL;
2425  }
2426 
2427  if ((count + 1) > session_manager.session_limit) {
2428  switch_mutex_unlock(runtime.session_hash_mutex);
2429  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Over Session Limit! %d\n", session_manager.session_limit);
2430  UNPROTECT_INTERFACE(endpoint_interface);
2431  return NULL;
2432  }
2433  }
2434 
2435 
2436  if (pool && *pool) {
2437  usepool = *pool;
2438  *pool = NULL;
2439  } else {
2440  switch_core_new_memory_pool(&usepool);
2441  }
2442 
2443  session = switch_core_alloc(usepool, sizeof(*session));
2444  session->pool = usepool;
2445 
2446  switch_core_memory_pool_set_data(session->pool, "__session", session);
2447 
2448  if (switch_channel_alloc(&session->channel, direction, session->pool) != SWITCH_STATUS_SUCCESS) {
2449  abort();
2450  }
2451 
2452  switch_channel_init(session->channel, session, CS_NEW, 0);
2453 
2454  if (direction == SWITCH_CALL_DIRECTION_OUTBOUND) {
2455  switch_channel_set_flag(session->channel, CF_OUTBOUND);
2456  }
2457 
2458  /* The session *IS* the pool you may not alter it because you have no idea how
2459  its all private it will be passed to the thread run function */
2460 
2461  if (use_uuid) {
2462  switch_set_string(session->uuid_str, use_uuid);
2463  } else {
2464  switch_uuid_get(&uuid);
2465  switch_uuid_format(session->uuid_str, &uuid);
2466  }
2467 
2468  switch_channel_set_variable(session->channel, "uuid", session->uuid_str);
2469  switch_channel_set_variable(session->channel, "call_uuid", session->uuid_str);
2470 
2471  session->endpoint_interface = endpoint_interface;
2472  session->raw_write_frame.data = session->raw_write_buf;
2473  session->raw_write_frame.buflen = sizeof(session->raw_write_buf);
2474  session->raw_read_frame.data = session->raw_read_buf;
2475  session->raw_read_frame.buflen = sizeof(session->raw_read_buf);
2476 
2477 
2478  session->enc_write_frame.data = session->enc_write_buf;
2479  session->enc_write_frame.buflen = sizeof(session->enc_write_buf);
2480  session->enc_read_frame.data = session->enc_read_buf;
2481  session->enc_read_frame.buflen = sizeof(session->enc_read_buf);
2482 
2483  switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED, session->pool);
2484  switch_mutex_init(&session->stack_count_mutex, SWITCH_MUTEX_NESTED, session->pool);
2485  switch_mutex_init(&session->resample_mutex, SWITCH_MUTEX_NESTED, session->pool);
2486  switch_mutex_init(&session->codec_init_mutex, SWITCH_MUTEX_NESTED, session->pool);
2487  switch_mutex_init(&session->codec_read_mutex, SWITCH_MUTEX_NESTED, session->pool);
2488  switch_mutex_init(&session->codec_write_mutex, SWITCH_MUTEX_NESTED, session->pool);
2489  switch_mutex_init(&session->frame_read_mutex, SWITCH_MUTEX_NESTED, session->pool);
2490  switch_thread_rwlock_create(&session->bug_rwlock, session->pool);
2491  switch_thread_cond_create(&session->cond, session->pool);
2492  switch_thread_rwlock_create(&session->rwlock, session->pool);
2493  switch_thread_rwlock_create(&session->io_rwlock, session->pool);
2494  switch_queue_create(&session->message_queue, SWITCH_MESSAGE_QUEUE_LEN, session->pool);
2495  switch_queue_create(&session->signal_data_queue, SWITCH_MESSAGE_QUEUE_LEN, session->pool);
2496  switch_queue_create(&session->event_queue, SWITCH_EVENT_QUEUE_LEN, session->pool);
2497  switch_queue_create(&session->private_event_queue, SWITCH_EVENT_QUEUE_LEN, session->pool);
2498  switch_queue_create(&session->private_event_queue_pri, SWITCH_EVENT_QUEUE_LEN, session->pool);
2499 
2500  switch_core_hash_insert(session_manager.session_table, session->uuid_str, session);
2501  session->id = session_manager.session_id++;
2502  session_manager.session_count++;
2503 
2504  if (session_manager.session_count > (uint32_t)runtime.sessions_peak) {
2505  runtime.sessions_peak = session_manager.session_count;
2506  }
2507  if (session_manager.session_count > (uint32_t)runtime.sessions_peak_fivemin) {
2508  runtime.sessions_peak_fivemin = session_manager.session_count;
2509  }
2510 
2511  switch_mutex_unlock(runtime.session_hash_mutex);
2512 
2513  switch_channel_set_variable_printf(session->channel, "session_id", "%u", session->id);
2514 
2515  return session;
2516 }
2517 
2518 SWITCH_DECLARE(uint32_t) switch_core_session_count(void)
2519 {
2520  return session_manager.session_count;
2521 }
2522 
2523 SWITCH_DECLARE(switch_size_t) switch_core_session_get_id(switch_core_session_t *session)
2524 {
2525  return session->id;
2526 }
2527 
2528 SWITCH_DECLARE(switch_size_t) switch_core_session_id_dec(void)
2529 {
2530  switch_mutex_lock(runtime.session_hash_mutex);
2531  session_manager.session_id--;
2532  switch_mutex_unlock(runtime.session_hash_mutex);
2533  return session_manager.session_id;
2534 }
2535 
2536 SWITCH_DECLARE(switch_size_t) switch_core_session_id(void)
2537 {
2538  return session_manager.session_id;
2539 }
2540 
2541 
2542 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request_by_name(const char *endpoint_name,
2543  switch_call_direction_t direction, switch_memory_pool_t **pool)
2544 {
2545  switch_endpoint_interface_t *endpoint_interface;
2546  switch_core_session_t *session;
2547 
2548  if ((endpoint_interface = switch_loadable_module_get_endpoint_interface(endpoint_name)) == 0) {
2549  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not locate channel type %s\n", endpoint_name);
2550  return NULL;
2551  }
2552 
2553  session = switch_core_session_request(endpoint_interface, direction, SOF_NONE, pool);
2554 
2555  UNPROTECT_INTERFACE(endpoint_interface);
2556 
2557  return session;
2558 }
2559 
2560 #ifndef SWITCH_PREFIX_DIR
2561 #define SWITCH_PREFIX_DIR "."
2562 #endif
2563 
2564 SWITCH_DECLARE(uint8_t) switch_core_session_compare(switch_core_session_t *a, switch_core_session_t *b)
2565 {
2566  switch_assert(a != NULL);
2567  switch_assert(b != NULL);
2568 
2569  return (uint8_t) (a->endpoint_interface == b->endpoint_interface);
2570 }
2571 
2572 SWITCH_DECLARE(uint8_t) switch_core_session_check_interface(switch_core_session_t *session, const switch_endpoint_interface_t *endpoint_interface)
2573 {
2574  switch_assert(session != NULL);
2575  switch_assert(endpoint_interface != NULL);
2576 
2577  return (uint8_t) (session->endpoint_interface == endpoint_interface);
2578 }
2579 
2580 SWITCH_DECLARE(char *) switch_core_session_get_uuid(switch_core_session_t *session)
2581 {
2582  if (!session) return NULL;
2583  return session->uuid_str;
2584 }
2585 
2586 SWITCH_DECLARE(const char *) switch_core_session_get_external_id(switch_core_session_t *session)
2587 {
2588  if (!session) return NULL;
2589  return session->external_id;
2590 }
2591 
2592 SWITCH_DECLARE(uint32_t) switch_core_session_limit(uint32_t new_limit)
2593 {
2594  if (new_limit) {
2595  session_manager.session_limit = new_limit;
2596  }
2597 
2598  return session_manager.session_limit;
2599 }
2600 
2601 SWITCH_DECLARE(double) switch_core_min_idle_cpu(double new_limit)
2602 {
2603  if (new_limit >= 0) {
2604  runtime.min_idle_time = new_limit;
2605  }
2606 
2607  return runtime.min_idle_time;
2608 }
2609 
2610 
2611 SWITCH_DECLARE(double) switch_core_idle_cpu(void)
2612 {
2613  return runtime.profile_time;
2614 }
2615 
2616 SWITCH_DECLARE(uint32_t) switch_core_sessions_per_second(uint32_t new_limit)
2617 {
2618  if (new_limit) {
2619  runtime.sps_total = new_limit;
2620  }
2621 
2622  return runtime.sps_total;
2623 }
2624 
2625 void switch_core_session_init(switch_memory_pool_t *pool)
2626 {
2627  memset(&session_manager, 0, sizeof(session_manager));
2628  session_manager.session_limit = 1000;
2629  session_manager.session_id = 1;
2630  session_manager.memory_pool = pool;
2631  switch_core_hash_init(&session_manager.session_table);
2632  switch_mutex_init(&session_manager.mutex, SWITCH_MUTEX_DEFAULT, session_manager.memory_pool);
2633  switch_thread_cond_create(&session_manager.cond, session_manager.memory_pool);
2634  switch_queue_create(&session_manager.thread_queue, 100000, session_manager.memory_pool);
2635 }
2636 
2637 void switch_core_session_uninit(void)
2638 {
2639  switch_queue_term(session_manager.thread_queue);
2640  switch_mutex_lock(session_manager.mutex);
2641  if (session_manager.running)
2642  switch_thread_cond_timedwait(session_manager.cond, session_manager.mutex, 10000000);
2643  switch_mutex_unlock(session_manager.mutex);
2644  switch_core_hash_destroy(&session_manager.session_table);
2645 }
2646 
2647 SWITCH_DECLARE(switch_app_log_t *) switch_core_session_get_app_log(switch_core_session_t *session)
2648 {
2649  return session->app_log;
2650 }
2651 
2652 SWITCH_DECLARE(switch_status_t) switch_core_session_get_app_flags(const char *app, int32_t *flags)
2653 {
2654  switch_application_interface_t *application_interface;
2655  switch_status_t status = SWITCH_STATUS_FALSE;
2656 
2657  switch_assert(flags);
2658 
2659  *flags = 0;
2660 
2661  if ((application_interface = switch_loadable_module_get_application_interface(app)) == 0) {
2662  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Application %s\n", app);
2663  goto end;
2664  } else if (application_interface->flags) {
2665  *flags = application_interface->flags;
2666  status = SWITCH_STATUS_SUCCESS;
2667  }
2668 
2669  UNPROTECT_INTERFACE(application_interface);
2670 
2671  end:
2672 
2673  return status;
2674 
2675 }
2676 
2677 SWITCH_DECLARE(switch_status_t) switch_core_session_execute_application_async(switch_core_session_t *session, const char *app, const char *arg)
2678 {
2679  switch_event_t *execute_event;
2680  char *ap, *arp;
2681 
2682  if (!arg && strstr(app, "::")) {
2683  ap = switch_core_session_strdup(session, app);
2684  app = ap;
2685 
2686  if ((arp = strstr(ap, "::"))) {
2687  *arp = '\0';
2688  arg = arp + 2;
2689  }
2690  }
2691 
2692  if (switch_event_create(&execute_event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
2693  switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "call-command", "execute");
2694  switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "execute-app-name", app);
2695 
2696  if (arg) {
2697  switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "execute-app-arg", arg);
2698  }
2699 
2700  if (!switch_channel_test_flag(session->channel, CF_PROXY_MODE)) {
2701  switch_channel_set_flag(session->channel, CF_BLOCK_BROADCAST_UNTIL_MEDIA);
2702  }
2703 
2704  switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "event-lock", "true");
2705  switch_core_session_queue_private_event(session, &execute_event, SWITCH_FALSE);
2706 
2707  return SWITCH_STATUS_SUCCESS;
2708  }
2709 
2710  return SWITCH_STATUS_FALSE;
2711 }
2712 
2713 SWITCH_DECLARE(void) switch_core_session_video_reset(switch_core_session_t *session)
2714 {
2715  switch_channel_clear_flag(session->channel, CF_VIDEO_ECHO);
2716  switch_channel_clear_flag(session->channel, CF_VIDEO_PASSIVE);
2717  //switch_channel_clear_flag(session->channel, CF_VIDEO_DECODED_READ);
2718  switch_channel_clear_flag(session->channel, CF_VIDEO_DEBUG_READ);
2719  switch_channel_clear_flag(session->channel, CF_VIDEO_DEBUG_WRITE);
2720  switch_channel_clear_flag(session->channel, CF_VIDEO_BLANK);
2721  switch_core_session_request_video_refresh(session);
2722 }
2723 
2724 SWITCH_DECLARE(switch_status_t) switch_core_session_execute_application_get_flags(switch_core_session_t *session, const char *app,
2725  const char *arg, int32_t *flags)
2726 {
2727  switch_application_interface_t *application_interface;
2728  switch_status_t status = SWITCH_STATUS_SUCCESS;
2729 
2730  switch_core_session_request_video_refresh(session);
2731  switch_core_media_gen_key_frame(session);
2732 
2733  if (switch_channel_down_nosig(session->channel)) {
2734  char *p;
2735  if (!arg && (p = strstr(app, "::"))) {
2736  *p++ = '0';
2737  *p++ = '0';
2738  arg = p;
2739 
2740  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s ASYNC CALL CONVERTED TO INLINE %s(%s)\n",
2741  switch_channel_get_name(session->channel), app, switch_str_nil(arg));
2742  }
2743 
2744  if ((application_interface = switch_loadable_module_get_application_interface(app)) == 0) {
2745  return SWITCH_STATUS_FALSE;
2746  }
2747 
2748  if (switch_test_flag(application_interface, SAF_ZOMBIE_EXEC)) {
2749  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s ZOMBIE EXEC %s(%s)\n",
2750  switch_channel_get_name(session->channel), app, switch_str_nil(arg));
2751  goto exec;
2752  }
2753 
2754  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
2755  "%s Channel is hungup and application '%s' does not have the zombie_exec flag.\n",
2756  switch_channel_get_name(session->channel), app);
2757 
2758  switch_goto_status(SWITCH_STATUS_IGNORE, done);
2759  }
2760 
2761  if (!arg && strstr(app, "::")) {
2762  return switch_core_session_execute_application_async(session, app, arg);
2763  }
2764 
2765  if ((application_interface = switch_loadable_module_get_application_interface(app)) == 0) {
2766  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Application %s\n", app);
2767  switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
2768  switch_goto_status(SWITCH_STATUS_FALSE, done);
2769  }
2770 
2771  if (!application_interface->application_function) {
2772  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No Function for %s\n", app);
2773  switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
2774  switch_goto_status(SWITCH_STATUS_FALSE, done);
2775  }
2776 
2777  if (flags && application_interface->flags) {
2778  *flags = application_interface->flags;
2779  }
2780 
2781  if (!switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA) && (switch_channel_test_flag(session->channel, CF_VIDEO))) {
2782  switch_core_session_request_video_refresh(session);
2783  }
2784 
2785  if (switch_channel_test_flag(session->channel, CF_PROXY_MODE) && !switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA)) {
2786  switch_ivr_media(session->uuid_str, SMF_NONE);
2787  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Application %s Requires media on channel %s!\n",
2788  app, switch_channel_get_name(session->channel));
2789  } else if (!switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA) && !switch_channel_media_ready(session->channel)) {
2790  if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
2791  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Application %s Requires media! pre_answering channel %s\n",
2792  app, switch_channel_get_name(session->channel));
2793  if (switch_channel_pre_answer(session->channel) != SWITCH_STATUS_SUCCESS) {
2794  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Well, that didn't work very well did it? ...\n");
2795  switch_goto_status(SWITCH_STATUS_FALSE, done);
2796  }
2797  } else {
2798  uint32_t ready = 0, sanity = 2000;
2799 
2800  do {
2801  sanity--;
2802  ready = switch_channel_media_up(session->channel);
2803  switch_cond_next();
2804  } while(!ready && sanity);
2805 
2806  if (!ready) {
2807  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
2808  "Cannot execute app '%s' media required on an outbound channel that does not have media established\n", app);
2809  switch_goto_status(SWITCH_STATUS_FALSE, done);
2810  }
2811  }
2812  }
2813 
2814  if (switch_channel_text_only(session->channel) &&
2815  !switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA) &&
2816  !switch_test_flag(application_interface, SAF_SUPPORT_TEXT_ONLY)) {
2817  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Application %s does not support text-only mode on channel %s!\n",
2818  app, switch_channel_get_name(session->channel));
2819  switch_channel_hangup(session->channel, SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED);
2820  switch_goto_status(SWITCH_STATUS_FALSE, done);
2821  }
2822 
2823  exec:
2824 
2825  switch_core_session_exec(session, application_interface, arg);
2826 
2827  done:
2828 
2829  UNPROTECT_INTERFACE(application_interface);
2830 
2831  return status;
2832 }
2833 
2834 SWITCH_DECLARE(switch_status_t) switch_core_session_exec(switch_core_session_t *session,
2835  const switch_application_interface_t *application_interface, const char *arg)
2836 {
2837  switch_app_log_t *log, *lp;
2838  switch_event_t *event;
2839  const char *var;
2840  switch_channel_t *channel = switch_core_session_get_channel(session);
2841  char *expanded = NULL;
2842  const char *app, *app_uuid_var, *app_uuid_name;
2843  switch_core_session_message_t msg = { 0 };
2844  char delim = ',';
2845  int scope = 0;
2846  char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
2847  char *app_uuid = uuid_str;
2848  switch_bool_t expand_variables = !switch_true(switch_channel_get_variable(session->channel, "app_disable_expand_variables"));
2849 
2850  if ((app_uuid_var = switch_channel_get_variable(channel, "app_uuid"))) {
2851  app_uuid = (char *)app_uuid_var;
2852  switch_channel_set_variable(channel, "app_uuid", NULL);
2853  } else {
2854  switch_uuid_str(uuid_str, sizeof(uuid_str));
2855  }
2856 
2857  if((app_uuid_name = switch_channel_get_variable(channel, "app_uuid_name"))) {
2858  switch_channel_set_variable(channel, "app_uuid_name", NULL);
2859  }
2860 
2861  switch_assert(application_interface);
2862 
2863  app = application_interface->interface_name;
2864 
2865  if (arg) {
2866  if (expand_variables) {
2867  expanded = switch_channel_expand_variables(session->channel, arg);
2868  } else {
2869  expanded = (char *)arg;
2870  }
2871  }
2872 
2873  if (expand_variables && expanded && *expanded == '%' && (*(expanded+1) == '[' || *(expanded+2) == '[')) {
2874  char *p, *dup;
2875  switch_event_t *ovars = NULL;
2876 
2877  p = expanded + 1;
2878 
2879  if (*p != '[') {
2880  delim = *p;
2881  p++;
2882  }
2883 
2884  dup = strdup(p);
2885 
2886  if (expanded != arg) {
2887  switch_safe_free(expanded);
2888  }
2889 
2890  switch_event_create_brackets(dup, '[', ']', delim, &ovars, &expanded, SWITCH_TRUE);
2891  free(dup);
2892 
2893  switch_channel_set_scope_variables(session->channel, &ovars);
2894  scope = 1;
2895  }
2896 
2897 
2898  if ( switch_core_test_flag(SCF_DIALPLAN_TIMESTAMPS) ) {
2899  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "EXECUTE [depth=%d] %s %s(%s)\n",
2900  switch_core_session_stack_count(session, 0), switch_channel_get_name(session->channel), app, switch_str_nil(expanded));
2901  } else {
2902  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(session), SWITCH_LOG_INFO, "EXECUTE [depth=%d] %s %s(%s)\n",
2903  switch_core_session_stack_count(session, 0), switch_channel_get_name(session->channel), app, switch_str_nil(expanded));
2904  }
2905 
2906  if ((var = switch_channel_get_variable(session->channel, "verbose_presence")) && switch_true(var)) {
2907  char *myarg = NULL;
2908  if (expanded) {
2909  myarg = switch_mprintf("%s(%s)", app, expanded);
2910  } else if (!zstr(arg)) {
2911  myarg = switch_mprintf("%s(%s)", app, arg);
2912  } else {
2913  myarg = switch_mprintf("%s", app);
2914  }
2915  if (myarg) {
2916  switch_channel_presence(session->channel, "unknown", myarg, NULL);
2917  switch_safe_free(myarg);
2918  }
2919  }
2920 
2921  if (!(var = switch_channel_get_variable(session->channel, SWITCH_DISABLE_APP_LOG_VARIABLE)) || (!(switch_true(var)))) {
2922  log = switch_core_session_alloc(session, sizeof(*log));
2923 
2924  log->app = switch_core_session_strdup(session, application_interface->interface_name);
2925  if (expanded) {
2926  log->arg = switch_core_session_strdup(session, expanded);
2927  }
2928 
2929  log->stamp = switch_time_now();
2930 
2931  for (lp = session->app_log; lp && lp->next; lp = lp->next);
2932 
2933  if (lp) {
2934  lp->next = log;
2935  } else {
2936  session->app_log = log;
2937  }
2938  }
2939 
2940  switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_VARIABLE, application_interface->interface_name);
2941  switch_channel_set_variable_var_check(channel, SWITCH_CURRENT_APPLICATION_DATA_VARIABLE, expanded, SWITCH_FALSE);
2942  switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, NULL);
2943 
2944  if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
2945  switch_channel_event_set_data(session->channel, event);
2946  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", application_interface->interface_name);
2947  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Data", expanded);
2948  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID", app_uuid);
2949  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID-Name", app_uuid_name);
2950  switch_event_fire(&event);
2951  }
2952 
2953  switch_channel_clear_flag(session->channel, CF_BREAK);
2954 
2955  switch_assert(application_interface->application_function);
2956 
2957  switch_channel_set_variable(session->channel, SWITCH_CURRENT_APPLICATION_VARIABLE, application_interface->interface_name);
2958 
2959  msg.from = __FILE__;
2960  msg.message_id = SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC;
2961  msg.string_array_arg[0] = application_interface->interface_name;
2962  msg.string_array_arg[1] = expanded;
2963  switch_core_session_receive_message(session, &msg);
2964 
2965  application_interface->application_function(session, expanded);
2966 
2967  if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE) == SWITCH_STATUS_SUCCESS) {
2968  const char *resp = switch_channel_get_variable(session->channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE);
2969  switch_channel_event_set_data(session->channel, event);
2970  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", application_interface->interface_name);
2971  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Data", expanded);
2972  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Response", resp ? resp : "_none_");
2973  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID", app_uuid);
2974  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID-Name", app_uuid_name);
2975  switch_event_fire(&event);
2976  }
2977 
2978  msg.message_id = SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC_COMPLETE;
2979  switch_core_session_receive_message(session, &msg);
2980 
2981  if (expanded != arg) {
2982  switch_safe_free(expanded);
2983  }
2984 
2985  if (scope) {
2986  switch_channel_set_scope_variables(session->channel, NULL);
2987  }
2988 
2989  return SWITCH_STATUS_SUCCESS;
2990 }
2991 
2992 SWITCH_DECLARE(uint32_t) switch_core_session_stack_count(switch_core_session_t *session, int x)
2993 {
2994  uint32_t stack_count = 0;
2995  switch_mutex_lock(session->stack_count_mutex);
2996  if (x > 0) session->stack_count++;
2997  else if (x < 0) session->stack_count--;
2998 
2999  stack_count = session->stack_count;
3000  switch_mutex_unlock(session->stack_count_mutex);
3001  return stack_count;
3002 }
3003 
3004 SWITCH_DECLARE(switch_status_t) switch_core_session_execute_exten(switch_core_session_t *session, const char *exten, const char *dialplan,
3005  const char *context)
3006 {
3007  char *dp[25];
3008  char *dpstr;
3009  int argc, x;
3010  uint32_t stack_count = 0;
3011  switch_caller_profile_t *profile, *new_profile, *pp = NULL;
3012  switch_channel_t *channel = switch_core_session_get_channel(session);
3013  switch_dialplan_interface_t *dialplan_interface = NULL;
3014  switch_caller_extension_t *extension = NULL;
3015  switch_status_t status = SWITCH_STATUS_SUCCESS;
3016 
3017  if (!(profile = switch_channel_get_caller_profile(channel))) {
3018  return SWITCH_STATUS_FALSE;
3019  }
3020 
3021  if ((stack_count = switch_core_session_stack_count(session, 0)) > SWITCH_MAX_STACKS) {
3022  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error %s too many stacked extensions [depth=%d]\n",
3023  switch_channel_get_name(session->channel), stack_count);
3024  return SWITCH_STATUS_FALSE;
3025  }
3026 
3027  switch_core_session_stack_count(session, 1);
3028 
3029  new_profile = switch_caller_profile_clone(session, profile);
3030  new_profile->destination_number = switch_core_strdup(new_profile->pool, exten);
3031  new_profile->times = (switch_channel_timetable_t *) switch_core_session_alloc(session, sizeof(*new_profile->times));
3032  *new_profile->times = *profile->times;
3033 
3034 
3035  if (!zstr(dialplan)) {
3036  new_profile->dialplan = switch_core_strdup(new_profile->pool, dialplan);
3037  }
3038 
3039  if (!zstr(context)) {
3040  new_profile->context = switch_core_strdup(new_profile->pool, context);
3041  }
3042 
3043  dpstr = switch_core_session_strdup(session, new_profile->dialplan);
3044 
3045  switch_channel_set_hunt_caller_profile(channel, new_profile);
3046  argc = switch_separate_string(dpstr, ',', dp, (sizeof(dp) / sizeof(dp[0])));
3047  for (x = 0; x < argc; x++) {
3048  char *dpname = dp[x];
3049  char *dparg = NULL;
3050 
3051  if (dpname) {
3052  if ((dparg = strchr(dpname, ':'))) {
3053  *dparg++ = '\0';
3054  }
3055  } else {
3056  continue;
3057  }
3058 
3059  if (!(dialplan_interface = switch_loadable_module_get_dialplan_interface(dpname))) {
3060  continue;
3061  }
3062 
3063  extension = dialplan_interface->hunt_function(session, dparg, new_profile);
3064  UNPROTECT_INTERFACE(dialplan_interface);
3065 
3066  if (extension) {
3067  break;
3068  }
3069  }
3070 
3071  if (!extension) {
3072  status = SWITCH_STATUS_FALSE;
3073  goto done;
3074  }
3075 
3076  new_profile->caller_extension = extension;
3077 
3078  if (profile->caller_extension) {
3079  for (pp = profile->caller_extension->children; pp && pp->next; pp = pp->next);
3080 
3081  if (pp) {
3082  pp->next = new_profile;
3083  } else {
3084  profile->caller_extension->children = new_profile;
3085  }
3086  }
3087 
3088  while (switch_channel_ready(channel) && extension->current_application) {
3089  switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Execute [depth=%d] %s(%s)\n",
3090  switch_core_session_stack_count(session, 0),
3091  extension->current_application->application_name, switch_str_nil(extension->current_application->application_data));
3092 
3093  if (switch_core_session_execute_application(session,
3094  extension->current_application->application_name,
3095  extension->current_application->application_data) != SWITCH_STATUS_SUCCESS) {
3096  goto done;
3097  }
3098 
3099  extension->current_application = extension->current_application->next;
3100  }
3101 
3102  done:
3103  switch_channel_set_hunt_caller_profile(channel, NULL);
3104 
3105  switch_core_session_stack_count(session, -1);
3106  return status;
3107 }
3108 
3109 SWITCH_DECLARE(switch_status_t) switch_core_session_set_loglevel(switch_core_session_t *session, switch_log_level_t loglevel)
3110 {
3111  switch_assert(session != NULL);
3112  session->loglevel = loglevel;
3113  return SWITCH_STATUS_SUCCESS;
3114 }
3115 
3116 SWITCH_DECLARE(switch_log_level_t) switch_core_session_get_loglevel(switch_core_session_t *session)
3117 {
3118  switch_assert(session != NULL);
3119  return session->loglevel;
3120 }
3121 
3122 SWITCH_DECLARE(void) switch_core_session_debug_pool(switch_stream_handle_t *stream)
3123 {
3124  stream->write_function(stream, "Thread pool: running:%d busy:%d popping:%d\n",
3125  session_manager.running, session_manager.busy, session_manager.running - session_manager.busy);
3126 }
3127 
3128 SWITCH_DECLARE(void) switch_core_session_raw_read(switch_core_session_t *session)
3129 {
3130  if (session->sdata) {
3131  if (session->sdata && switch_core_codec_ready(&session->sdata->codec)) {
3132  switch_core_codec_destroy(&session->sdata->codec);
3133  }
3134  memset(session->sdata, 0, sizeof(*session->sdata));
3135  } else {
3136  session->sdata = switch_core_session_alloc(session, sizeof(*session->sdata));
3137  }
3138 
3139  switch_core_session_set_codec_slin(session, session->sdata);
3140 }
3141 
3142 SWITCH_DECLARE(switch_status_t) switch_core_session_override_io_routines(switch_core_session_t *session, switch_io_routines_t *ior)
3143 {
3144  if (session->endpoint_interface && switch_channel_test_cap(session->channel, CC_IO_OVERRIDE)) {
3145  session->io_override = ior;
3146  return SWITCH_STATUS_SUCCESS;
3147  }
3148 
3149  return SWITCH_STATUS_FALSE;
3150 }
3151 
3152 
3153 /* For Emacs:
3154  * Local Variables:
3155  * mode:c
3156  * indent-tabs-mode:t
3157  * tab-width:4
3158  * c-basic-offset:4
3159  * End:
3160  * For VIM:
3161  * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
3162  */
switch_channel_set_variable_printf
switch_status_t switch_channel_set_variable_printf(switch_channel_t *channel, const char *varname, const char *fmt,...)
Definition: switch_channel.c:1595
switch_xml::sibling
switch_xml_t sibling
Definition: switch_xml.h:93
switch_core_session::codec_init_mutex
switch_mutex_t * codec_init_mutex
Definition: switch_core_pvt.h:115
SCF_SYNC_CLOCK_REQUESTED
Definition: switch_types.h:382
switch_channel_set_cap_value
void switch_channel_set_cap_value(switch_channel_t *channel, switch_channel_cap_t cap, uint32_t value)
Definition: switch_channel.c:1854
__SWITCH_FUNC__
#define __SWITCH_FUNC__
Definition: switch_platform.h:51
switch_core_session_findall
switch_console_callback_match_t * switch_core_session_findall(void)
Definition: switch_core_session.c:417
switch_core_sessions_per_second
uint32_t switch_core_sessions_per_second(uint32_t new_limit)
Definition: switch_core_session.c:2616
CF_LEG_HOLDING
Definition: switch_types.h:1513
CF_MEDIA_ACK
Definition: switch_types.h:1506
CF_FS_RTP
Definition: switch_types.h:1500
CF_VIDEO
Definition: switch_types.h:1487
switch_app_log::stamp
switch_time_t stamp
Definition: switch_core.h:62
CF_PASSTHRU_PTIME_MISMATCH
Definition: switch_types.h:1518
switch_channel_get_state
switch_channel_state_t switch_channel_get_state(switch_channel_t *channel)
Get the current state of a channel in the state engine.
Definition: switch_channel.c:2235
switch_event_fire
#define switch_event_fire(event)
Fire an event filling in most of the arguements with obvious values.
Definition: switch_event.h:413
switch_channel_hangup
#define switch_channel_hangup(channel, hangup_cause)
Hangup a channel flagging it&#39;s state machine to end.
Definition: switch_channel.h:589
switch_core_media_gen_key_frame
#define switch_core_media_gen_key_frame(_session)
Definition: switch_core_media.h:347
switch_time_sync
void switch_time_sync(void)
Definition: switch_time.c:609
switch_queue_size
unsigned int switch_queue_size(switch_queue_t *queue)
Definition: switch_apr.c:1238
switch_core_session_set_dmachine
void switch_core_session_set_dmachine(switch_core_session_t *session, switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)
Definition: switch_core_session.c:44
SWITCH_MUTEX_DEFAULT
#define SWITCH_MUTEX_DEFAULT
Definition: switch_apr.h:317
switch_core_new_memory_pool
#define switch_core_new_memory_pool(p)
Create a new sub memory pool from the core&#39;s master pool.
Definition: switch_core.h:633
switch_io_routines::get_jb
switch_io_get_jb_t get_jb
Definition: switch_module_interfaces.h:172
switch_application_interface
A module interface to implement an application.
Definition: switch_module_interfaces.h:788
switch_core_session_request_uuid
switch_core_session_t * switch_core_session_request_uuid(switch_endpoint_interface_t *endpoint_interface, switch_call_direction_t direction, switch_originate_flag_t originate_flags, switch_memory_pool_t **pool, const char *use_uuid)
Definition: switch_core_session.c:2371
session_manager
struct switch_session_manager session_manager
Definition: switch_core_session.c:42
switch_core_session_sprintf
char * switch_core_session_sprintf(_In_ switch_core_session_t *session, _In_z_ _Printf_format_string_ const char *fmt,...)
printf-style style printing routine. The data is output to a string allocated from the session ...
switch_xml::name
char * name
Definition: switch_xml.h:81
switch_thread_cond_create
switch_status_t switch_thread_cond_create(switch_thread_cond_t **cond, switch_memory_pool_t *pool)
Definition: switch_apr.c:373
switch_core_session::write_resampler
switch_audio_resampler_t * write_resampler
Definition: switch_core_pvt.h:110
switch_core_session_get_private_class
void * switch_core_session_get_private_class(switch_core_session_t *session, switch_pvt_class_t index)
Definition: switch_core_session.c:481
switch_true
static switch_bool_t switch_true(const char *expr)
Evaluate the truthfullness of a string expression.
Definition: switch_utils.h:519
switch_session_manager::session_count
uint32_t session_count
Definition: switch_core_pvt.h:298
SWITCH_CHANNEL_SESSION_LOG
#define SWITCH_CHANNEL_SESSION_LOG(x)
Definition: switch_types.h:1334
switch_caller_extension
An Abstract Representation of a dialplan extension.
Definition: switch_caller.h:149
switch_core_session::event_queue
switch_queue_t * event_queue
Definition: switch_core_pvt.h:129
switch_core_session_message::_func
const char * _func
Definition: switch_core.h:209
switch_caller_profile
Call Specific Data.
Definition: switch_caller.h:73
switch_core_session::bug_rwlock
switch_thread_rwlock_t * bug_rwlock
Definition: switch_core_pvt.h:134
switch_set_flag
#define switch_set_flag(obj, flag)
Set a flag on an arbitrary object.
Definition: switch_utils.h:700
switch_scheduler_del_task_group
uint32_t switch_scheduler_del_task_group(const char *group)
Delete a scheduled task based on the group name.
Definition: switch_scheduler.c:313
switch_core_session_dequeue_event
switch_status_t switch_core_session_dequeue_event(switch_core_session_t *session, switch_event_t **event, switch_bool_t force)
Definition: switch_core_session.c:1247
CF_REDIRECT
Definition: switch_types.h:1469
SWITCH_THREAD_FUNC
#define SWITCH_THREAD_FUNC
Definition: switch_platform.h:203
SWITCH_ORIGINATOR_VARIABLE
#define SWITCH_ORIGINATOR_VARIABLE
Definition: switch_types.h:205
str_node::next
struct str_node * next
Definition: switch_core_session.c:208
switch_core_session_add_stream
int switch_core_session_add_stream(switch_core_session_t *session, void *private_info)
Definition: switch_core_session.c:504
CF_VIDEO_DEBUG_READ
Definition: switch_types.h:1593
switch_core_session_message::message_id
switch_core_session_message_types_t message_id
Definition: switch_core.h:183
switch_channel_alloc
switch_status_t switch_channel_alloc(_In_ switch_channel_t **channel, _In_ switch_call_direction_t direction, _In_ switch_memory_pool_t *pool)
Allocate a new channel.
switch_core_session_set_codec_slin
switch_status_t switch_core_session_set_codec_slin(switch_core_session_t *session, switch_slin_data_t *data)
Definition: switch_core_session.c:87
SWITCH_CHANNEL_LOG
#define SWITCH_CHANNEL_LOG
Definition: switch_types.h:1330
switch_io_event_hook_outgoing_channel::next
struct switch_io_event_hook_outgoing_channel * next
Definition: switch_core_event_hook.h:70
SWITCH_CAUSE_SUCCESS
Definition: switch_types.h:2223
SWITCH_TRUE
Definition: switch_types.h:439
switch_mutex_trylock
switch_status_t switch_mutex_trylock(switch_mutex_t *lock)
Definition: switch_apr.c:318
switch_core_hash_destroy
switch_status_t switch_core_hash_destroy(_Inout_ switch_hash_t **hash)
Destroy an existing hash table.
SWITCH_CALL_DIRECTION_INBOUND
Definition: switch_types.h:304
switch_core_hash_find
void * switch_core_hash_find(_In_ switch_hash_t *hash, _In_z_ const char *key)
Retrieve data from a given hash.
SWITCH_EVENT_CHANNEL_EXECUTE
Definition: switch_types.h:2081
switch_core_session::raw_read_buf
uint8_t raw_read_buf[SWITCH_RECOMMENDED_BUFFER_SIZE]
Definition: switch_core_pvt.h:148
SSF_THREAD_RUNNING
Definition: switch_core_pvt.h:77
switch_core_session_pass_indication
switch_status_t switch_core_session_pass_indication(switch_core_session_t *session, switch_core_session_message_types_t indication)
Definition: switch_core_session.c:1010
SWITCH_MESSAGE_HEARTBEAT_EVENT
Definition: switch_types.h:1171
switch_event_del_header
#define switch_event_del_header(_e, _h)
Definition: switch_event.h:212
message_names
static const char * message_names[]
Definition: switch_core_session.c:778
CC_FLAG_MAX
Definition: switch_types.h:1458
CF_VIDEO_ECHO
Definition: switch_types.h:1580
switch_endpoint_interface
Abstraction of an module endpoint interface This is the glue between the abstract idea of a "channel"...
Definition: switch_module_interfaces.h:182
switch_core_session_get_external_id
const char * switch_core_session_get_external_id(switch_core_session_t *session)
Definition: switch_core_session.c:2586
switch_core_session::codec_write_mutex
switch_mutex_t * codec_write_mutex
Definition: switch_core_pvt.h:117
switch_ivr_process_indications
switch_status_t switch_ivr_process_indications(switch_core_session_t *session, switch_core_session_message_t *message)
Definition: switch_ivr.c:813
switch_channel_get_partner_uuid
const char * switch_channel_get_partner_uuid(switch_channel_t *channel)
Definition: switch_channel.c:4864
switch_core_test_flag
int switch_core_test_flag(int flag)
Definition: switch_core.c:1792
switch_core_hash_init
#define switch_core_hash_init(_hash)
Definition: switch_core.h:1431
switch_channel_cause2str
const char * switch_channel_cause2str(_In_ switch_call_cause_t cause)
return a cause string for a given cause
switch_runtime::sps_total
uint32_t sps_total
Definition: switch_core_pvt.h:245
switch_core_session::enc_read_frame
switch_frame_t enc_read_frame
Definition: switch_core_pvt.h:147
SWITCH_MAX_STACKS
#define SWITCH_MAX_STACKS
Definition: switch_types.h:583
fspr_threadattr_t
Definition: switch_apr.c:648
str_node
Definition: switch_core_session.c:206
switch_channel_get_partner_uuid_copy
const char * switch_channel_get_partner_uuid_copy(switch_channel_t *channel, char *buf, switch_size_t blen)
Definition: switch_channel.c:4845
CF_BRIDGED
Definition: switch_types.h:1470
switch_core_session::id
switch_size_t id
Definition: switch_core_pvt.h:91
switch_core_pvt.h
SWITCH_EVENT_COMMAND
Definition: switch_types.h:2137
SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE
Definition: switch_types.h:2082
switch_channel_timetable::created
switch_time_t created
Definition: switch_channel.h:45
switch_channel_flush_dtmf
void switch_channel_flush_dtmf(_In_ switch_channel_t *channel)
switch_session_manager::thread_queue
switch_queue_t * thread_queue
Definition: switch_core_pvt.h:301
switch_core_session::raw_write_buffer
switch_buffer_t * raw_write_buffer
Definition: switch_core_pvt.h:139
MESSAGE_STRING_ARG_MAX
#define MESSAGE_STRING_ARG_MAX
Definition: switch_core.h:177
switch_core_session::stack_count_mutex
switch_mutex_t * stack_count_mutex
Definition: switch_core_pvt.h:113
CF_SIGNAL_DATA
Definition: switch_types.h:1529
switch_core_session_message::numeric_arg
int numeric_arg
Definition: switch_core.h:186
SWITCH_STATUS_INUSE
Definition: switch_types.h:1244
CF_SIMPLIFY
Definition: switch_types.h:1530
switch_session_manager::running
int running
Definition: switch_core_pvt.h:304
switch_queue_pop_timeout
switch_status_t switch_queue_pop_timeout(switch_queue_t *queue, void **data, switch_interval_time_t timeout)
Definition: switch_apr.c:1248
SCSMF_DYNAMIC
Definition: switch_types.h:1320
CF_CONFIRM_BLIND_TRANSFER
Definition: switch_types.h:1543
SWITCH_EVENT_CHANNEL_DESTROY
Definition: switch_types.h:2075
SSF_DESTROYABLE
Definition: switch_core_pvt.h:82
switch_call_direction_t
switch_call_direction_t
Definition: switch_types.h:303
CF_TRACKED
Definition: switch_types.h:1549
CF_JITTERBUFFER
Definition: switch_types.h:1521
SWITCH_LOG_INFO
Definition: switch_types.h:1290
SWITCH_MESSAGE_INDICATE_DISPLAY
Definition: switch_types.h:1135
switch_core_session::codec_read_mutex
switch_mutex_t * codec_read_mutex
Definition: switch_core_pvt.h:116
switch_core_session_unsched_heartbeat
void switch_core_session_unsched_heartbeat(switch_core_session_t *session)
Definition: switch_core_session.c:1647
switch_channel_event_set_data
void switch_channel_event_set_data(_In_ switch_channel_t *channel, _In_ switch_event_t *event)
Add information about a given channel to an event object.
SWITCH_EVENT_PRIVATE_COMMAND
Definition: switch_types.h:2121
switch_xml::child
switch_xml_t child
Definition: switch_xml.h:97
switch_pvt_class_t
switch_pvt_class_t
Definition: switch_types.h:258
switch_core_session_get_video_read_codec
switch_codec_t * switch_core_session_get_video_read_codec(_In_ switch_core_session_t *session)
Retrieve the video_read codec from a given session.
switch_bool_t
switch_bool_t
Definition: switch_types.h:437
CF_VIDEO_READY
Definition: switch_types.h:1596
switch_core_session_get_mutex
switch_mutex_t * switch_core_session_get_mutex(switch_core_session_t *session)
Signal a session&#39;s state machine thread that a state change has occured.
Definition: switch_core_session.c:1437
switch_io_event_hook_state_change
Node in which to store state change callback hooks.
Definition: switch_core_event_hook.h:151
switch_event_create_brackets
switch_status_t switch_event_create_brackets(char *data, char a, char b, char c, switch_event_t **event, char **new_data, switch_bool_t dup)
Definition: switch_event.c:1664
switch_channel_presence
#define switch_channel_presence(_a, _b, _c, _d)
Definition: switch_channel.h:190
CF_ANSWERED
Definition: switch_types.h:1462
switch_core_session_message_send
switch_status_t switch_core_session_message_send(const char *uuid_str, switch_core_session_message_t *message)
Definition: switch_core_session.c:440
switch_core_strdup
#define switch_core_strdup(_pool, _todup)
Copy a string using memory allocation from a given pool.
Definition: switch_core.h:733
SWITCH_MESSAGE_INDICATE_TRANSFER
Definition: switch_types.h:1120
switch_core_session_set_read_codec
switch_status_t switch_core_session_set_read_codec(_In_ switch_core_session_t *session, switch_codec_t *codec)
Assign the read codec to a given session.
CF_PROXY_MEDIA
Definition: switch_types.h:1493
b
const cJSON *const b
Definition: switch_cJSON.h:243
switch_io_event_hook_receive_message
Node in which to store custom receive message callback hooks.
Definition: switch_core_event_hook.h:74
switch_core_session_init
void switch_core_session_init(switch_memory_pool_t *pool)
Definition: switch_core_session.c:2625
SCF_SESSION_THREAD_POOL
Definition: switch_types.h:386
switch_slin_data
Definition: switch_module_interfaces.h:869
SWITCH_MESSAGE_INDICATE_NOMEDIA
Definition: switch_types.h:1125
switch_core_session::external_id
const char * external_id
Definition: switch_core_pvt.h:172
switch_caller_profile::uuid
char * uuid
Definition: switch_caller.h:113
switch_core_session_check_interface
uint8_t switch_core_session_check_interface(switch_core_session_t *session, const switch_endpoint_interface_t *endpoint_interface)
Checks if a session is using a specific endpoint.
Definition: switch_core_session.c:2572
switch_core_session_sync_clock
int switch_core_session_sync_clock(void)
Definition: switch_core_session.c:1509
switch_threadattr_stacksize_set
switch_status_t switch_threadattr_stacksize_set(switch_threadattr_t *attr, switch_size_t stacksize)
Definition: switch_apr.c:683
switch_core_session_raw_read
void switch_core_session_raw_read(switch_core_session_t *session)
Definition: switch_core_session.c:3128
switch_core_media_bug_flush_all
switch_status_t switch_core_media_bug_flush_all(_In_ switch_core_session_t *session)
Flush the read/write buffers for all media bugs on the session.
switch_io_event_hook_receive_event::next
struct switch_io_event_hook_receive_event * next
Definition: switch_core_event_hook.h:84
switch_core_destroy_memory_pool
#define switch_core_destroy_memory_pool(p)
Returns a subpool back to the main pool.
Definition: switch_core.h:642
pool
switch_memory_pool_t * pool
Definition: switch_channel.c:50
CS_NEW
Definition: switch_types.h:1381
switch_ivr_dmachine_set_target
void switch_ivr_dmachine_set_target(switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)
Definition: switch_ivr_async.c:104
switch_event
Representation of an event.
Definition: switch_event.h:80
SWITCH_MESSAGE_REDIRECT_AUDIO
Definition: switch_types.h:1113
switch_codec2str
#define switch_codec2str(codec, buf, len)
Definition: switch_utils.h:293
switch_channel_ready
#define switch_channel_ready(_channel)
Definition: switch_channel.h:84
switch_endpoint_interface::io_routines
switch_io_routines_t * io_routines
Definition: switch_module_interfaces.h:187
switch_core_session::streams
void * streams[SWITCH_MAX_STREAMS]
Definition: switch_core_pvt.h:124
CF_WANT_RTT
Definition: switch_types.h:1620
CF_VIDEO_PASSIVE
Definition: switch_types.h:1577
switch_core_session_request_xml
switch_core_session_t * switch_core_session_request_xml(switch_endpoint_interface_t *endpoint_interface, switch_memory_pool_t **pool, switch_xml_t xml)
Definition: switch_core_session.c:2144
switch_event_header
An event Header.
Definition: switch_event.h:65
switch_thread_data_s::running
int running
Definition: switch_core.h:70
switch_core_session_request_by_name
switch_core_session_t * switch_core_session_request_by_name(const char *endpoint_name, switch_call_direction_t direction, switch_memory_pool_t **pool)
Definition: switch_core_session.c:2542
switch_core_session_read_lock
switch_status_t switch_core_session_read_lock(_In_ switch_core_session_t *session)
Acquire a read lock on the session.
switch_core_session_free_message
void switch_core_session_free_message(switch_core_session_message_t **message)
Definition: switch_core_session.c:1070
switch_queue_trypop
switch_status_t switch_queue_trypop(switch_queue_t *queue, void **data)
Definition: switch_apr.c:1264
switch_core_session_message_types_t
switch_core_session_message_types_t
Possible types of messages for inter-session communication.
Definition: switch_types.h:1112
switch_caller_profile_clone
switch_caller_profile_t * switch_caller_profile_clone(_In_ switch_core_session_t *session, _In_ switch_caller_profile_t *tocopy)
Clone an existing caller profile object.
switch_digit_action_target_t
switch_digit_action_target_t
Definition: switch_types.h:283
switch_caller_profile::context
const char * context
Definition: switch_caller.h:115
switch_core_session::stack_count
uint32_t stack_count
Definition: switch_core_pvt.h:137
switch_channel_set_caller_profile
void switch_channel_set_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
Set the given channel&#39;s caller profile.
Definition: switch_channel.c:2863
switch_io_routines::receive_event
switch_io_receive_event_t receive_event
Definition: switch_module_interfaces.h:158
CF_BRIDGE_NOWRITE
Definition: switch_types.h:1519
CF_FLAG_MAX
Definition: switch_types.h:1636
switch_core_session_set_private_class
switch_status_t switch_core_session_set_private_class(switch_core_session_t *session, void *private_info, switch_pvt_class_t index)
Definition: switch_core_session.c:492
switch_core_session
Definition: switch_core_pvt.h:86
switch_channel_media_ready
#define switch_channel_media_ready(_channel)
Definition: switch_channel.h:85
SWITCH_CODEC_FLAG_ENCODE
Definition: switch_types.h:1753
switch_thread_pool_wait
switch_status_t switch_thread_pool_wait(switch_thread_data_t *td, int ms)
Definition: switch_core_session.c:1909
parse_array
static void parse_array(const char *str, uint32_t *array, int32_t array_len)
Definition: switch_core_session.c:2106
switch_thread_cond_timedwait
switch_status_t switch_thread_cond_timedwait(switch_thread_cond_t *cond, switch_mutex_t *mutex, switch_interval_time_t timeout)
Definition: switch_apr.c:383
SWITCH_MESSAGE_INDICATE_RINGING
Definition: switch_types.h:1121
switch_core_session_perform_receive_message
switch_status_t switch_core_session_perform_receive_message(switch_core_session_t *session, switch_core_session_message_t *message, const char *file, const char *func, int line)
Definition: switch_core_session.c:843
CC_IO_OVERRIDE
Definition: switch_types.h:1453
check_queue
static switch_status_t check_queue(void)
Definition: switch_core_session.c:1849
switch_io_event_hook_receive_event::receive_event
switch_receive_event_hook_t receive_event
Definition: switch_core_event_hook.h:83
switch_core_session_queue_indication
switch_status_t switch_core_session_queue_indication(switch_core_session_t *session, switch_core_session_message_types_t indication)
Definition: switch_core_session.c:1030
SWITCH_MESSAGE_INDICATE_DEFLECT
Definition: switch_types.h:1133
CF_ACCEPT_CNG
Definition: switch_types.h:1468
switch_core_session_wake_session_thread
switch_status_t switch_core_session_wake_session_thread(switch_core_session_t *session)
Definition: switch_core_session.c:1442
switch_core_session_debug_pool
void switch_core_session_debug_pool(switch_stream_handle_t *stream)
Definition: switch_core_session.c:3122
switch_hup_type_t
switch_hup_type_t
Definition: switch_core.h:985
switch_thread_data_s::alloc
int alloc
Definition: switch_core.h:69
switch_core_session::read_impl
switch_codec_implementation_t read_impl
Definition: switch_core_pvt.h:103
SWITCH_MESSAGE_INDICATE_HOLD
Definition: switch_types.h:1127
switch_xml
A representation of an XML tree.
Definition: switch_xml.h:79
SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT
Definition: switch_types.h:1132
switch_thread_data_s::pool
switch_memory_pool_t * pool
Definition: switch_core.h:71
switch_core_codec_destroy
switch_status_t switch_core_codec_destroy(switch_codec_t *codec)
Destroy an initalized codec handle.
Definition: switch_core_codec.c:917
switch_caller_profile::next
struct switch_caller_profile * next
Definition: switch_caller.h:128
switch_dialplan_interface
Abstract interface to a dialplan module.
Definition: switch_module_interfaces.h:266
switch_runtime::throttle_mutex
switch_mutex_t * throttle_mutex
Definition: switch_core_pvt.h:241
SWITCH_MESSAGE_INDICATE_UNHOLD
Definition: switch_types.h:1128
switch_channel_get_variable_dup
const char * switch_channel_get_variable_dup(switch_channel_t *channel, const char *varname, switch_bool_t dup, int idx)
Retrieve a variable from a given channel.
Definition: switch_channel.c:973
switch_core_session_message::string_array_arg
const char * string_array_arg[MESSAGE_STRING_ARG_MAX]
Definition: switch_core.h:211
switch_core_session_thread
static void *SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread_t *thread, void *obj)
Definition: switch_core_session.c:1717
switch_channel_state_name
const char * switch_channel_state_name(_In_ switch_channel_state_t state)
Render the name of the provided state enum.
switch_core_session_get_app_log
switch_app_log_t * switch_core_session_get_app_log(switch_core_session_t *session)
Definition: switch_core_session.c:2647
switch_originate_flag_t
uint32_t switch_originate_flag_t
Definition: switch_types.h:335
switch_core_session::signal_data_queue
switch_queue_t * signal_data_queue
Definition: switch_core_pvt.h:131
CF_UNICAST
Definition: switch_types.h:1486
switch_caller_profile_new
switch_caller_profile_t * switch_caller_profile_new(_In_ switch_memory_pool_t *pool, _In_opt_z_ const char *username, _In_opt_z_ const char *dialplan, _In_opt_z_ const char *caller_id_name, _In_opt_z_ const char *caller_id_number, _In_opt_z_ const char *network_addr, _In_opt_z_ const char *ani, _In_opt_z_ const char *aniii, _In_opt_z_ const char *rdnis, _In_opt_z_ const char *source, _In_opt_z_ const char *context, _In_opt_z_ const char *destination_number)
Create a new caller profile object.
switch_caller_profile::dialplan
const char * dialplan
Definition: switch_caller.h:77
switch_core_session_execute_exten
switch_status_t switch_core_session_execute_exten(switch_core_session_t *session, const char *exten, const char *dialplan, const char *context)
Definition: switch_core_session.c:3004
SWITCH_EVENT_CHANNEL_UUID
Definition: switch_types.h:2094
switch_core_session_set_external_id
switch_status_t switch_core_session_set_external_id(switch_core_session_t *session, const char *use_external_id)
Definition: switch_core_session.c:2064
CF_TRANSFER
Definition: switch_types.h:1467
switch_io_routines
A table of i/o routines that an endpoint interface can implement.
Definition: switch_module_interfaces.h:144
SSF_WARN_TRANSCODE
Definition: switch_core_pvt.h:74
switch_ivr_media
switch_status_t switch_ivr_media(const char *uuid, switch_media_flag_t flags)
Signal a session to request direct media access to it&#39;s remote end.
Definition: switch_ivr.c:1773
CF_INNER_BRIDGE
Definition: switch_types.h:1494
switch_core_session_execute_application_async
switch_status_t switch_core_session_execute_application_async(switch_core_session_t *session, const char *app, const char *arg)
Definition: switch_core_session.c:2677
switch_resample_destroy
void switch_resample_destroy(switch_audio_resampler_t **resampler)
Destroy an existing resampler handle.
Definition: switch_resample.c:108
thread
static switch_thread_t * thread
Definition: switch_log.c:486
switch_caller_application::application_data
char * application_data
Definition: switch_caller.h:142
switch_jb_s
Definition: switch_jitterbuffer.c:84
switch_snprintf
int switch_snprintf(_Out_z_cap_(len) char *buf, _In_ switch_size_t len, _In_z_ _Printf_format_string_ const char *format,...)
switch_session_manager::busy
int busy
Definition: switch_core_pvt.h:305
runtime
struct switch_runtime runtime
Definition: switch_core.c:86
switch_core_session_started
unsigned int switch_core_session_started(switch_core_session_t *session)
Definition: switch_core_session.c:1504
switch_channel_test_flag
uint32_t switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flag)
Test for presence of given flag on a given channel.
Definition: switch_channel.c:1677
SWITCH_CALL_DIRECTION_OUTBOUND
Definition: switch_types.h:305
CF_TIMESTAMP_SET
Definition: switch_types.h:1503
switch_core_session_hupall
void switch_core_session_hupall(switch_call_cause_t cause)
Definition: switch_core_session.c:378
switch_scheduler_add_task
uint32_t switch_scheduler_add_task(time_t task_runtime, switch_scheduler_func_t func, const char *desc, const char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags)
Schedule a task in the future.
Definition: switch_scheduler.c:211
SWITCH_MESSAGE_INVALID
Definition: switch_types.h:1174
switch_core_session_soft_lock
void switch_core_session_soft_lock(switch_core_session_t *session, uint32_t sec)
Definition: switch_core_session.c:77
SWITCH_MESSAGE_INDICATE_BROADCAST
Definition: switch_types.h:1131
SHT_UNANSWERED
Definition: switch_core.h:987
switch_io_event_hook_receive_event
Node in which to store custom receive message callback hooks.
Definition: switch_core_event_hook.h:81
switch_session_manager::cond
switch_thread_cond_t * cond
Definition: switch_core_pvt.h:303
SWITCH_LOG_WARNING
Definition: switch_types.h:1292
switch_channel_set_scope_variables
void switch_channel_set_scope_variables(switch_channel_t *channel, switch_event_t **event)
Definition: switch_channel.c:928
switch_slin_data::session
switch_core_session_t * session
Definition: switch_module_interfaces.h:870
switch_status_is_timeup
SWITCH_BEGIN_EXTERN_C int switch_status_is_timeup(int status)
Definition: switch_apr.c:95
switch_core_session::text_buffer
switch_buffer_t * text_buffer
Definition: switch_core_pvt.h:169
switch_frame::codec
switch_codec_t * codec
Definition: switch_frame.h:56
switch_application_interface::interface_name
const char * interface_name
Definition: switch_module_interfaces.h:790
switch_core_session_message
A message object designed to allow unlike technologies to exchange data.
Definition: switch_core.h:179
switch_channel_set_origination_caller_profile
void switch_channel_set_origination_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
Set the given channel&#39;s origination caller profile.
Definition: switch_channel.c:2961
switch_frame::data
void * data
Definition: switch_frame.h:66
switch_core_session_findall_matching_var
switch_console_callback_match_t * switch_core_session_findall_matching_var(const char *var_name, const char *var_val)
Definition: switch_core_session.c:289
SWITCH_DISABLE_APP_LOG_VARIABLE
#define SWITCH_DISABLE_APP_LOG_VARIABLE
Definition: switch_types.h:232
switch_core_session::media_handle
switch_media_handle_t * media_handle
Definition: switch_core_pvt.h:160
SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE
#define SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE
Definition: switch_types.h:204
switch_channel_timetable::hungup
switch_time_t hungup
Definition: switch_channel.h:49
zstr
#define zstr(x)
Definition: switch_utils.h:314
switch_core_session_get_read_codec
switch_codec_t * switch_core_session_get_read_codec(_In_ switch_core_session_t *session)
Retrieve the read codec from a given session.
switch_core_session_id
switch_size_t switch_core_session_id(void)
Provide the current session_id.
Definition: switch_core_session.c:2536
switch_caller_application::next
struct switch_caller_application * next
Definition: switch_caller.h:145
switch_core_session_perform_get_partner
switch_status_t switch_core_session_perform_get_partner(switch_core_session_t *session, switch_core_session_t **partner, const char *file, const char *func, int line)
Get the session&#39;s partner (the session its bridged to)
Definition: switch_core_session.c:189
switch_core_session_hupall_matching_var_ans
uint32_t switch_core_session_hupall_matching_var_ans(const char *var_name, const char *var_val, switch_call_cause_t cause, switch_hup_type_t type)
Definition: switch_core_session.c:273
switch_core_session_message::_file
const char * _file
Definition: switch_core.h:208
switch_core_session_get_channel
switch_channel_t * switch_core_session_get_channel(switch_core_session_t *session)
Definition: switch_core_session.c:1431
switch_core_session::event_hooks
switch_io_event_hooks_t event_hooks
Definition: switch_core_pvt.h:95
switch_xml::txt
char * txt
Definition: switch_xml.h:85
CF_PROXY_OFF
Definition: switch_types.h:1479
switch_mutex_unlock
switch_status_t switch_mutex_unlock(switch_mutex_t *lock)
Definition: switch_apr.c:313
SWITCH_MESSAGE_QUEUE_LEN
#define SWITCH_MESSAGE_QUEUE_LEN
Definition: switch_core_pvt.h:66
switch_core_session_get_read_impl
switch_status_t switch_core_session_get_read_impl(switch_core_session_t *session, switch_codec_implementation_t *impp)
Definition: switch_core_codec.c:325
switch_core_session_execute_application
#define switch_core_session_execute_application(_a, _b, _c)
Execute an application on a session.
Definition: switch_core.h:1129
switch_core_recovery_track
void switch_core_recovery_track(switch_core_session_t *session)
Definition: switch_core_sqldb.c:3415
switch_core_session_compare
uint8_t switch_core_session_compare(switch_core_session_t *a, switch_core_session_t *b)
Checks if 2 sessions are using the same endpoint module.
Definition: switch_core_session.c:2564
switch_channel_timetable
Definition: switch_channel.h:43
switch_thread_pool_node_s
Definition: switch_core_session.c:1770
UNPROTECT_INTERFACE
#define UNPROTECT_INTERFACE(_it)
Definition: switch_module_interfaces.h:865
SWITCH_EVENT_CLONE
Definition: switch_types.h:2073
SWITCH_ORIGINATOR_CODEC_VARIABLE
#define SWITCH_ORIGINATOR_CODEC_VARIABLE
Definition: switch_types.h:206
switch_runtime::sessions_peak
int32_t sessions_peak
Definition: switch_core_pvt.h:250
switch_clear_flag
#define switch_clear_flag(obj, flag)
Clear a flag on an arbitrary object while locked.
Definition: switch_utils.h:724
switch_io_event_hook_receive_message::receive_message
switch_receive_message_hook_t receive_message
Definition: switch_core_event_hook.h:75
SSF_DESTROYED
Definition: switch_core_pvt.h:73
SWITCH_MUTEX_NESTED
#define SWITCH_MUTEX_NESTED
Definition: switch_apr.h:318
switch_core_session_reset
void switch_core_session_reset(switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
Definition: switch_core_session.c:1391
CF_TAGGED
Definition: switch_types.h:1474
switch_plc_free
int switch_plc_free(switch_plc_state_t *s)
Definition: switch_spandsp.c:42
switch_core_session::private_event_queue
switch_queue_t * private_event_queue
Definition: switch_core_pvt.h:132
xml_find_var
static char * xml_find_var(switch_xml_t vars, const char *name)
Definition: switch_core_session.c:2096
SAF_SUPPORT_NOMEDIA
Definition: switch_types.h:1707
switch_core_session_enable_heartbeat
void switch_core_session_enable_heartbeat(switch_core_session_t *session, uint32_t seconds)
Definition: switch_core_session.c:1670
switch_ivr_dmachine
Definition: switch_ivr_async.c:63
switch_core_session_get_app_flags
switch_status_t switch_core_session_get_app_flags(const char *app, int32_t *flags)
Definition: switch_core_session.c:2652
switch_threadattr_detach_set
switch_status_t switch_threadattr_detach_set(switch_threadattr_t *attr, int32_t on)
Definition: switch_apr.c:678
switch_codec::implementation
const switch_codec_implementation_t * implementation
Definition: switch_module_interfaces.h:704
switch_core_idle_cpu
double switch_core_idle_cpu(void)
Definition: switch_core_session.c:2611
switch_core_session::private_info
void * private_info[SWITCH_CORE_SESSION_MAX_PRIVATES]
Definition: switch_core_pvt.h:128
switch_frame::buflen
uint32_t buflen
Definition: switch_frame.h:70
switch_runtime::sessions_peak_fivemin
int32_t sessions_peak_fivemin
Definition: switch_core_pvt.h:251
buf
switch_byte_t switch_byte_t * buf
Definition: switch_bitpack.h:76
SWITCH_PROCESS_CDR_VARIABLE
#define SWITCH_PROCESS_CDR_VARIABLE
Definition: switch_types.h:179
CF_REPORTING
Definition: switch_types.h:1501
switch_core_session_private_event_count
uint32_t switch_core_session_private_event_count(switch_core_session_t *session)
Definition: switch_core_session.c:1293
SWITCH_LOG_NOTICE
Definition: switch_types.h:1291
CF_BLOCK_BROADCAST_UNTIL_MEDIA
Definition: switch_types.h:1525
switch_yield
#define switch_yield(ms)
Wait a desired number of microseconds and yield the CPU.
Definition: switch_utils.h:998
switch_core_session_message::string_arg
const char * string_arg
Definition: switch_core.h:188
switch_separate_string
unsigned int switch_separate_string(_In_ char *buf, char delim, _Post_count_(return) char **array, unsigned int arraylen)
Separate a string into an array based on a character delimiter.
SWITCH_STATUS_GENERR
Definition: switch_types.h:1243
switch_core_session::channel
switch_channel_t * channel
Definition: switch_core_pvt.h:93
switch_core_session_thread_pool_launch
switch_status_t switch_core_session_thread_pool_launch(switch_core_session_t *session)
Definition: switch_core_session.c:1918
SSF_THREAD_STARTED
Definition: switch_core_pvt.h:76
switch_core_session::read_resampler
switch_audio_resampler_t * read_resampler
Definition: switch_core_pvt.h:109
switch_dialplan_interface::hunt_function
switch_dialplan_hunt_function_t hunt_function
Definition: switch_module_interfaces.h:270
switch_frame::datalen
uint32_t datalen
Definition: switch_frame.h:68
CF_PAUSE_BUGS
Definition: switch_types.h:1497
switch_channel_timetable::resurrected
switch_time_t resurrected
Definition: switch_channel.h:51
CF_SIGNAL_BRIDGE_TTL
Definition: switch_types.h:1510
CF_STOP_BROADCAST
Definition: switch_types.h:1492
switch_core_session_perform_force_locate
switch_core_session_t * switch_core_session_perform_force_locate(const char *uuid_str, const char *file, const char *func, int line)
Definition: switch_core_session.c:152
switch_core_session::frame_read_mutex
switch_mutex_t * frame_read_mutex
Definition: switch_core_pvt.h:119
CF_RECOVERED
Definition: switch_types.h:1520
switch_core_session_queue_event
switch_status_t switch_core_session_queue_event(switch_core_session_t *session, switch_event_t **event)
Definition: switch_core_session.c:1205
switch_core_session_disable_heartbeat
void switch_core_session_disable_heartbeat(switch_core_session_t *session)
Definition: switch_core_session.c:1703
SCF_DIALPLAN_TIMESTAMPS
Definition: switch_types.h:387
switch_event_header::name
char * name
Definition: switch_event.h:67
switch_loadable_module_get_application_interface
switch_application_interface_t * switch_loadable_module_get_application_interface(const char *name)
Retrieve the application interface by it&#39;s registered name.
switch_core_session_perform_locate
switch_core_session_t * switch_core_session_perform_locate(const char *uuid_str, const char *file, const char *func, int line)
Definition: switch_core_session.c:121
SAF_ZOMBIE_EXEC
Definition: switch_types.h:1710
switch_mutex_lock
switch_status_t switch_mutex_lock(switch_mutex_t *lock)
Definition: switch_apr.c:308
switch_caller_profile::callee_id_number
const char * callee_id_number
Definition: switch_caller.h:89
CF_RECOVERING_BRIDGE
Definition: switch_types.h:1548
switch_core_session::enc_write_buf
uint8_t enc_write_buf[SWITCH_RECOMMENDED_BUFFER_SIZE]
Definition: switch_core_pvt.h:143
switch_core_session_dequeue_signal_data
switch_status_t switch_core_session_dequeue_signal_data(switch_core_session_t *session, void **signal_data)
Definition: switch_core_session.c:1151
switch_session_manager::session_id
switch_size_t session_id
Definition: switch_core_pvt.h:300
switch_core_session_thread_launch
switch_status_t switch_core_session_thread_launch(switch_core_session_t *session)
Definition: switch_core_session.c:1942
switch_core_session_request_video_refresh
#define switch_core_session_request_video_refresh(_s)
Definition: switch_core.h:2881
switch_core_alloc
#define switch_core_alloc(_pool, _mem)
Allocate memory directly from a memory pool.
Definition: switch_core.h:684
switch_codec_implementation::actual_samples_per_second
uint32_t actual_samples_per_second
Definition: switch_module_interfaces.h:735
switch_core_session::track_id
uint32_t track_id
Definition: switch_core_pvt.h:154
switch_scheduler_del_task_id
uint32_t switch_scheduler_del_task_id(uint32_t task_id)
Delete a scheduled task.
Definition: switch_scheduler.c:282
CF_VIDEO_DEBUG_WRITE
Definition: switch_types.h:1594
switch_session_manager
Definition: switch_core_pvt.h:295
switch_channel_get_variable
#define switch_channel_get_variable(_c, _v)
Definition: switch_channel.h:326
index
int index
Definition: switch_cJSON.h:160
SWITCH_THREAD_STACKSIZE
#define SWITCH_THREAD_STACKSIZE
Definition: switch_types.h:584
switch_core_session_messages_waiting
uint32_t switch_core_session_messages_waiting(switch_core_session_t *session)
Definition: switch_core_session.c:1223
switch_event_add_header_string
switch_status_t switch_event_add_header_string(switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
Add a string header to an event.
Definition: switch_event.c:1247
switch_core_session::thread
switch_thread_t * thread
Definition: switch_core_pvt.h:88
switch_core_session_perform_destroy
void switch_core_session_perform_destroy(switch_core_session_t **session, const char *file, const char *func, int line)
Definition: switch_core_session.c:1529
SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED
Definition: switch_types.h:2207
switch_core_session_sched_heartbeat
void switch_core_session_sched_heartbeat(switch_core_session_t *session, uint32_t seconds)
Definition: switch_core_session.c:1655
CF_JITTERBUFFER_PLC
Definition: switch_types.h:1522
switch_app_log
Definition: switch_core.h:59
switch_caller_profile::caller_id_name
const char * caller_id_name
Definition: switch_caller.h:79
switch_apr_queue_t
Definition: switch_apr_queue.c:28
switch_safe_free
#define switch_safe_free(it)
Free a pointer and set it to NULL unless it already is NULL.
Definition: switch_utils.h:885
switch_thread_rwlock_tryrdlock
switch_status_t switch_thread_rwlock_tryrdlock(switch_thread_rwlock_t *rwlock)
Definition: switch_apr.c:255
switch_thread_data_s::func
switch_thread_start_t func
Definition: switch_core.h:67
SWITCH_SIG_BREAK
Definition: switch_types.h:1735
switch_caller_extension::children
struct switch_caller_profile * children
Definition: switch_caller.h:160
switch_core_session_flush_private_events
uint32_t switch_core_session_flush_private_events(switch_core_session_t *session)
Flush the private event queue of a session.
Definition: switch_core_session.c:1348
switch_core_session_thread_pool_worker
static void *SWITCH_THREAD_FUNC switch_core_session_thread_pool_worker(switch_thread_t *thread, void *obj)
Definition: switch_core_session.c:1774
switch_channel_pass_sdp
switch_status_t switch_channel_pass_sdp(switch_channel_t *from_channel, switch_channel_t *to_channel, const char *sdp)
Definition: switch_channel.c:5550
switch_console_push_match
void switch_console_push_match(switch_console_callback_match_t **matches, const char *new_val)
Definition: switch_console.c:1794
switch_mutex_init
switch_status_t switch_mutex_init(switch_mutex_t **lock, unsigned int flags, switch_memory_pool_t *pool)
Definition: switch_apr.c:293
switch_core_session_message::from
char * from
Definition: switch_core.h:181
SWITCH_MESSAGE_INDICATE_RESPOND
Definition: switch_types.h:1130
SWITCH_STANDARD_SCHED_FUNC
SWITCH_STANDARD_SCHED_FUNC(sch_heartbeat_callback)
Definition: switch_core_session.c:1624
switch_application_interface::application_function
switch_application_function_t application_function
Definition: switch_module_interfaces.h:792
switch_channel_set_flag_value
void switch_channel_set_flag_value(switch_channel_t *channel, switch_channel_flag_t flag, uint32_t value)
Set given flag(s) on a given channel.
Definition: switch_channel.c:1950
SWITCH_ORIGINATOR_VIDEO_CODEC_VARIABLE
#define SWITCH_ORIGINATOR_VIDEO_CODEC_VARIABLE
Definition: switch_types.h:207
switch_core_session_launch_thread
void switch_core_session_launch_thread(switch_core_session_t *session, switch_thread_start_t func, void *obj)
Definition: switch_core_session.c:2003
SWITCH_LOG_DEBUG1
Definition: switch_types.h:1288
switch_core_session_exec
switch_status_t switch_core_session_exec(switch_core_session_t *session, const switch_application_interface_t *application_interface, const char *arg)
Definition: switch_core_session.c:2834
SWITCH_STATUS_BREAK
Definition: switch_types.h:1245
CF_ORIGINATOR
Definition: switch_types.h:1504
switch_caller_profile::ani
const char * ani
Definition: switch_caller.h:95
switch_core_session_receive_event
switch_status_t switch_core_session_receive_event(switch_core_session_t *session, switch_event_t **event)
Definition: switch_core_session.c:1167
switch_channel_text_only
#define switch_channel_text_only(_channel)
Definition: switch_channel.h:96
switch_core_session::resample_mutex
switch_mutex_t * resample_mutex
Definition: switch_core_pvt.h:114
switch_caller_application::application_name
char * application_name
Definition: switch_caller.h:140
switch_channel_down_nosig
#define switch_channel_down_nosig(_channel)
Definition: switch_channel.h:92
switch_core_session::message_queue
switch_queue_t * message_queue
Definition: switch_core_pvt.h:130
SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE
#define SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE
Definition: switch_types.h:134
switch_core_hash_this
void switch_core_hash_this(_In_ switch_hash_index_t *hi, _Out_opt_ptrdiff_cap_(klen) const void **key, _Out_opt_ switch_ssize_t *klen, _Out_ void **val)
Gets the key and value of the current hash element.
switch_core_session::track_duration
uint32_t track_duration
Definition: switch_core_pvt.h:153
SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR
Definition: switch_types.h:2187
SWITCH_IGNORE_DISPLAY_UPDATES_VARIABLE
#define SWITCH_IGNORE_DISPLAY_UPDATES_VARIABLE
Definition: switch_types.h:127
switch_core_session::text_mutex
switch_mutex_t * text_mutex
Definition: switch_core_pvt.h:171
CF_ORIGINATING
Definition: switch_types.h:1491
switch_core_session::io_override
switch_io_routines_t * io_override
Definition: switch_core_pvt.h:166
switch_channel_timetable::profile_created
switch_time_t profile_created
Definition: switch_channel.h:44
switch_size_t
uintptr_t switch_size_t
Definition: switch_platform.h:225
switch_core_session::cond
switch_thread_cond_t * cond
Definition: switch_core_pvt.h:118
switch_core_session_destroy
#define switch_core_session_destroy(session)
Destroy a session and return the memory pool to the core.
Definition: switch_core.h:817
switch_core_hash_next
switch_hash_index_t * switch_core_hash_next(_In_ switch_hash_index_t **hi)
Gets the next element of a hashtable.
switch_stream_handle
Definition: switch_module_interfaces.h:94
CF_OUTBOUND
Definition: switch_types.h:1463
switch_thread_data_s::obj
void * obj
Definition: switch_core.h:68
CF_VIDEO_BREAK
Definition: switch_types.h:1584
SWITCH_MESSAGE_INDICATE_SIGNAL_DATA
Definition: switch_types.h:1153
switch_core_session_request
#define switch_core_session_request(_ep, _d, _f, _p)
Definition: switch_core.h:803
switch_channel_timetable::answered
switch_time_t answered
Definition: switch_channel.h:46
SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS
Definition: switch_types.h:1150
switch_channel_set_originator_caller_profile
void switch_channel_set_originator_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
Set the given channel&#39;s originator caller profile.
Definition: switch_channel.c:2926
CF_XFER_ZOMBIE
Definition: switch_types.h:1505
switch_core_session_message::_line
int _line
Definition: switch_core.h:210
switch_core_codec_init
#define switch_core_codec_init(_codec, _codec_name, _modname, _fmtp, _rate, _ms, _channels, _flags, _codec_settings, _pool)
Initialize a codec handle.
Definition: switch_core.h:1693
switch_io_routines::state_change
switch_io_state_change_t state_change
Definition: switch_module_interfaces.h:160
switch_core_session::uuid_str
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH+1]
Definition: switch_core_pvt.h:127
switch_core_session::io_rwlock
switch_thread_rwlock_t * io_rwlock
Definition: switch_core_pvt.h:122
SWITCH_MESSAGE_INDICATE_PROGRESS
Definition: switch_types.h:1117
switch_url_decode
char * switch_url_decode(char *s)
Definition: switch_utils.c:3654
switch_runtime::session_hash_mutex
switch_mutex_t * session_hash_mutex
Definition: switch_core_pvt.h:242
switch_cond_next
void switch_cond_next(void)
Definition: switch_time.c:658
CF_RESET
Definition: switch_types.h:1490
switch_io_event_hook_receive_message::next
struct switch_io_event_hook_receive_message * next
Definition: switch_core_event_hook.h:76
switch_caller_profile::aniii
const char * aniii
Definition: switch_caller.h:99
switch_core_session_id_dec
switch_size_t switch_core_session_id_dec(void)
Definition: switch_core_session.c:2528
switch_codec_implementation::microseconds_per_packet
int microseconds_per_packet
Definition: switch_module_interfaces.h:739
switch_core_session_count
uint32_t switch_core_session_count(void)
Provide the total number of sessions.
Definition: switch_core_session.c:2518
SWITCH_CURRENT_APPLICATION_DATA_VARIABLE
#define SWITCH_CURRENT_APPLICATION_DATA_VARIABLE
Definition: switch_types.h:133
switch_core_min_idle_cpu
double switch_core_min_idle_cpu(double new_limit)
Definition: switch_core_session.c:2601
switch_core_session::raw_read_buffer
switch_buffer_t * raw_read_buffer
Definition: switch_core_pvt.h:145
switch_session_manager::memory_pool
switch_memory_pool_t * memory_pool
Definition: switch_core_pvt.h:296
switch_event_header::value
char * value
Definition: switch_event.h:69
switch_channel_set_hunt_caller_profile
void switch_channel_set_hunt_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
Definition: switch_channel.c:2945
SWITCH_MESSAGE_INDICATE_BRIDGE
Definition: switch_types.h:1118
switch_call_cause_t
switch_call_cause_t
Definition: switch_types.h:2172
switch_caller_extension::current_application
switch_caller_application_t * current_application
Definition: switch_caller.h:155
SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE
Definition: switch_types.h:1157
switch_slin_data::frame_data
char frame_data[SWITCH_RECOMMENDED_BUFFER_SIZE]
Definition: switch_module_interfaces.h:873
CF_RECOVERING
Definition: switch_types.h:1547
switch_core_hash_delete
void * switch_core_hash_delete(_In_ switch_hash_t *hash, _In_z_ const char *key)
Delete data from a hash based on desired key.
switch_core_session_override_io_routines
switch_status_t switch_core_session_override_io_routines(switch_core_session_t *session, switch_io_routines_t *ior)
Definition: switch_core_session.c:3142
switch_slin_data::write_frame
switch_frame_t write_frame
Definition: switch_module_interfaces.h:871
CF_CONSUME_ON_ORIGINATE
Definition: switch_types.h:1517
switch_core_session_receive_message
#define switch_core_session_receive_message(_session, _message)
Definition: switch_core.h:1247
switch_core_session_rwunlock
void switch_core_session_rwunlock(_In_ switch_core_session_t *session)
Unlock a read or write lock on as given session.
switch_core_session_video_reset
void switch_core_session_video_reset(switch_core_session_t *session)
Definition: switch_core_session.c:2713
switch_core_session_flush_message
switch_status_t switch_core_session_flush_message(switch_core_session_t *session)
Definition: switch_core_session.c:1113
switch_channel_set_variable_var_check
switch_status_t switch_channel_set_variable_var_check(switch_channel_t *channel, const char *varname, const char *value, switch_bool_t var_check)
Definition: switch_channel.c:1488
switch_channel_test_cap
uint32_t switch_channel_test_cap(switch_channel_t *channel, switch_channel_cap_t cap)
Definition: switch_channel.c:1874
switch_io_event_hook_state_change::state_change
switch_state_change_hook_t state_change
Definition: switch_core_event_hook.h:153
switch_app_log::app
char * app
Definition: switch_core.h:60
CF_HOLD
Definition: switch_types.h:1471
switch_str_nil
#define switch_str_nil(s)
Make a null string a blank string instead.
Definition: switch_utils.h:993
SWITCH_CORE_SESSION_MAX_PRIVATES
#define SWITCH_CORE_SESSION_MAX_PRIVATES
Definition: switch_types.h:239
switch_mutex_t
struct fspr_thread_mutex_t switch_mutex_t
Definition: switch_apr.h:314
switch_slin_data::codec
switch_codec_t codec
Definition: switch_module_interfaces.h:872
CF_WINNER
Definition: switch_types.h:1475
switch_core_session::raw_read_frame
switch_frame_t raw_read_frame
Definition: switch_core_pvt.h:146
CF_WANT_MSRP
Definition: switch_types.h:1617
SWITCH_CHANNEL_SESSION_LOG_CLEAN
#define SWITCH_CHANNEL_SESSION_LOG_CLEAN(x)
Definition: switch_types.h:1332
switch_thread_cond_signal
switch_status_t switch_thread_cond_signal(switch_thread_cond_t *cond)
Definition: switch_apr.c:394
switch_core_media_receive_message
switch_status_t switch_core_media_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
Definition: switch_core_media.c:12724
switch_thread_equal
int switch_thread_equal(switch_thread_id_t tid1, switch_thread_id_t tid2)
Compare two thread ids.
Definition: switch_apr.c:111
switch_runtime::profile_time
double profile_time
Definition: switch_core_pvt.h:270
switch_thread_start_t
void *(SWITCH_THREAD_FUNC * switch_thread_start_t)(switch_thread_t *, void *)
Definition: switch_apr.h:950
switch_core_session_execute_application_get_flags
switch_status_t switch_core_session_execute_application_get_flags(switch_core_session_t *session, const char *app, const char *arg, int32_t *flags)
Definition: switch_core_session.c:2724
switch_core_session_dequeue_message
switch_status_t switch_core_session_dequeue_message(switch_core_session_t *session, switch_core_session_message_t **message)
Definition: switch_core_session.c:1092
switch_core_session_run
void switch_core_session_run(_In_ switch_core_session_t *session)
Start the session&#39;s state machine.
switch_uuid_format
void switch_uuid_format(char *buffer, const switch_uuid_t *uuid)
Definition: switch_apr.c:1140
switch_channel_expand_variables
#define switch_channel_expand_variables(_channel, _in)
Definition: switch_channel.h:654
SWITCH_R_SDP_VARIABLE
#define SWITCH_R_SDP_VARIABLE
Definition: switch_types.h:197
switch_core_session::private_event_queue_pri
switch_queue_t * private_event_queue_pri
Definition: switch_core_pvt.h:133
switch_codec_implementation::samples_per_packet
uint32_t samples_per_packet
Definition: switch_module_interfaces.h:741
switch_io_event_hook_state_change::next
struct switch_io_event_hook_state_change * next
Definition: switch_core_event_hook.h:154
switch_stream_handle::write_function
switch_stream_handle_write_function_t write_function
Definition: switch_module_interfaces.h:96
switch_core_session_event_count
uint32_t switch_core_session_event_count(switch_core_session_t *session)
Definition: switch_core_session.c:1238
SWITCH_CODEC_FLAG_DECODE
Definition: switch_types.h:1754
CF_MSRPS
Definition: switch_types.h:1616
switch_uuid_t
Definition: switch_apr.h:539
switch_core_session_get_stream_count
int switch_core_session_get_stream_count(switch_core_session_t *session)
Definition: switch_core_session.c:516
SWITCH_EVENT_QUEUE_LEN
#define SWITCH_EVENT_QUEUE_LEN
Definition: switch_core_pvt.h:65
switch_codec_implementation::number_of_channels
uint8_t number_of_channels
Definition: switch_module_interfaces.h:747
switch_codec_implementation::samples_per_second
uint32_t samples_per_second
Definition: switch_module_interfaces.h:733
switch_core_session::pool
switch_memory_pool_t * pool
Definition: switch_core_pvt.h:87
CF_CNG_PLC
Definition: switch_types.h:1526
SWITCH_EVENT_GENERAL
Definition: switch_types.h:2136
SWITCH_SIZE_T_FMT
#define SWITCH_SIZE_T_FMT
Definition: switch_platform.h:258
switch_channel_uninit
void switch_channel_uninit(switch_channel_t *channel)
Uninitalize a channel.
Definition: switch_channel.c:740
switch_status_t
switch_status_t
Common return values.
Definition: switch_types.h:1233
SWITCH_LOG_CRIT
Definition: switch_types.h:1294
SWITCH_LOG_DEBUG
Definition: switch_types.h:1289
CF_EARLY_HANGUP
Definition: switch_types.h:1515
CF_ATTENDED_TRANSFER
Definition: switch_types.h:1527
switch_runtime::sps
int32_t sps
Definition: switch_core_pvt.h:246
CF_BROADCAST_DROP_MEDIA
Definition: switch_types.h:1514
switch_core_session_running
unsigned int switch_core_session_running(switch_core_session_t *session)
Definition: switch_core_session.c:1499
switch_goto_status
#define switch_goto_status(_status, _label)
Definition: switch_utils.h:287
switch_core_session_get_stream
void * switch_core_session_get_stream(switch_core_session_t *session, int index)
Definition: switch_core_session.c:510
switch_core_session_read_lock_hangup
switch_status_t switch_core_session_read_lock_hangup(_In_ switch_core_session_t *session)
Acquire a read lock on the session.
switch_loadable_module_get_dialplan_interface
switch_dialplan_interface_t * switch_loadable_module_get_dialplan_interface(const char *name)
Retrieve the dialplan interface by it&#39;s registered name.
target
const cJSON *const target
Definition: switch_cJSON_Utils.h:75
switch_io_event_hook_outgoing_channel
Node in which to store custom receive message callback hooks.
Definition: switch_core_event_hook.h:68
switch_loadable_module_get_endpoint_interface
switch_endpoint_interface_t * switch_loadable_module_get_endpoint_interface(const char *name)
Retrieve the endpoint interface by it&#39;s registered name.
Definition: switch_loadable_module.c:2479
SWITCH_LOG_DEBUG10
Definition: switch_types.h:1279
switch_thread_pool_node_s::pool
switch_memory_pool_t * pool
Definition: switch_core_session.c:1771
SWITCH_MESSAGE_INDICATE_UUID_CHANGE
Definition: switch_types.h:1141
switch_uuid_str
char * switch_uuid_str(char *buf, switch_size_t len)
Definition: switch_utils.c:4241
switch_core_session_write_lock
void switch_core_session_write_lock(_In_ switch_core_session_t *session)
Acquire a write lock on the session.
CF_MEDIA_SET
Definition: switch_types.h:1516
switch_event_header::next
struct switch_event_header * next
Definition: switch_event.h:76
switch_core_session::enc_read_buf
uint8_t enc_read_buf[SWITCH_RECOMMENDED_BUFFER_SIZE]
Definition: switch_core_pvt.h:149
SWITCH_SIGNAL_BOND_VARIABLE
#define SWITCH_SIGNAL_BOND_VARIABLE
Definition: switch_types.h:203
SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC
Definition: switch_types.h:1145
check_media
#define check_media(session)
Definition: switch_core_session.c:1285
switch_caller_profile::destination_number
char * destination_number
Definition: switch_caller.h:105
CF_EARLY_OK
Definition: switch_types.h:1552
switch_core_session_signal_state_change
void switch_core_session_signal_state_change(switch_core_session_t *session)
Definition: switch_core_session.c:1478
CF_DISABLE_RINGBACK
Definition: switch_types.h:1508
switch_channel_set_originatee_caller_profile
void switch_channel_set_originatee_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
Set the given channel&#39;s originatee caller profile.
Definition: switch_channel.c:2991
switch_session_manager::session_table
switch_hash_t * session_table
Definition: switch_core_pvt.h:297
switch_channel_has_dtmf
switch_size_t switch_channel_has_dtmf(_In_ switch_channel_t *channel)
Test for presence of DTMF on a given channel.
switch_core_memory_pool_set_data
void switch_core_memory_pool_set_data(switch_memory_pool_t *pool, const char *key, void *data)
Definition: switch_core_memory.c:317
SWITCH_MESSAGE_INDICATE_ANSWER
Definition: switch_types.h:1115
SAF_SUPPORT_TEXT_ONLY
Definition: switch_types.h:1712
SWITCH_CHANNEL_ID_LOG
Definition: switch_types.h:1313
switch_core_hash_insert
#define switch_core_hash_insert(_h, _k, _d)
Definition: switch_core.h:1479
switch_core_session_locate
#define switch_core_session_locate(uuid_str)
Locate a session based on it&#39;s uuid.
Definition: switch_core.h:932
SWITCH_MESSAGE_INDICATE_UNBRIDGE
Definition: switch_types.h:1119
CF_CONTROLLED
Definition: switch_types.h:1477
switch_core_session::stream_count
int stream_count
Definition: switch_core_pvt.h:125
switch.h
Main Library Header.
switch_core_media_bug_remove_all
#define switch_core_media_bug_remove_all(_s)
Definition: switch_core.h:405
switch_channel_timetable::progress
switch_time_t progress
Definition: switch_channel.h:47
switch_core_session_get_dmachine
switch_ivr_dmachine_t * switch_core_session_get_dmachine(switch_core_session_t *session, switch_digit_action_target_t target)
Definition: switch_core_session.c:56
CF_SERVICE
Definition: switch_types.h:1473
switch_event_create
#define switch_event_create(event, id)
Create a new event assuming it will not be custom event and therefore hiding the unused parameters...
Definition: switch_event.h:384
switch_core_ready_outbound
switch_bool_t switch_core_ready_outbound(void)
Determines if the core is ready to place outbound calls.
Definition: switch_core.c:3008
SWITCH_EVENT_SESSION_HEARTBEAT
Definition: switch_types.h:2138
SWITCH_DECLARE
#define SWITCH_DECLARE(type)
Definition: switch_platform.h:195
switch_core_session::enc_write_frame
switch_frame_t enc_write_frame
Definition: switch_core_pvt.h:141
switch_uuid_get
void switch_uuid_get(switch_uuid_t *uuid)
Definition: switch_apr.c:1152
switch_core_session_get_id
switch_size_t switch_core_session_get_id(switch_core_session_t *session)
Definition: switch_core_session.c:2523
switch_event_get_header
#define switch_event_get_header(_e, _h)
Definition: switch_event.h:172
switch_channel_set_flag
#define switch_channel_set_flag(_c, _f)
Definition: switch_channel.h:408
switch_hashtable_iterator
Definition: switch_hashtable_private.h:29
switch_xml_child
switch_xml_t switch_xml_child(_In_ switch_xml_t xml, _In_z_ const char *name)
returns the first child tag (one level deeper) with the given name or NULL \ if not found ...
switch_channel_set_name
switch_status_t switch_channel_set_name(switch_channel_t *channel, const char *name)
Assign a name to a given channel.
Definition: switch_channel.c:1126
CF_MSRP
Definition: switch_types.h:1615
switch_io_routines::receive_message
switch_io_receive_message_t receive_message
Definition: switch_module_interfaces.h:156
switch_channel_direction
switch_call_direction_t switch_channel_direction(switch_channel_t *channel)
Definition: switch_channel.c:440
switch_set_string
#define switch_set_string(_dst, _src)
Definition: switch_utils.h:734
SWITCH_STATUS_TIMEOUT
Definition: switch_types.h:1236
CF_VIDEO_BLANK
Definition: switch_types.h:1581
switch_queue_trypush
switch_status_t switch_queue_trypush(switch_queue_t *queue, void *data)
Definition: switch_apr.c:1279
switch_caller_profile::times
struct switch_channel_timetable * times
Definition: switch_caller.h:124
CF_REQ_MEDIA
Definition: switch_types.h:1495
SWITCH_LOG_ERROR
Definition: switch_types.h:1293
CF_EARLY_MEDIA
Definition: switch_types.h:1464
switch_channel_state_thread_trylock
switch_status_t switch_channel_state_thread_trylock(switch_channel_t *channel)
Definition: switch_channel.c:2646
switch_core_memory_pool_tag
void switch_core_memory_pool_tag(switch_memory_pool_t *pool, const char *tag)
Definition: switch_core_memory.c:331
switch_core_session_hupall_matching_vars_ans
uint32_t switch_core_session_hupall_matching_vars_ans(switch_event_t *vars, switch_call_cause_t cause, switch_hup_type_t type)
Definition: switch_core_session.c:211
switch_io_routines::outgoing_channel
switch_io_outgoing_channel_t outgoing_channel
Definition: switch_module_interfaces.h:146
switch_core_session_hupall_endpoint
void switch_core_session_hupall_endpoint(const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause)
Hangup all sessions that belong to an endpoint.
Definition: switch_core_session.c:339
CF_LAZY_ATTENDED_TRANSFER
Definition: switch_types.h:1528
switch_core_session::mutex
switch_mutex_t * mutex
Definition: switch_core_pvt.h:112
str_node::str
char * str
Definition: switch_core_session.c:207
switch_core_session_soft_unlock
void switch_core_session_soft_unlock(switch_core_session_t *session)
Definition: switch_core_session.c:82
switch_app_log::arg
char * arg
Definition: switch_core.h:61
switch_epoch_time_now
time_t switch_epoch_time_now(time_t *t)
Get the current epoch time.
Definition: switch_time.c:322
switch_caller_profile::caller_id_number
const char * caller_id_number
Definition: switch_caller.h:81
CF_MEDIA_BRIDGE_TTL
Definition: switch_types.h:1511
switch_queue_term
switch_status_t switch_queue_term(switch_queue_t *queue)
Definition: switch_apr.c:1274
SWITCH_STATUS_FALSE
Definition: switch_types.h:1235
CF_GEN_RINGBACK
Definition: switch_types.h:1482
switch_core_session_alloc
#define switch_core_session_alloc(_session, _memory)
Allocate memory from a session&#39;s pool.
Definition: switch_core.h:696
switch_core_session::dmachine
switch_ivr_dmachine_t * dmachine[2]
Definition: switch_core_pvt.h:157
switch_queue_push
switch_status_t switch_queue_push(switch_queue_t *queue, void *data)
Definition: switch_apr.c:1253
SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL
Definition: switch_types.h:2198
SWITCH_STATUS_SUCCESS
Definition: switch_types.h:1234
switch_core_session_get_text_buffer
const char * switch_core_session_get_text_buffer(switch_core_session_t *session)
Definition: switch_core_session.c:1990
switch_thread_rwlock_create
switch_status_t switch_thread_rwlock_create(switch_thread_rwlock_t **rwlock, switch_memory_pool_t *pool)
Definition: switch_apr.c:235
switch_test_flag
#define switch_test_flag(obj, flag)
Test for the existance of a flag on an arbitary object.
Definition: switch_utils.h:693
CF_EVENT_LOCK
Definition: switch_types.h:1488
switch_core_session_try_reset
switch_status_t switch_core_session_try_reset(switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
Reset the buffers and resampler on a session, fail if can not lock codec mutexes. ...
Definition: switch_core_session.c:1374
CF_PARK
Definition: switch_types.h:1502
CF_STATE_REPEAT
Definition: switch_types.h:1626
switch_console_callback_match
Definition: switch_types.h:2383
switch_core_codec_ready
static switch_bool_t switch_core_codec_ready(switch_codec_t *codec)
Definition: switch_loadable_module.h:607
switch_log_printf
void switch_log_printf(_In_ switch_text_channel_t channel, _In_z_ const char *file, _In_z_ const char *func, _In_ int line, _In_opt_z_ const char *userdata, _In_ switch_log_level_t level, _In_z_ _Printf_format_string_ const char *fmt,...) PRINTF_FUNCTION(7
Write log data to the logging engine.
switch_stristr
const char * switch_stristr(const char *instr, const char *str)
Definition: switch_utils.c:1673
SWITCH_CURRENT_APPLICATION_VARIABLE
#define SWITCH_CURRENT_APPLICATION_VARIABLE
Definition: switch_types.h:142
CF_BLOCK_STATE
Definition: switch_types.h:1499
switch_threadattr_create
switch_status_t switch_threadattr_create(switch_threadattr_t **new_attr, switch_memory_pool_t *pool)
Definition: switch_apr.c:665
switch_thread_create
switch_status_t switch_thread_create(switch_thread_t **new_thread, switch_threadattr_t *attr, switch_thread_start_t func, void *data, switch_memory_pool_t *cont)
Definition: switch_apr.c:698
switch_codec_implementation
A table of settings and callbacks that define a paticular implementation of a codec.
Definition: switch_module_interfaces.h:723
PROTECT_INTERFACE
#define PROTECT_INTERFACE(_it)
Definition: switch_module_interfaces.h:864
CF_DIVERT_EVENTS
Definition: switch_types.h:1498
switch_core_session::endpoint_interface
switch_endpoint_interface_t * endpoint_interface
Definition: switch_core_pvt.h:90
switch_thread_pool_node_t
struct switch_thread_pool_node_s switch_thread_pool_node_t
SMF_NONE
Definition: switch_types.h:496
CF_RTT
Definition: switch_types.h:1619
count
int count
Definition: switch_cJSON.h:204
switch_memory_pool_t
struct fspr_pool_t switch_memory_pool_t
Definition: switch_types.h:2318
name
const char *const name
Definition: switch_cJSON.h:250
switch_channel_up_nosig
#define switch_channel_up_nosig(_channel)
Definition: switch_channel.h:91
switch_core_session_queue_signal_data
switch_status_t switch_core_session_queue_signal_data(switch_core_session_t *session, void *signal_data)
Definition: switch_core_session.c:1131
SWITCH_STACK_BOTTOM
Definition: switch_types.h:1204
switch_queue_create
switch_status_t switch_queue_create(switch_queue_t **queue, unsigned int queue_capacity, switch_memory_pool_t *pool)
Definition: switch_apr.c:1233
switch_session_manager::session_limit
uint32_t session_limit
Definition: switch_core_pvt.h:299
switch_core_session_strdup
#define switch_core_session_strdup(_session, _todup)
Copy a string using memory allocation from a session&#39;s pool.
Definition: switch_core.h:719
switch_core_session::loglevel
switch_log_level_t loglevel
Definition: switch_core_pvt.h:155
switch_thread_self
switch_thread_id_t switch_thread_self(void)
Definition: switch_apr.c:102
switch_ivr_deactivate_unicast
switch_status_t switch_ivr_deactivate_unicast(switch_core_session_t *session)
Definition: switch_ivr.c:371
thread_launch_failure
static void thread_launch_failure(void)
Definition: switch_core_session.c:1826
switch_event_destroy
void switch_event_destroy(switch_event_t **event)
Destroy an event.
Definition: switch_event.c:1289
SOF_NONE
Definition: switch_types.h:326
CF_EVENT_PARSE
Definition: switch_types.h:1481
SSHF_FREE_ARG
Definition: switch_types.h:490
CF_VIDEO_DECODED_READ
Definition: switch_types.h:1592
SWITCH_MESSAGE_INDICATE_MEDIA
Definition: switch_types.h:1123
CF_BYPASS_MEDIA_AFTER_BRIDGE
Definition: switch_types.h:1512
switch_channel_timetable::transferred
switch_time_t transferred
Definition: switch_channel.h:50
switch_core_session::raw_write_buf
uint8_t raw_write_buf[SWITCH_RECOMMENDED_BUFFER_SIZE]
Definition: switch_core_pvt.h:142
SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC_COMPLETE
Definition: switch_types.h:1146
switch_application_interface::flags
uint32_t flags
Definition: switch_module_interfaces.h:800
CF_SUSPEND
Definition: switch_types.h:1480
switch_channel_state_thread_unlock
void switch_channel_state_thread_unlock(switch_channel_t *channel)
Definition: switch_channel.c:2652
switch_codec
Definition: switch_module_interfaces.h:700
CF_WANT_MSRPS
Definition: switch_types.h:1618
switch_core_session_event_send
switch_status_t switch_core_session_event_send(const char *uuid_str, switch_event_t **event)
Definition: switch_core_session.c:460
switch_core_session_queue_message
switch_status_t switch_core_session_queue_message(switch_core_session_t *session, switch_core_session_message_t *message)
Definition: switch_core_session.c:1050
SOF_NO_EFFECTIVE_CID_NAME
Definition: switch_types.h:332
SOF_NO_EFFECTIVE_ANI
Definition: switch_types.h:329
switch_core_session_get_loglevel
switch_log_level_t switch_core_session_get_loglevel(switch_core_session_t *session)
Get the log level for a session.
Definition: switch_core_session.c:3116
switch_channel_clear_flag
void switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flag)
Clear given flag(s) from a channel.
Definition: switch_channel.c:2145
switch_core_session::sdata
switch_slin_data_t * sdata
Definition: switch_core_pvt.h:167
switch_core_session::thread_id
switch_thread_id_t thread_id
Definition: switch_core_pvt.h:89
switch_ivr_dmachine_destroy
void switch_ivr_dmachine_destroy(switch_ivr_dmachine_t **dmachine)
Definition: switch_ivr_async.c:186
CF_DIALPLAN
Definition: switch_types.h:1523
SWITCH_PRI_LOW
Definition: switch_types.h:2602
switch_assert
#define switch_assert(expr)
Definition: switch_platform.h:347
switch_thread_t
struct fspr_thread_t switch_thread_t
Definition: switch_apr.h:941
SWITCH_MAX_FORWARDS_VARIABLE
#define SWITCH_MAX_FORWARDS_VARIABLE
Definition: switch_types.h:226
SWITCH_FALSE
Definition: switch_types.h:438
switch_channel_set_variable
#define switch_channel_set_variable(_channel, _var, _val)
Definition: switch_channel.h:299
switch_session_manager::mutex
switch_mutex_t * mutex
Definition: switch_core_pvt.h:302
switch_time_now
switch_time_t switch_time_now(void)
Definition: switch_apr.c:325
switch_core_session::raw_write_frame
switch_frame_t raw_write_frame
Definition: switch_core_pvt.h:140
switch_channel_init
switch_status_t switch_channel_init(switch_channel_t *channel, switch_core_session_t *session, switch_channel_state_t state, switch_channel_flag_t flag)
Connect a newly allocated channel to a session object and setup it&#39;s initial state.
Definition: switch_channel.c:767
SHT_ANSWERED
Definition: switch_core.h:988
CF_EVENT_LOCK_PRI
Definition: switch_types.h:1489
switch_core_session_set_loglevel
switch_status_t switch_core_session_set_loglevel(switch_core_session_t *session, switch_log_level_t loglevel)
Sets the log level for a session.
Definition: switch_core_session.c:3109
SWITCH_STATUS_IGNORE
Definition: switch_types.h:1251
switch_channel_pre_answer
#define switch_channel_pre_answer(channel)
Indicate progress on a channel to attempt early media.
Definition: switch_channel.h:509
CF_NOT_READY
Definition: switch_types.h:1509
switch_core_session_in_thread
switch_bool_t switch_core_session_in_thread(switch_core_session_t *session)
Definition: switch_core_session.c:1712
switch_channel_get_caller_profile
switch_caller_profile_t * switch_channel_get_caller_profile(switch_channel_t *channel)
Retrieve the given channel&#39;s caller profile.
Definition: switch_channel.c:2914
switch_core_session_kill_channel
#define switch_core_session_kill_channel(session, sig)
Send a signal to a channel.
Definition: switch_core.h:1393
SOF_NO_EFFECTIVE_CID_NUM
Definition: switch_types.h:331
CC_BYPASS_MEDIA
Definition: switch_types.h:1448
switch_event_serialize
switch_status_t switch_event_serialize(switch_event_t *event, char **str, switch_bool_t encode)
Definition: switch_event.c:1527
switch_core_ready_inbound
switch_bool_t switch_core_ready_inbound(void)
Determines if the core is ready to take inbound calls.
Definition: switch_core.c:3003
switch_thread_data_s
Definition: switch_core.h:66
switch_buffer_destroy
void switch_buffer_destroy(switch_buffer_t **buffer)
Destroy the buffer.
Definition: switch_buffer.c:399
SWITCH_MESSAGE_INDICATE_REDIRECT
Definition: switch_types.h:1129
CC_PROXY_MEDIA
Definition: switch_types.h:1449
switch_channel_get_name
char * switch_channel_get_name(switch_channel_t *channel)
Retrieve the name of a given channel.
Definition: switch_channel.c:1148
switch_core_hash_first
#define switch_core_hash_first(_h)
Definition: switch_core.h:1592
switch_core_ready
switch_bool_t switch_core_ready(void)
Determines if the core is ready to take calls.
Definition: switch_core.c:2998
switch_core_session::rwlock
switch_thread_rwlock_t * rwlock
Definition: switch_core_pvt.h:121
switch_mprintf
SWITCH_BEGIN_EXTERN_C char * switch_mprintf(const char *zFormat,...)
Definition: switch_mprintf.c:897
switch_runtime::min_idle_time
double min_idle_time
Definition: switch_core_pvt.h:271
SOF_NO_LIMITS
Definition: switch_types.h:333
SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED
Definition: switch_types.h:2209
memset
memset(buf, 0, buflen)
switch_channel_media_up
#define switch_channel_media_up(_channel)
Definition: switch_channel.h:86
switch_core_session_limit
uint32_t switch_core_session_limit(uint32_t new_limit)
Definition: switch_core_session.c:2592
switch_core.h
Core Library.
switch_buffer_get_head_pointer
void * switch_buffer_get_head_pointer(switch_buffer_t *buffer)
Definition: switch_buffer.c:57
CF_THREAD_SLEEPING
Definition: switch_types.h:1507
CF_BROADCAST
Definition: switch_types.h:1485
switch_caller_profile::callee_id_name
const char * callee_id_name
Definition: switch_caller.h:87
SOF_NO_EFFECTIVE_ANIII
Definition: switch_types.h:330
switch_core_session_get_pool
switch_memory_pool_t * switch_core_session_get_pool(_In_ switch_core_session_t *session)
Retrieve the memory pool from a session.
switch_channel_timetable::progress_media
switch_time_t progress_media
Definition: switch_channel.h:48
CF_PROXY_MODE
Definition: switch_types.h:1478
switch_core_session::app_log
switch_app_log_t * app_log
Definition: switch_core_pvt.h:136
switch_core_session_outgoing_channel
switch_call_cause_t switch_core_session_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event, const char *endpoint_name, switch_caller_profile_t *caller_profile, switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
Definition: switch_core_session.c:521
switch_log_level_t
switch_log_level_t
Log Level Enumeration.
Definition: switch_types.h:1278
switch_core_session_destroy_state
void switch_core_session_destroy_state(switch_core_session_t *session)
Definition: switch_core_state_machine.c:720
switch_core_session::soft_lock
uint32_t soft_lock
Definition: switch_core_pvt.h:156
SWITCH_EVENT_CHANNEL_OUTGOING
Definition: switch_types.h:2089
SWITCH_UUID_FORMATTED_LENGTH
#define SWITCH_UUID_FORMATTED_LENGTH
Definition: switch_apr.h:545
switch_event::headers
switch_event_header_t * headers
Definition: switch_event.h:90
switch_io_event_hook_outgoing_channel::outgoing_channel
switch_outgoing_channel_hook_t outgoing_channel
Definition: switch_core_event_hook.h:69
switch_app_log::next
struct switch_app_log * next
Definition: switch_core.h:63
switch_core_session::read_frame_count
uint32_t read_frame_count
Definition: switch_core_pvt.h:152
switch_caller_profile::caller_extension
struct switch_caller_extension * caller_extension
Definition: switch_caller.h:126
switch_core_session_dequeue_private_event
switch_status_t switch_core_session_dequeue_private_event(switch_core_session_t *session, switch_event_t **event)
Definition: switch_core_session.c:1316
switch_ivr_clear_speech_cache
void switch_ivr_clear_speech_cache(switch_core_session_t *session)
Definition: switch_ivr_play_say.c:3008
switch_core_session_uninit
void switch_core_session_uninit(void)
Definition: switch_core_session.c:2637
switch_core_session_get_uuid
char * switch_core_session_get_uuid(switch_core_session_t *session)
Definition: switch_core_session.c:2580
switch_core_session_message::pointer_arg
void * pointer_arg
Definition: switch_core.h:192
switch_core_session_set_uuid
switch_status_t switch_core_session_set_uuid(switch_core_session_t *session, const char *use_uuid)
Definition: switch_core_session.c:2018
switch_core_session_queue_private_event
switch_status_t switch_core_session_queue_private_event(switch_core_session_t *session, switch_event_t **event, switch_bool_t priority)
Definition: switch_core_session.c:1263
switch_thread_pool_launch_thread
switch_status_t switch_thread_pool_launch_thread(switch_thread_data_t **tdp)
Definition: switch_core_session.c:1893
switch_caller_profile::pool
switch_memory_pool_t * pool
Definition: switch_caller.h:127
switch_core_session_stack_count
uint32_t switch_core_session_stack_count(switch_core_session_t *session, int x)
Definition: switch_core_session.c:2992
SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
Definition: switch_types.h:2188
switch_channel
Definition: switch_channel.c:152
CF_BREAK
Definition: switch_types.h:1484
switch_core_session_get_jb
switch_jb_t * switch_core_session_get_jb(switch_core_session_t *session, switch_media_type_t type)
Definition: switch_core_session.c:68
switch_media_type_t
switch_media_type_t
Definition: switch_types.h:1844
switch_threadattr_priority_set
switch_status_t switch_threadattr_priority_set(switch_threadattr_t *attr, switch_thread_priority_t priority)
Definition: switch_apr.c:688
Generated by   doxygen 1.8.13