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