RTS API Documentation  1.10.11
switch_core.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  * Marcel Barbulescu <marcelbarbulescu@gmail.com>
30  * Joseph Sullivan <jossulli@amazon.com>
31  * Seven Du <dujinfang@gmail.com>
32  * Andrey Volk <andywolk@gmail.com>
33  *
34  * switch_core.c -- Main Core Library
35  *
36  */
37 
38 
39 
40 #include <switch.h>
41 #include <switch_ssl.h>
42 #include <switch_stun.h>
43 #include <switch_nat.h>
44 #include "private/switch_apr_pvt.h"
45 #include "private/switch_core_pvt.h"
46 #include <switch_curl.h>
47 #include <switch_msrp.h>
48 #ifndef WIN32
49 #include <switch_private.h>
50 #ifdef HAVE_SETRLIMIT
51 #include <sys/resource.h>
52 #endif
53 #endif
54 #include <errno.h>
55 #include <sqlite3.h>
56 #ifdef HAVE_SYS_PRCTL_H
57 #include <sys/prctl.h>
58 #endif
59 #ifdef SOLARIS_PRIVILEGES
60 #include <priv.h>
61 #endif
62 
63 #ifdef __linux__
64 #include <sys/wait.h>
65 #ifndef _GNU_SOURCE
66 #define _GNU_SOURCE /* Required for POSIX_SPAWN_USEVFORK */
67 #endif
68 #include <spawn.h>
69 #include <poll.h>
70 #endif
71 
72 #ifdef WIN32
73 #define popen _popen
74 #define pclose _pclose
75 #endif
76 
77 #ifdef HAVE_SYSTEMD
78 #include <systemd/sd-daemon.h>
79 #endif
80 #include <xswitch.h> // xswitch functions and extensions
81 
82 SWITCH_DECLARE_DATA switch_directories SWITCH_GLOBAL_dirs = { 0 };
83 SWITCH_DECLARE_DATA switch_filenames SWITCH_GLOBAL_filenames = { 0 };
84 
85 /* The main runtime obj we keep this hidden for ourselves */
86 struct switch_runtime runtime = { 0 };
87 static void switch_load_core_config(const char *file);
88 
89 static void send_heartbeat(void)
90 {
91  switch_event_t *event;
92  switch_core_time_duration_t duration;
93 
94  switch_core_measure_time(switch_core_uptime(), &duration);
95 
96  if (switch_event_create(&event, SWITCH_EVENT_HEARTBEAT) == SWITCH_STATUS_SUCCESS) {
97  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Ready");
98  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Up-Time",
99  "%u year%s, "
100  "%u day%s, "
101  "%u hour%s, "
102  "%u minute%s, "
103  "%u second%s, "
104  "%u millisecond%s, "
105  "%u microsecond%s",
106  duration.yr, duration.yr == 1 ? "" : "s",
107  duration.day, duration.day == 1 ? "" : "s",
108  duration.hr, duration.hr == 1 ? "" : "s",
109  duration.min, duration.min == 1 ? "" : "s",
110  duration.sec, duration.sec == 1 ? "" : "s",
111  duration.ms, duration.ms == 1 ? "" : "s", duration.mms, duration.mms == 1 ? "" : "s");
112 
113  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FreeSWITCH-Version", "%s", switch_version_full());
114  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Uptime-msec", "%"SWITCH_TIME_T_FMT, switch_core_uptime() / 1000);
115  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Count", "%u", switch_core_session_count());
116  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Max-Sessions", "%u", switch_core_session_limit(0));
117  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec", "%u", runtime.sps);
118  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec-Last", "%u", runtime.sps_last);
119  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec-Max", "%u", runtime.sps_peak);
120  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec-FiveMin", "%u", runtime.sps_peak_fivemin);
121  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Since-Startup", "%" SWITCH_SIZE_T_FMT, switch_core_session_id() - 1);
122  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Peak-Max", "%u", runtime.sessions_peak);
123  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Peak-FiveMin", "%u", runtime.sessions_peak_fivemin);
124  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Idle-CPU", "%f", switch_core_idle_cpu());
125  switch_event_fire(&event);
126  }
127 }
128 
129 static char main_ip4[256] = "";
130 static char main_ip6[256] = "";
131 
132 static void check_ip(void)
133 {
134  char guess_ip4[256] = "";
135  char guess_ip6[256] = "";
136  char old_ip4[256] = "";
137  char old_ip6[256] = "";
138  int ok4 = 1, ok6 = 1;
139  int mask = 0;
140  switch_status_t check6, check4;
141  switch_event_t *event;
142  char *hostname = switch_core_get_variable("hostname");
143 
144  gethostname(runtime.hostname, sizeof(runtime.hostname));
145 
146  if (zstr(hostname)) {
147  switch_core_set_variable("hostname", runtime.hostname);
148  } else if (strcmp(hostname, runtime.hostname)) {
149  if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
150  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "hostname-change");
151  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "old-hostname", hostname);
152  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "new-hostname", runtime.hostname);
153  switch_event_fire(&event);
154  }
155 
156  switch_core_set_variable("hostname", runtime.hostname);
157  }
158 
159  check4 = switch_find_local_ip(guess_ip4, sizeof(guess_ip4), &mask, AF_INET);
160  check6 = switch_find_local_ip(guess_ip6, sizeof(guess_ip6), NULL, AF_INET6);
161 
162  if (check6 != SWITCH_STATUS_SUCCESS && (zstr(main_ip6) || !strcasecmp(main_ip6, "::1"))) {
163  check6 = SWITCH_STATUS_SUCCESS;
164  }
165 
166  if (check4 != SWITCH_STATUS_SUCCESS) {
167  ok4 = 2;
168  } else if (!*main_ip4) {
169  switch_set_string(main_ip4, guess_ip4);
170  } else {
171  if (!(ok4 = !strcmp(main_ip4, guess_ip4))) {
172  struct in_addr in;
173 
174  in.s_addr = mask;
175  switch_set_string(old_ip4, main_ip4);
176  switch_set_string(main_ip4, guess_ip4);
177  switch_core_set_variable("local_ip_v4", guess_ip4);
178  switch_core_set_variable("local_mask_v4", inet_ntoa(in));
179  }
180  }
181 
182  if (check6 != SWITCH_STATUS_SUCCESS) {
183  ok6 = 2;
184  } else if (!*main_ip6) {
185  switch_set_string(main_ip6, guess_ip6);
186  } else {
187  if (!(ok6 = !strcmp(main_ip6, guess_ip6))) {
188  switch_set_string(old_ip6, main_ip6);
189  switch_set_string(main_ip6, guess_ip6);
190  switch_core_set_variable("local_ip_v6", guess_ip6);
191  }
192  }
193 
194  if (!ok4 || !ok6) {
195  if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
196  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "network-address-change");
197  if (!ok4) {
198  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-previous-v4", old_ip4);
199  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-change-v4", main_ip4);
200  }
201  if (!ok6) {
202  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-previous-v6", old_ip6);
203  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-change-v6", main_ip6);
204  }
205  switch_event_fire(&event);
206  }
207  }
208 
209  if (ok4 == 2 || ok6 == 2) {
210  if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
211  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "network-outage");
212 
213  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-status-v4", ok4 == 2 ? "disconnected" : "active");
214  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-v4", main_ip4);
215 
216  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-status-v6", ok6 == 2 ? "disconnected" : "active");
217  switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-v6", main_ip6);
218 
219  switch_event_fire(&event);
220  }
221  }
222 
223 }
224 
225 SWITCH_STANDARD_SCHED_FUNC(heartbeat_callback)
226 {
227  send_heartbeat();
228 
229  /* reschedule this task */
230  task->runtime = switch_epoch_time_now(NULL) + runtime.event_heartbeat_interval;
231 }
232 
233 
234 SWITCH_STANDARD_SCHED_FUNC(check_ip_callback)
235 {
236  check_ip();
237 
238  /* reschedule this task */
239  task->runtime = switch_epoch_time_now(NULL) + 60;
240 }
241 
242 
243 SWITCH_DECLARE(switch_status_t) switch_core_set_console(const char *console)
244 {
245  if ((runtime.console = fopen(console, "a")) == 0) {
246  fprintf(stderr, "Cannot open output file %s.\n", console);
247  return SWITCH_STATUS_FALSE;
248  }
249 
250  return SWITCH_STATUS_SUCCESS;
251 }
252 
253 SWITCH_DECLARE(FILE *) switch_core_get_console(void)
254 {
255  return runtime.console;
256 }
257 
258 #ifdef HAVE_SYS_IOCTL_H
259 #include <sys/ioctl.h>
260 #endif
261 SWITCH_DECLARE(void) switch_core_screen_size(int *x, int *y)
262 {
263 
264 #ifdef WIN32
265  CONSOLE_SCREEN_BUFFER_INFO csbi;
266  int ret;
267 
268  if ((ret = GetConsoleScreenBufferInfo(GetStdHandle( STD_OUTPUT_HANDLE ), &csbi))) {
269  if (x) *x = csbi.dwSize.X;
270  if (y) *y = csbi.dwSize.Y;
271  }
272 
273 #elif defined(TIOCGWINSZ)
274  struct winsize w;
275  ioctl(0, TIOCGWINSZ, &w);
276 
277  if (x) *x = w.ws_col;
278  if (y) *y = w.ws_row;
279 #else
280  if (x) *x = 80;
281  if (y) *y = 24;
282 #endif
283 
284 }
285 
286 SWITCH_DECLARE(FILE *) switch_core_data_channel(switch_text_channel_t channel)
287 {
288  return runtime.console;
289 }
290 
291 
292 SWITCH_DECLARE(void) switch_core_remove_state_handler(const switch_state_handler_table_t *state_handler)
293 {
294  int index, tmp_index = 0;
295  const switch_state_handler_table_t *tmp[SWITCH_MAX_STATE_HANDLERS + 1] = { 0 };
296 
297  switch_mutex_lock(runtime.global_mutex);
298 
299  for (index = 0; index < runtime.state_handler_index; index++) {
300  const switch_state_handler_table_t *cur = runtime.state_handlers[index];
301  runtime.state_handlers[index] = NULL;
302  if (cur == state_handler) {
303  continue;
304  }
305  tmp[tmp_index++] = cur;
306  }
307 
308  runtime.state_handler_index = 0;
309 
310  for (index = 0; index < tmp_index; index++) {
311  runtime.state_handlers[runtime.state_handler_index++] = tmp[index];
312  }
313  switch_mutex_unlock(runtime.global_mutex);
314 }
315 
316 
317 SWITCH_DECLARE(int) switch_core_add_state_handler(const switch_state_handler_table_t *state_handler)
318 {
319  int index;
320 
321  switch_mutex_lock(runtime.global_mutex);
322  index = runtime.state_handler_index;
323 
324  if (index > (SWITCH_MAX_STATE_HANDLERS - 1)) {
325  index = -1;
326  } else {
327  runtime.state_handlers[index] = state_handler;
328  runtime.state_handler_index++;
329  }
330 
331  switch_mutex_unlock(runtime.global_mutex);
332  return index;
333 }
334 
335 SWITCH_DECLARE(const switch_state_handler_table_t *) switch_core_get_state_handler(int index)
336 {
337 
338  if (index >= SWITCH_MAX_STATE_HANDLERS || index > runtime.state_handler_index) {
339  return NULL;
340  }
341 
342  return runtime.state_handlers[index];
343 }
344 
345 SWITCH_DECLARE(void) switch_core_dump_variables(switch_stream_handle_t *stream)
346 {
347  switch_event_header_t *hi;
348 
349  switch_mutex_lock(runtime.global_mutex);
350  for (hi = runtime.global_vars->headers; hi; hi = hi->next) {
351  stream->write_function(stream, "%s=%s\n", hi->name, hi->value);
352  }
353  switch_mutex_unlock(runtime.global_mutex);
354 }
355 
356 SWITCH_DECLARE(const char *) switch_core_get_hostname(void)
357 {
358  return runtime.hostname;
359 }
360 
361 SWITCH_DECLARE(const char *) switch_core_get_switchname(void)
362 {
363  if (!zstr(runtime.switchname)) return runtime.switchname;
364  return runtime.hostname;
365 }
366 
367 SWITCH_DECLARE(char *) switch_core_get_domain(switch_bool_t dup)
368 {
369  char *domain;
370  const char *var;
371 
372  switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
373  if (!(var = switch_core_get_variable("domain"))) {
374  var = "freeswitch.local";
375  }
376  if (dup) {
377  domain = strdup(var);
378  } else {
379  domain = (char *) var;
380  }
381  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
382 
383  return domain;
384 }
385 
386 SWITCH_DECLARE(switch_status_t) switch_core_get_variables(switch_event_t **event)
387 {
388  switch_status_t status;
389  switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
390  status = switch_event_dup(event, runtime.global_vars);
391  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
392  return status;
393 }
394 
395 SWITCH_DECLARE(char *) switch_core_get_variable(const char *varname)
396 {
397  char *val;
398  switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
399  val = (char *) switch_event_get_header(runtime.global_vars, varname);
400  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
401  return val;
402 }
403 
404 SWITCH_DECLARE(char *) switch_core_get_variable_dup(const char *varname)
405 {
406  char *val = NULL, *v;
407 
408  if (varname) {
409  switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
410  if ((v = (char *) switch_event_get_header(runtime.global_vars, varname))) {
411  val = strdup(v);
412  }
413  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
414  }
415 
416  return val;
417 }
418 
419 SWITCH_DECLARE(char *) switch_core_get_variable_pdup(const char *varname, switch_memory_pool_t *pool)
420 {
421  char *val = NULL, *v;
422 
423  if (varname) {
424  switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
425  if ((v = (char *) switch_event_get_header(runtime.global_vars, varname))) {
426  val = switch_core_strdup(pool, v);
427  }
428  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
429  }
430 
431  return val;
432 }
433 
434 static void switch_core_unset_variables(void)
435 {
436  switch_thread_rwlock_wrlock(runtime.global_var_rwlock);
437  switch_event_destroy(&runtime.global_vars);
438  switch_event_create_plain(&runtime.global_vars, SWITCH_EVENT_CHANNEL_DATA);
439  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
440 }
441 
442 SWITCH_DECLARE(void) switch_core_set_variable(const char *varname, const char *value)
443 {
444  char *val;
445 
446  if (varname) {
447  switch_thread_rwlock_wrlock(runtime.global_var_rwlock);
448  val = (char *) switch_event_get_header(runtime.global_vars, varname);
449  if (val) {
450  switch_event_del_header(runtime.global_vars, varname);
451  }
452  if (value) {
453  char *v = strdup(value);
454  switch_string_var_check(v, SWITCH_TRUE);
455  switch_event_add_header_string(runtime.global_vars, SWITCH_STACK_BOTTOM, varname, v);
456  free(v);
457  } else {
458  switch_event_del_header(runtime.global_vars, varname);
459  }
460  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
461  }
462 }
463 
464 SWITCH_DECLARE(switch_bool_t) switch_core_set_var_conditional(const char *varname, const char *value, const char *val2)
465 {
466  char *val;
467 
468  if (varname) {
469  switch_thread_rwlock_wrlock(runtime.global_var_rwlock);
470  val = (char *) switch_event_get_header(runtime.global_vars, varname);
471 
472  if (val) {
473  if (!val2 || strcmp(val, val2) != 0) {
474  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
475  return SWITCH_FALSE;
476  }
477  switch_event_del_header(runtime.global_vars, varname);
478  } else if (!zstr(val2)) {
479  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
480  return SWITCH_FALSE;
481  }
482 
483  if (value) {
484  char *v = strdup(value);
485  switch_string_var_check(v, SWITCH_TRUE);
486  switch_event_add_header_string_nodup(runtime.global_vars, SWITCH_STACK_BOTTOM, varname, v);
487  } else {
488  switch_event_del_header(runtime.global_vars, varname);
489  }
490  switch_thread_rwlock_unlock(runtime.global_var_rwlock);
491  }
492  return SWITCH_TRUE;
493 }
494 
495 SWITCH_DECLARE(char *) switch_core_get_uuid(void)
496 {
497  return runtime.uuid_str;
498 }
499 
500 
501 static void *SWITCH_THREAD_FUNC switch_core_service_thread(switch_thread_t *thread, void *obj)
502 {
503  switch_core_session_t *session = obj;
504  switch_channel_t *channel;
505  switch_frame_t *read_frame = NULL;
506 
507 // switch_assert(thread != NULL);
508 // switch_assert(session != NULL);
509 
510  if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
511  return NULL;
512  }
513 
514  switch_mutex_lock(session->frame_read_mutex);
515 
516  channel = switch_core_session_get_channel(session);
517 
518  switch_channel_set_flag(channel, CF_SERVICE);
519  while (switch_channel_test_flag(channel, CF_SERVICE)) {
520 
521  if (switch_channel_test_flag(channel, CF_SERVICE_AUDIO)) {
522  switch (switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0)) {
523  case SWITCH_STATUS_SUCCESS:
524  case SWITCH_STATUS_TIMEOUT:
525  case SWITCH_STATUS_BREAK:
526  break;
527  default:
528  switch_channel_clear_flag(channel, CF_SERVICE);
529  break;
530  }
531  }
532 
533  if (switch_channel_test_flag(channel, CF_SERVICE_VIDEO) && switch_channel_test_flag(channel, CF_VIDEO)) {
534  switch (switch_core_session_read_video_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0)) {
535  case SWITCH_STATUS_SUCCESS:
536  case SWITCH_STATUS_TIMEOUT:
537  case SWITCH_STATUS_BREAK:
538  break;
539  default:
540  switch_channel_clear_flag(channel, CF_SERVICE);
541  break;
542  }
543  }
544  }
545 
546  switch_mutex_unlock(session->frame_read_mutex);
547 
548  switch_channel_clear_flag(channel, CF_SERVICE_AUDIO);
549  switch_channel_clear_flag(channel, CF_SERVICE_VIDEO);
550 
551  switch_core_session_rwunlock(session);
552 
553  return NULL;
554 }
555 
556 /* Either add a timeout here or make damn sure the thread cannot get hung somehow (my preference) */
557 SWITCH_DECLARE(void) switch_core_thread_session_end(switch_core_session_t *session)
558 {
559  switch_channel_t *channel;
560  switch_assert(session);
561 
562  channel = switch_core_session_get_channel(session);
563  switch_assert(channel);
564 
565  switch_channel_clear_flag(channel, CF_SERVICE);
566  switch_channel_clear_flag(channel, CF_SERVICE_AUDIO);
567  switch_channel_clear_flag(channel, CF_SERVICE_VIDEO);
568 
569  switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
570 
571 }
572 
573 SWITCH_DECLARE(void) switch_core_service_session_av(switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)
574 {
575  switch_channel_t *channel;
576  switch_assert(session);
577 
578  channel = switch_core_session_get_channel(session);
579  switch_assert(channel);
580 
581  if (audio) switch_channel_set_flag(channel, CF_SERVICE_AUDIO);
582  if (video) switch_channel_set_flag(channel, CF_SERVICE_VIDEO);
583 
584  switch_core_session_launch_thread(session, (void *(*)(switch_thread_t *,void *))switch_core_service_thread, session);
585 }
586 
587 /* This function abstracts the thread creation for modules by allowing you to pass a function ptr and
588  a void object and trust that that the function will be run in a thread with arg This lets
589  you request and activate a thread without giving up any knowledge about what is in the thread
590  neither the core nor the calling module know anything about each other.
591 
592  This thread is expected to never exit until the application exits so the func is responsible
593  to make sure that is the case.
594 
595  The typical use for this is so switch_loadable_module.c can start up a thread for each module
596  passing the table of module methods as a session obj into the core without actually allowing
597  the core to have any clue and keeping switch_loadable_module.c from needing any thread code.
598 
599 */
600 
601 SWITCH_DECLARE(switch_thread_t *) switch_core_launch_thread(switch_thread_start_t func, void *obj, switch_memory_pool_t *pool)
602 {
603  switch_thread_t *thread = NULL;
604  switch_threadattr_t *thd_attr = NULL;
605  switch_core_thread_session_t *ts;
606  int mypool;
607 
608  mypool = pool ? 0 : 1;
609 
610  if (!pool && switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
611  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory pool\n");
612  return NULL;
613  }
614 
615  switch_threadattr_create(&thd_attr, pool);
616 
617  if ((ts = switch_core_alloc(pool, sizeof(*ts))) == 0) {
618  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory\n");
619  } else {
620  if (mypool) {
621  ts->pool = pool;
622  }
623  ts->objs[0] = obj;
624  ts->objs[1] = thread;
625  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
626  switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
627  switch_thread_create(&thread, thd_attr, func, ts, pool);
628  }
629 
630  return thread;
631 }
632 
633 SWITCH_DECLARE(void) switch_core_set_globals(void)
634 {
635 #define BUFSIZE 1024
636 #ifdef WIN32
637  char lpPathBuffer[BUFSIZE];
638  DWORD dwBufSize = BUFSIZE;
639  char base_dir[1024];
640  char *lastbacklash;
641  char *tmp;
642 
643  GetModuleFileName(NULL, base_dir, BUFSIZE);
644  lastbacklash = strrchr(base_dir, '\\');
645  base_dir[(lastbacklash - base_dir)] = '\0';
646  /* set base_dir as cwd, to be able to use relative paths in scripting languages (e.g. mod_lua) when FS is running as a service or while debugging FS using visual studio */
647  SetCurrentDirectory(base_dir);
648  tmp = switch_string_replace(base_dir, "\\", "/");
649  strcpy(base_dir, tmp);
650  free(tmp);
651 
652 #else
653  char base_dir[1024] = SWITCH_PREFIX_DIR;
654 #endif
655 
656  /* Order of precedence for, eg, rundir:
657  * -run
658  * -base
659  * --with-rundir
660  * --prefix
661  */
662 
663  if (!SWITCH_GLOBAL_dirs.mod_dir && (SWITCH_GLOBAL_dirs.mod_dir = (char *) malloc(BUFSIZE))) {
664  if (SWITCH_GLOBAL_dirs.base_dir)
665  switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s%smod", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
666  else
667 #ifdef SWITCH_MOD_DIR
668  switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s", SWITCH_MOD_DIR);
669 #else
670  switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s%smod", base_dir, SWITCH_PATH_SEPARATOR);
671 #endif
672  }
673 
674  if (!SWITCH_GLOBAL_dirs.lib_dir && (SWITCH_GLOBAL_dirs.lib_dir = (char *) malloc(BUFSIZE))) {
675  if (SWITCH_GLOBAL_dirs.base_dir)
676  switch_snprintf(SWITCH_GLOBAL_dirs.lib_dir, BUFSIZE, "%s%slib", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
677  else
678 #ifdef SWITCH_LIB_DIR
679  switch_snprintf(SWITCH_GLOBAL_dirs.lib_dir, BUFSIZE, "%s", SWITCH_LIB_DIR);
680 #else
681  switch_snprintf(SWITCH_GLOBAL_dirs.lib_dir, BUFSIZE, "%s%slib", base_dir, SWITCH_PATH_SEPARATOR);
682 #endif
683  }
684 
685  if (!SWITCH_GLOBAL_dirs.conf_dir && (SWITCH_GLOBAL_dirs.conf_dir = (char *) malloc(BUFSIZE))) {
686  if (SWITCH_GLOBAL_dirs.base_dir)
687  switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s%sconf", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
688  else
689 #ifdef SWITCH_CONF_DIR
690  switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s", SWITCH_CONF_DIR);
691 #else
692  switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s%sconf", base_dir, SWITCH_PATH_SEPARATOR);
693 #endif
694  }
695 
696  if (!SWITCH_GLOBAL_dirs.log_dir && (SWITCH_GLOBAL_dirs.log_dir = (char *) malloc(BUFSIZE))) {
697  if (SWITCH_GLOBAL_dirs.base_dir)
698  switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s%slog", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
699  else
700 #ifdef SWITCH_LOG_DIR
701  switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s", SWITCH_LOG_DIR);
702 #else
703  switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s%slog", base_dir, SWITCH_PATH_SEPARATOR);
704 #endif
705  }
706 
707  if (!SWITCH_GLOBAL_dirs.run_dir && (SWITCH_GLOBAL_dirs.run_dir = (char *) malloc(BUFSIZE))) {
708  if (SWITCH_GLOBAL_dirs.base_dir)
709  switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s%srun", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
710  else
711 #ifdef SWITCH_RUN_DIR
712  switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s", SWITCH_RUN_DIR);
713 #else
714  switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s%srun", base_dir, SWITCH_PATH_SEPARATOR);
715 #endif
716  }
717 
718  if (!SWITCH_GLOBAL_dirs.recordings_dir && (SWITCH_GLOBAL_dirs.recordings_dir = (char *) malloc(BUFSIZE))) {
719  if (SWITCH_GLOBAL_dirs.base_dir)
720  switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s%srecordings", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
721  else
722 #ifdef SWITCH_RECORDINGS_DIR
723  switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s", SWITCH_RECORDINGS_DIR);
724 #else
725  switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s%srecordings", base_dir, SWITCH_PATH_SEPARATOR);
726 #endif
727  }
728 
729  if (!SWITCH_GLOBAL_dirs.sounds_dir && (SWITCH_GLOBAL_dirs.sounds_dir = (char *) malloc(BUFSIZE))) {
730  if (SWITCH_GLOBAL_dirs.base_dir)
731  switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s%ssounds", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
732  else
733 #ifdef SWITCH_SOUNDS_DIR
734  switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s", SWITCH_SOUNDS_DIR);
735 #else
736  switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s%ssounds", base_dir, SWITCH_PATH_SEPARATOR);
737 #endif
738  }
739 
740  if (!SWITCH_GLOBAL_dirs.storage_dir && (SWITCH_GLOBAL_dirs.storage_dir = (char *) malloc(BUFSIZE))) {
741  if (SWITCH_GLOBAL_dirs.base_dir)
742  switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s%sstorage", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
743  else
744 #ifdef SWITCH_STORAGE_DIR
745  switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s", SWITCH_STORAGE_DIR);
746 #else
747  switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s%sstorage", base_dir, SWITCH_PATH_SEPARATOR);
748 #endif
749  }
750 
751  if (!SWITCH_GLOBAL_dirs.cache_dir && (SWITCH_GLOBAL_dirs.cache_dir = (char *) malloc(BUFSIZE))) {
752  if (SWITCH_GLOBAL_dirs.base_dir)
753  switch_snprintf(SWITCH_GLOBAL_dirs.cache_dir, BUFSIZE, "%s%scache", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
754  else
755 #ifdef SWITCH_CACHE_DIR
756  switch_snprintf(SWITCH_GLOBAL_dirs.cache_dir, BUFSIZE, "%s", SWITCH_CACHE_DIR);
757 #else
758  switch_snprintf(SWITCH_GLOBAL_dirs.cache_dir, BUFSIZE, "%s%scache", base_dir, SWITCH_PATH_SEPARATOR);
759 #endif
760  }
761 
762  if (!SWITCH_GLOBAL_dirs.db_dir && (SWITCH_GLOBAL_dirs.db_dir = (char *) malloc(BUFSIZE))) {
763  if (SWITCH_GLOBAL_dirs.base_dir)
764  switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s%sdb", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
765  else
766 #ifdef SWITCH_DB_DIR
767  switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s", SWITCH_DB_DIR);
768 #else
769  switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s%sdb", base_dir, SWITCH_PATH_SEPARATOR);
770 #endif
771  }
772 
773  if (!SWITCH_GLOBAL_dirs.script_dir && (SWITCH_GLOBAL_dirs.script_dir = (char *) malloc(BUFSIZE))) {
774  if (SWITCH_GLOBAL_dirs.base_dir)
775  switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s%sscripts", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
776  else
777 #ifdef SWITCH_SCRIPT_DIR
778  switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s", SWITCH_SCRIPT_DIR);
779 #else
780  switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s%sscripts", base_dir, SWITCH_PATH_SEPARATOR);
781 #endif
782  }
783 
784  if (!SWITCH_GLOBAL_dirs.htdocs_dir && (SWITCH_GLOBAL_dirs.htdocs_dir = (char *) malloc(BUFSIZE))) {
785  if (SWITCH_GLOBAL_dirs.base_dir)
786  switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s%shtdocs", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
787  else
788 #ifdef SWITCH_HTDOCS_DIR
789  switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s", SWITCH_HTDOCS_DIR);
790 #else
791  switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s%shtdocs", base_dir, SWITCH_PATH_SEPARATOR);
792 #endif
793  }
794 
795  if (!SWITCH_GLOBAL_dirs.grammar_dir && (SWITCH_GLOBAL_dirs.grammar_dir = (char *) malloc(BUFSIZE))) {
796  if (SWITCH_GLOBAL_dirs.base_dir)
797  switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s%sgrammar", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
798  else
799 #ifdef SWITCH_GRAMMAR_DIR
800  switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s", SWITCH_GRAMMAR_DIR);
801 #else
802  switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s%sgrammar", base_dir, SWITCH_PATH_SEPARATOR);
803 #endif
804  }
805 
806  if (!SWITCH_GLOBAL_dirs.fonts_dir && (SWITCH_GLOBAL_dirs.fonts_dir = (char *) malloc(BUFSIZE))) {
807  if (SWITCH_GLOBAL_dirs.base_dir)
808  switch_snprintf(SWITCH_GLOBAL_dirs.fonts_dir, BUFSIZE, "%s%sfonts", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
809  else
810 #ifdef SWITCH_FONTS_DIR
811  switch_snprintf(SWITCH_GLOBAL_dirs.fonts_dir, BUFSIZE, "%s", SWITCH_FONTS_DIR);
812 #else
813  switch_snprintf(SWITCH_GLOBAL_dirs.fonts_dir, BUFSIZE, "%s%sfonts", base_dir, SWITCH_PATH_SEPARATOR);
814 #endif
815  }
816 
817  if (!SWITCH_GLOBAL_dirs.images_dir && (SWITCH_GLOBAL_dirs.images_dir = (char *) malloc(BUFSIZE))) {
818  if (SWITCH_GLOBAL_dirs.base_dir)
819  switch_snprintf(SWITCH_GLOBAL_dirs.images_dir, BUFSIZE, "%s%simages", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
820  else
821 #ifdef SWITCH_IMAGES_DIR
822  switch_snprintf(SWITCH_GLOBAL_dirs.images_dir, BUFSIZE, "%s", SWITCH_IMAGES_DIR);
823 #else
824  switch_snprintf(SWITCH_GLOBAL_dirs.images_dir, BUFSIZE, "%s%simages", base_dir, SWITCH_PATH_SEPARATOR);
825 #endif
826  }
827 
828  if (!SWITCH_GLOBAL_dirs.data_dir && (SWITCH_GLOBAL_dirs.data_dir = (char *) malloc(BUFSIZE))) {
829  if (SWITCH_GLOBAL_dirs.base_dir)
830  switch_snprintf(SWITCH_GLOBAL_dirs.data_dir, BUFSIZE, "%s", SWITCH_GLOBAL_dirs.base_dir);
831  else
832 #ifdef SWITCH_DATA_DIR
833  switch_snprintf(SWITCH_GLOBAL_dirs.data_dir, BUFSIZE, "%s", SWITCH_DATA_DIR);
834 #else
835  switch_snprintf(SWITCH_GLOBAL_dirs.data_dir, BUFSIZE, "%s", base_dir);
836 #endif
837  }
838 
839  if (!SWITCH_GLOBAL_dirs.localstate_dir && (SWITCH_GLOBAL_dirs.localstate_dir = (char *) malloc(BUFSIZE))) {
840  if (SWITCH_GLOBAL_dirs.base_dir)
841  switch_snprintf(SWITCH_GLOBAL_dirs.localstate_dir, BUFSIZE, "%s", SWITCH_GLOBAL_dirs.base_dir);
842  else
843 #ifdef SWITCH_LOCALSTATE_DIR
844  switch_snprintf(SWITCH_GLOBAL_dirs.localstate_dir, BUFSIZE, "%s", SWITCH_LOCALSTATE_DIR);
845 #else
846  switch_snprintf(SWITCH_GLOBAL_dirs.localstate_dir, BUFSIZE, "%s", base_dir);
847 #endif
848  }
849 
850  if (!SWITCH_GLOBAL_dirs.certs_dir && (SWITCH_GLOBAL_dirs.certs_dir = (char *) malloc(BUFSIZE))) {
851  if (SWITCH_GLOBAL_dirs.base_dir)
852  switch_snprintf(SWITCH_GLOBAL_dirs.certs_dir, BUFSIZE, "%s%scert", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
853  else
854 #ifdef SWITCH_CERTS_DIR
855  switch_snprintf(SWITCH_GLOBAL_dirs.certs_dir, BUFSIZE, "%s", SWITCH_CERTS_DIR);
856 #else
857  switch_snprintf(SWITCH_GLOBAL_dirs.certs_dir, BUFSIZE, "%s%scert", base_dir, SWITCH_PATH_SEPARATOR);
858 #endif
859  }
860 
861  if (!SWITCH_GLOBAL_dirs.temp_dir && (SWITCH_GLOBAL_dirs.temp_dir = (char *) malloc(BUFSIZE))) {
862 #ifdef SWITCH_TEMP_DIR
863  switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", SWITCH_TEMP_DIR);
864 #else
865 #ifdef WIN32
866  GetTempPath(dwBufSize, lpPathBuffer);
867  lpPathBuffer[strlen(lpPathBuffer)-1] = 0;
868  tmp = switch_string_replace(lpPathBuffer, "\\", "/");
869  strcpy(lpPathBuffer, tmp);
870  free(tmp);
871  switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", lpPathBuffer);
872 #else
873  switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", "/tmp");
874 #endif
875 #endif
876  }
877 
878  if (!SWITCH_GLOBAL_filenames.conf_name && (SWITCH_GLOBAL_filenames.conf_name = (char *) malloc(BUFSIZE))) {
879  switch_snprintf(SWITCH_GLOBAL_filenames.conf_name, BUFSIZE, "%s", "freeswitch.xml");
880  }
881 
882  /* Do this last because it being empty is part of the above logic */
883  if (!SWITCH_GLOBAL_dirs.base_dir && (SWITCH_GLOBAL_dirs.base_dir = (char *) malloc(BUFSIZE))) {
884  switch_snprintf(SWITCH_GLOBAL_dirs.base_dir, BUFSIZE, "%s", base_dir);
885  }
886 
887  switch_assert(SWITCH_GLOBAL_dirs.base_dir);
888  switch_assert(SWITCH_GLOBAL_dirs.mod_dir);
889  switch_assert(SWITCH_GLOBAL_dirs.lib_dir);
890  switch_assert(SWITCH_GLOBAL_dirs.conf_dir);
891  switch_assert(SWITCH_GLOBAL_dirs.log_dir);
892  switch_assert(SWITCH_GLOBAL_dirs.run_dir);
893  switch_assert(SWITCH_GLOBAL_dirs.db_dir);
894  switch_assert(SWITCH_GLOBAL_dirs.script_dir);
895  switch_assert(SWITCH_GLOBAL_dirs.htdocs_dir);
896  switch_assert(SWITCH_GLOBAL_dirs.grammar_dir);
897  switch_assert(SWITCH_GLOBAL_dirs.fonts_dir);
898  switch_assert(SWITCH_GLOBAL_dirs.images_dir);
899  switch_assert(SWITCH_GLOBAL_dirs.recordings_dir);
900  switch_assert(SWITCH_GLOBAL_dirs.sounds_dir);
901  switch_assert(SWITCH_GLOBAL_dirs.certs_dir);
902  switch_assert(SWITCH_GLOBAL_dirs.temp_dir);
903  switch_assert(SWITCH_GLOBAL_dirs.data_dir);
904  switch_assert(SWITCH_GLOBAL_dirs.localstate_dir);
905 
906  switch_assert(SWITCH_GLOBAL_filenames.conf_name);
907 }
908 
909 
910 SWITCH_DECLARE(int32_t) switch_core_set_process_privileges(void)
911 {
912 #ifdef SOLARIS_PRIVILEGES
913  priv_set_t *basicset;
914 
915  /* make the process privilege-aware */
916  setpflags(PRIV_AWARE, 1);
917 
918  /* reset the privileges to basic */
919  basicset = priv_str_to_set("basic", ",", NULL);
920  if (setppriv(PRIV_SET, PRIV_EFFECTIVE, basicset) != 0) {
921  fprintf(stderr, "ERROR: Failed to acquire basic privileges (%s)\n", strerror(errno));
922  }
923 
924  /* we need high-resolution clock, and this requires a non-basic privilege */
925  if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_CLOCK_HIGHRES, NULL) < 0) {
926  fprintf(stderr, "ERROR: Failed to acquire proc_clock_highres privilege (%s)\n", strerror(errno));
927  return -1;
928  }
929 
930  /* need this for setrlimit */
931  if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_RESOURCE, NULL) < 0) {
932  fprintf(stderr, "ERROR: Failed to acquire sys_resource privilege (%s)\n", strerror(errno));
933  return -1;
934  }
935 
936  /* we need to read directories belonging to other uid */
937  if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_FILE_DAC_SEARCH, NULL) < 0) {
938  fprintf(stderr, "ERROR: Failed to acquire file_dac_search privilege (%s)\n", strerror(errno));
939  return -1;
940  }
941 #endif
942  return 0;
943 }
944 
945 SWITCH_DECLARE(int32_t) set_low_priority(void)
946 {
947 #ifdef WIN32
948  return SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
949 #else
950 #if defined(USE_SCHED_SETSCHEDULER) && ! defined(SOLARIS_PRIVILEGES)
951  /*
952  * Try to use a normal scheduler
953  */
954  struct sched_param sched = { 0 };
955  sched.sched_priority = 0;
956  if (sched_setscheduler(0, SCHED_OTHER, &sched) < 0) {
957  fprintf(stderr, "ERROR: Failed to set SCHED_OTHER scheduler (%s)\n", strerror(errno));
958  return -1;
959  }
960 #endif
961 
962 #ifdef HAVE_SETPRIORITY
963  /*
964  * setpriority() works on FreeBSD (6.2), nice() doesn't
965  */
966  if (setpriority(PRIO_PROCESS, getpid(), 19) < 0) {
967  fprintf(stderr, "ERROR: Could not set nice level\n");
968  return -1;
969  }
970 #else
971  if (nice(19) != 19) {
972  fprintf(stderr, "ERROR: Could not set nice level\n");
973  return -1;
974  }
975 #endif
976 
977  return 0;
978 #endif
979 }
980 
981 SWITCH_DECLARE(int32_t) set_realtime_priority(void)
982 {
983 #ifdef WIN32
984  return SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
985 #else
986 #ifdef USE_SCHED_SETSCHEDULER
987  /*
988  * Try to use a round-robin scheduler
989  * with a fallback if that does not work
990  */
991  struct sched_param sched = { 0 };
992  sched.sched_priority = SWITCH_PRI_LOW;
993 #endif
994 
995 #ifdef SOLARIS_PRIVILEGES
996  /* request the privileges to elevate the priority */
997  if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_PRIOCNTL, NULL) < 0) {
998 #ifdef PRIV_PROC_PRIOUP
999  /* fallback to PRIV_PROC_PRIOUP on SmartOS */
1000  fprintf(stderr, "WARN: Failed to acquire proc_priocntl privilege (%s)\n", strerror(errno));
1001  if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_PRIOUP, NULL) < 0) {
1002  fprintf(stderr, "ERROR: Failed to acquire proc_prioup privilege (%s)\n", strerror(errno));
1003  return -1;
1004  }
1005 #else
1006  fprintf(stderr, "ERROR: Failed to acquire proc_priocntl privilege (%s)\n", strerror(errno));
1007  return -1;
1008 #endif
1009  }
1010 
1011  if (sched_setscheduler(0, SCHED_FIFO, &sched) < 0) {
1012  fprintf(stderr, "WARN: Failed to set SCHED_FIFO scheduler (%s)\n", strerror(errno));
1013  } else {
1014  return 0;
1015  }
1016 
1017  if (setpriority(PRIO_PROCESS, 0, -10) < 0) {
1018  fprintf(stderr, "ERROR: Could not set nice level\n");
1019  return -1;
1020  }
1021 
1022  return 0;
1023 #else
1024 
1025 #ifdef USE_SCHED_SETSCHEDULER
1026  if (sched_setscheduler(0, SCHED_FIFO, &sched) < 0) {
1027  fprintf(stderr, "ERROR: Failed to set SCHED_FIFO scheduler (%s)\n", strerror(errno));
1028  sched.sched_priority = 0;
1029  if (sched_setscheduler(0, SCHED_OTHER, &sched) < 0 ) {
1030  fprintf(stderr, "ERROR: Failed to set SCHED_OTHER scheduler (%s)\n", strerror(errno));
1031  return -1;
1032  }
1033  }
1034 #endif
1035 
1036 #ifdef HAVE_SETPRIORITY
1037  /*
1038  * setpriority() works on FreeBSD (6.2), nice() doesn't
1039  */
1040  if (setpriority(PRIO_PROCESS, getpid(), -10) < 0) {
1041  fprintf(stderr, "ERROR: Could not set nice level\n");
1042  return -1;
1043  }
1044 #else
1045  if (nice(-10) != -10) {
1046  fprintf(stderr, "ERROR: Could not set nice level\n");
1047  return -1;
1048  }
1049 #endif
1050 #endif
1051  return 0;
1052 #endif
1053 }
1054 
1055 SWITCH_DECLARE(uint32_t) switch_core_cpu_count(void)
1056 {
1057  return runtime.cpu_count;
1058 }
1059 
1060 SWITCH_DECLARE(int32_t) set_normal_priority(void)
1061 {
1062  return 0;
1063 }
1064 
1065 SWITCH_DECLARE(int32_t) set_auto_priority(void)
1066 {
1067 #ifndef WIN32
1068  runtime.cpu_count = sysconf (_SC_NPROCESSORS_ONLN);
1069 #else
1070  SYSTEM_INFO sysinfo;
1071  GetSystemInfo( &sysinfo );
1072  runtime.cpu_count = sysinfo.dwNumberOfProcessors;
1073 #endif
1074 
1075  if (!runtime.cpu_count) runtime.cpu_count = 1;
1076 
1077  return set_realtime_priority();
1078 
1079 
1080  // ERROR: code not reachable on Windows Visual Studio Express 2008 return 0;
1081 }
1082 
1083 SWITCH_DECLARE(int32_t) change_user_group(const char *user, const char *group)
1084 {
1085 #ifndef WIN32
1086  uid_t runas_uid = 0;
1087  gid_t runas_gid = 0;
1088  struct passwd *runas_pw = NULL;
1089 
1090  if (user) {
1091  /*
1092  * Lookup user information in the system's db
1093  */
1094  runas_pw = getpwnam(user);
1095  if (!runas_pw) {
1096  fprintf(stderr, "ERROR: Unknown user \"%s\"\n", user);
1097  return -1;
1098  }
1099  runas_uid = runas_pw->pw_uid;
1100  }
1101 
1102  if (group) {
1103  struct group *gr = NULL;
1104 
1105  /*
1106  * Lookup group information in the system's db
1107  */
1108  gr = getgrnam(group);
1109  if (!gr) {
1110  fprintf(stderr, "ERROR: Unknown group \"%s\"\n", group);
1111  return -1;
1112  }
1113  runas_gid = gr->gr_gid;
1114  }
1115 
1116  if (runas_uid && getuid() == runas_uid && (!runas_gid || runas_gid == getgid())) {
1117  /* already running as the right user and group, nothing to do! */
1118  return 0;
1119  }
1120 
1121  if (runas_uid) {
1122 #ifdef SOLARIS_PRIVILEGES
1123  /* request the privilege to set the UID */
1124  if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_SETID, NULL) < 0) {
1125  fprintf(stderr, "ERROR: Failed to acquire proc_setid privilege (%s)\n", strerror(errno));
1126  return -1;
1127  }
1128 #endif
1129 #ifdef HAVE_SETGROUPS
1130  /*
1131  * Drop all group memberships prior to changing anything
1132  * or else we're going to inherit the parent's list of groups
1133  * (which is not what we want...)
1134  */
1135  if (setgroups(0, NULL) < 0) {
1136  fprintf(stderr, "ERROR: Failed to drop group access list\n");
1137  return -1;
1138  }
1139 #endif
1140  if (runas_gid) {
1141  /*
1142  * A group has been passed, switch to it
1143  * (without loading the user's other groups)
1144  */
1145  if (setgid(runas_gid) < 0) {
1146  fprintf(stderr, "ERROR: Failed to change gid!\n");
1147  return -1;
1148  }
1149  } else {
1150  /*
1151  * No group has been passed, use the user's primary group in this case
1152  */
1153  if (setgid(runas_pw->pw_gid) < 0) {
1154  fprintf(stderr, "ERROR: Failed to change gid!\n");
1155  return -1;
1156  }
1157 #ifdef HAVE_INITGROUPS
1158  /*
1159  * Set all the other groups the user is a member of
1160  * (This can be really useful for fine-grained access control)
1161  */
1162  if (initgroups(runas_pw->pw_name, runas_pw->pw_gid) < 0) {
1163  fprintf(stderr, "ERROR: Failed to set group access list for user\n");
1164  return -1;
1165  }
1166 #endif
1167  }
1168 
1169  /*
1170  * Finally drop all privileges by switching to the new userid
1171  */
1172  if (setuid(runas_uid) < 0) {
1173  fprintf(stderr, "ERROR: Failed to change uid!\n");
1174  return -1;
1175  }
1176 #ifdef HAVE_SYS_PRCTL_H
1177  if (prctl(PR_SET_DUMPABLE, 1) < 0) {
1178  fprintf(stderr, "ERROR: Failed to enable core dumps!\n");
1179  return -1;
1180  }
1181 #endif
1182  }
1183 #endif
1184  return 0;
1185 }
1186 
1187 SWITCH_DECLARE(void) switch_core_runtime_loop(int bg)
1188 {
1189 #ifdef WIN32
1190  HANDLE shutdown_event;
1191  char path[256] = "";
1192 #endif
1193  if (bg) {
1194 #ifdef WIN32
1195  switch_snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
1196  shutdown_event = CreateEvent(NULL, FALSE, FALSE, path);
1197  if (shutdown_event) {
1198  WaitForSingleObject(shutdown_event, INFINITE);
1199  }
1200 #else
1201  while (runtime.running) {
1202  switch_yield(1000000);
1203  }
1204 #endif
1205  } else {
1206  /* wait for console input */
1207  switch_console_loop();
1208  }
1209 }
1210 
1211 SWITCH_DECLARE(const char *) switch_core_mime_ext2type(const char *ext)
1212 {
1213  if (!ext) {
1214  return NULL;
1215  }
1216  return (const char *) switch_core_hash_find(runtime.mime_types, ext);
1217 }
1218 
1219 SWITCH_DECLARE(const char *) switch_core_mime_type2ext(const char *mime)
1220 {
1221  if (!mime) {
1222  return NULL;
1223  }
1224  return (const char *) switch_core_hash_find(runtime.mime_type_exts, mime);
1225 }
1226 
1227 SWITCH_DECLARE(switch_hash_index_t *) switch_core_mime_index(void)
1228 {
1229  return switch_core_hash_first(runtime.mime_types);
1230 }
1231 
1232 SWITCH_DECLARE(switch_status_t) switch_core_mime_add_type(const char *type, const char *ext)
1233 {
1234  char *ptype = NULL;
1235  char *ext_list = NULL;
1236  int argc = 0;
1237  char *argv[20] = { 0 };
1238  int x;
1239  switch_status_t status = SWITCH_STATUS_FALSE;
1240 
1241  switch_assert(type);
1242  switch_assert(ext);
1243 
1244  ptype = switch_core_permanent_strdup(type);
1245  ext_list = strdup(ext);
1246 
1247  switch_assert(ext_list);
1248 
1249  /* Map each file extension to this MIME type if not already mapped. Map the MIME type to the first file extension in the list if not already mapped. */
1250  if ((argc = switch_separate_string(ext_list, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
1251  int is_mapped_type = switch_core_hash_find(runtime.mime_type_exts, ptype) != NULL;
1252  for (x = 0; x < argc; x++) {
1253  if (argv[x] && ptype) {
1254  if (!switch_core_hash_find(runtime.mime_types, ext)) {
1255  switch_core_hash_insert(runtime.mime_types, argv[x], ptype);
1256  }
1257  if (!is_mapped_type) {
1258  switch_core_hash_insert(runtime.mime_type_exts, ptype, switch_core_permanent_strdup(argv[x]));
1259  is_mapped_type = 1;
1260  }
1261  }
1262  }
1263 
1264  status = SWITCH_STATUS_SUCCESS;
1265  }
1266 
1267  free(ext_list);
1268 
1269  return status;
1270 }
1271 
1272 static void load_mime_types(void)
1273 {
1274  char *cf = "mime.types";
1275  FILE *fd = NULL;
1276  char *line_buf = NULL;
1277  switch_size_t llen = 0;
1278  char *mime_path = NULL;
1279 
1280  mime_path = switch_mprintf("%s/%s", SWITCH_GLOBAL_dirs.conf_dir, cf);
1281  switch_assert(mime_path);
1282 
1283  fd = fopen(mime_path, "rb");
1284 
1285  if (fd == NULL) {
1286  goto end;
1287  }
1288 
1289  while ((switch_fp_read_dline(fd, &line_buf, &llen))) {
1290  char *p;
1291  char *type = line_buf;
1292 
1293  if (*line_buf == '#') {
1294  continue;
1295  }
1296 
1297  if ((p = strchr(line_buf, '\r')) || (p = strchr(line_buf, '\n'))) {
1298  *p = '\0';
1299  }
1300 
1301  if ((p = strchr(type, '\t')) || (p = strchr(type, ' '))) {
1302  *p++ = '\0';
1303 
1304  while (*p == ' ' || *p == '\t') {
1305  p++;
1306  }
1307 
1308  switch_core_mime_add_type(type, p);
1309  }
1310 
1311  }
1312 
1313  switch_safe_free(line_buf);
1314  fclose(fd);
1315 
1316  end:
1317 
1318  switch_safe_free(mime_path);
1319 
1320 }
1321 
1322 SWITCH_DECLARE(void) switch_core_setrlimits(void)
1323 {
1324 #ifdef HAVE_SETRLIMIT
1325  struct rlimit rlp;
1326 
1327  /*
1328  Setting the stack size on FreeBSD results in an instant crash.
1329 
1330  If anyone knows how to fix this,
1331  feel free to submit a patch to https://github.com/signalwire/freeswitch
1332  */
1333 
1334 #ifndef __FreeBSD__
1335  memset(&rlp, 0, sizeof(rlp));
1336  rlp.rlim_cur = SWITCH_THREAD_STACKSIZE;
1337  rlp.rlim_max = SWITCH_SYSTEM_THREAD_STACKSIZE;
1338  setrlimit(RLIMIT_STACK, &rlp);
1339 #endif
1340 
1341  memset(&rlp, 0, sizeof(rlp));
1342  rlp.rlim_cur = 999999;
1343  rlp.rlim_max = 999999;
1344  setrlimit(RLIMIT_NOFILE, &rlp);
1345 
1346  memset(&rlp, 0, sizeof(rlp));
1347  rlp.rlim_cur = RLIM_INFINITY;
1348  rlp.rlim_max = RLIM_INFINITY;
1349 
1350  setrlimit(RLIMIT_CPU, &rlp);
1351  setrlimit(RLIMIT_DATA, &rlp);
1352  setrlimit(RLIMIT_FSIZE, &rlp);
1353 #ifdef RLIMIT_NPROC
1354  setrlimit(RLIMIT_NPROC, &rlp);
1355 #endif
1356 #ifdef RLIMIT_RTPRIO
1357  setrlimit(RLIMIT_RTPRIO, &rlp);
1358 #endif
1359 
1360 #if !defined(__OpenBSD__) && !defined(__NetBSD__)
1361  setrlimit(RLIMIT_AS, &rlp);
1362 #endif
1363 #endif
1364  return;
1365 }
1366 
1367 typedef struct {
1368  switch_memory_pool_t *pool;
1369  switch_hash_t *hash;
1370 } switch_ip_list_t;
1371 
1372 static switch_ip_list_t IP_LIST = { 0 };
1373 
1374 SWITCH_DECLARE(switch_bool_t) switch_check_network_list_ip_port_token(const char *ip_str, int port, const char *list_name, const char **token)
1375 {
1376  switch_network_list_t *list;
1377  ip_t ip, mask, net;
1378  uint32_t bits;
1379  char *ipv6 = strchr(ip_str,':');
1380  switch_bool_t ok = SWITCH_FALSE;
1381  char *ipv4 = NULL;
1382 
1383  if (!list_name) {
1384  return SWITCH_FALSE;
1385  }
1386 
1387  if ((ipv4 = switch_network_ipv4_mapped_ipv6_addr(ip_str))) {
1388  ip_str = ipv4;
1389  ipv6 = NULL;
1390  }
1391 
1392  switch_mutex_lock(runtime.global_mutex);
1393  if (ipv6) {
1394  switch_inet_pton(AF_INET6, ip_str, &ip);
1395  } else {
1396  switch_inet_pton(AF_INET, ip_str, &ip);
1397  ip.v4 = htonl(ip.v4);
1398  }
1399 
1400  if ((list = switch_core_hash_find(IP_LIST.hash, list_name))) {
1401  if (ipv6) {
1402  ok = switch_network_list_validate_ip6_port_token(list, ip, port, token);
1403  } else {
1404  ok = switch_network_list_validate_ip_port_token(list, ip.v4, port, token);
1405  }
1406  } else if (strchr(list_name, '/')) {
1407  if (strchr(list_name, ',')) {
1408  char *list_name_dup = strdup(list_name);
1409  char *argv[100]; /* MAX ACL */
1410  int argc;
1411 
1412  switch_assert(list_name_dup);
1413 
1414  if ((argc = switch_separate_string(list_name_dup, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
1415  int i;
1416  for (i = 0; i < argc; i++) {
1417  switch_parse_cidr(argv[i], &net, &mask, &bits);
1418  if (ipv6) {
1419  if ((ok = switch_testv6_subnet(ip, net, mask))){
1420  break;
1421  }
1422  } else {
1423  if ((ok = switch_test_subnet(ip.v4, net.v4, mask.v4))) {
1424  break;
1425  }
1426  }
1427  }
1428  }
1429  free(list_name_dup);
1430  } else {
1431  switch_parse_cidr(list_name, &net, &mask, &bits);
1432 
1433  if (ipv6) {
1434  ok = switch_testv6_subnet(ip, net, mask);
1435  } else {
1436  ok = switch_test_subnet(ip.v4, net.v4, mask.v4);
1437  }
1438  }
1439  }
1440 
1441  switch_safe_free(ipv4);
1442  switch_mutex_unlock(runtime.global_mutex);
1443 
1444  return ok;
1445 }
1446 
1447 SWITCH_DECLARE(switch_bool_t) switch_check_network_list_ip_token(const char *ip_str, const char *list_name, const char **token)
1448 {
1449  return switch_check_network_list_ip_port_token(ip_str, 0, list_name, token);
1450 }
1451 
1452 SWITCH_DECLARE(void) switch_load_network_lists(switch_bool_t reload)
1453 {
1454  switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, x_node = NULL, cfg = NULL;
1455  switch_network_list_t *rfc_list, *list;
1456  char guess_ip[16] = "";
1457  int mask = 0;
1458  char guess_mask[16] = "";
1459  char *tmp_name;
1460  struct in_addr in;
1461 
1462  switch_find_local_ip(guess_ip, sizeof(guess_ip), &mask, AF_INET);
1463  in.s_addr = mask;
1464  switch_set_string(guess_mask, inet_ntoa(in));
1465 
1466  switch_mutex_lock(runtime.global_mutex);
1467 
1468  if (IP_LIST.hash) {
1469  switch_core_hash_destroy(&IP_LIST.hash);
1470  }
1471 
1472  if (IP_LIST.pool) {
1473  switch_core_destroy_memory_pool(&IP_LIST.pool);
1474  }
1475 
1476  memset(&IP_LIST, 0, sizeof(IP_LIST));
1477  switch_core_new_memory_pool(&IP_LIST.pool);
1478  switch_core_hash_init(&IP_LIST.hash);
1479 
1480 
1481  tmp_name = "rfc6598.auto";
1482  switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
1483  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
1484  switch_network_list_add_cidr(rfc_list, "100.64.0.0/10", SWITCH_TRUE);
1485  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1486 
1487  tmp_name = "rfc1918.auto";
1488  switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
1489  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
1490  switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_TRUE);
1491  switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_TRUE);
1492  switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_TRUE);
1493  switch_network_list_add_cidr(rfc_list, "fe80::/10", SWITCH_TRUE);
1494  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1495 
1496  tmp_name = "wan.auto";
1497  switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
1498  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
1499  switch_network_list_add_cidr(rfc_list, "0.0.0.0/8", SWITCH_FALSE);
1500  switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_FALSE);
1501  switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_FALSE);
1502  switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_FALSE);
1503  switch_network_list_add_cidr(rfc_list, "169.254.0.0/16", SWITCH_FALSE);
1504  switch_network_list_add_cidr(rfc_list, "100.64.0.0/10", SWITCH_FALSE);
1505  switch_network_list_add_cidr(rfc_list, "fe80::/10", SWITCH_FALSE);
1506  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1507 
1508  tmp_name = "wan_v6.auto";
1509  switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
1510  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
1511  switch_network_list_add_cidr(rfc_list, "0.0.0.0/0", SWITCH_FALSE);
1512  switch_network_list_add_cidr(rfc_list, "fe80::/10", SWITCH_FALSE);
1513  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1514 
1515 
1516  tmp_name = "wan_v4.auto";
1517  switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
1518  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
1519  switch_network_list_add_cidr(rfc_list, "0.0.0.0/8", SWITCH_FALSE);
1520  switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_FALSE);
1521  switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_FALSE);
1522  switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_FALSE);
1523  switch_network_list_add_cidr(rfc_list, "169.254.0.0/16", SWITCH_FALSE);
1524  switch_network_list_add_cidr(rfc_list, "100.64.0.0/10", SWITCH_FALSE);
1525  switch_network_list_add_cidr(rfc_list, "::/0", SWITCH_FALSE);
1526  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1527 
1528 
1529  tmp_name = "any_v6.auto";
1530  switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
1531  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
1532  switch_network_list_add_cidr(rfc_list, "0.0.0.0/0", SWITCH_FALSE);
1533  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1534 
1535 
1536  tmp_name = "any_v4.auto";
1537  switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
1538  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
1539  switch_network_list_add_cidr(rfc_list, "::/0", SWITCH_FALSE);
1540  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1541 
1542 
1543  tmp_name = "nat.auto";
1544  switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
1545  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
1546  if (switch_network_list_add_host_mask(rfc_list, guess_ip, guess_mask, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
1547  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (deny) to list %s\n", guess_ip, guess_mask, tmp_name);
1548  }
1549  switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_TRUE);
1550  switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_TRUE);
1551  switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_TRUE);
1552  switch_network_list_add_cidr(rfc_list, "100.64.0.0/10", SWITCH_TRUE);
1553  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1554 
1555  tmp_name = "loopback.auto";
1556  switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
1557  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
1558  switch_network_list_add_cidr(rfc_list, "127.0.0.0/8", SWITCH_TRUE);
1559  switch_network_list_add_cidr(rfc_list, "::1/128", SWITCH_TRUE);
1560  switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);
1561 
1562  tmp_name = "localnet.auto";
1563  switch_network_list_create(&list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
1564  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
1565 
1566  if (switch_network_list_add_host_mask(list, guess_ip, guess_mask, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
1567  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (allow) to list %s\n", guess_ip, guess_mask, tmp_name);
1568  }
1569  switch_core_hash_insert(IP_LIST.hash, tmp_name, list);
1570 
1571 
1572  if ((xml = switch_xml_open_cfg("acl.conf", &cfg, NULL))) {
1573  if ((x_lists = switch_xml_child(cfg, "network-lists"))) {
1574  for (x_list = switch_xml_child(x_lists, "list"); x_list; x_list = x_list->next) {
1575  const char *name = switch_xml_attr(x_list, "name");
1576  const char *dft = switch_xml_attr(x_list, "default");
1577  switch_bool_t default_type = SWITCH_TRUE;
1578 
1579  if (zstr(name)) {
1580  continue;
1581  }
1582 
1583  if (dft) {
1584  default_type = switch_true(dft);
1585  }
1586 
1587  if (switch_network_list_create(&list, name, default_type, IP_LIST.pool) != SWITCH_STATUS_SUCCESS) {
1588  abort();
1589  }
1590 
1591  if (reload) {
1592  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (%s)\n", name, default_type ? "allow" : "deny");
1593  } else {
1594  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Created ip list %s default (%s)\n", name, default_type ? "allow" : "deny");
1595  }
1596 
1597 
1598  for (x_node = switch_xml_child(x_list, "node"); x_node; x_node = x_node->next) {
1599  const char *cidr = NULL, *host = NULL, *mask = NULL, *domain = NULL, *port = NULL;
1600  switch_bool_t ok = default_type;
1601  const char *type = switch_xml_attr(x_node, "type");
1602  switch_network_port_range_t port_range;
1603  char *argv[MAX_NETWORK_PORTS] = { 0 };
1604  int argc = 0, i;
1605 
1606  if (type) {
1607  ok = switch_true(type);
1608  }
1609 
1610  cidr = switch_xml_attr(x_node, "cidr");
1611  host = switch_xml_attr(x_node, "host");
1612  mask = switch_xml_attr(x_node, "mask");
1613  domain = switch_xml_attr(x_node, "domain");
1614 
1615  memset(&port_range, 0, sizeof(switch_network_port_range_t));
1616 
1617  if( (port = switch_xml_attr(x_node, "port")) != NULL) {
1618  port_range.port = atoi(port);
1619  }
1620 
1621  if( (port = switch_xml_attr(x_node, "ports")) != NULL) {
1622  argc = switch_separate_string((char*)port, ',', argv, (sizeof(argv) / sizeof(argv[0])));
1623  for(i=0; i < argc; i++) {
1624  port_range.ports[i] = atoi(argv[i]);
1625  }
1626  }
1627  if( (port = switch_xml_attr(x_node, "port-min")) != NULL) {
1628  port_range.min_port = atoi(port);
1629  }
1630  if( (port = switch_xml_attr(x_node, "port-max")) != NULL) {
1631  port_range.max_port = atoi(port);
1632  }
1633 
1634  if (domain) {
1635  switch_event_t *my_params = NULL;
1636  switch_xml_t x_domain, xml_root;
1637  switch_xml_t gt, gts, ut, uts;
1638 
1639  switch_event_create(&my_params, SWITCH_EVENT_GENERAL);
1640  switch_assert(my_params);
1641  switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "domain", domain);
1642  switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "purpose", "network-list");
1643 
1644  if (switch_xml_locate_domain(domain, my_params, &xml_root, &x_domain) != SWITCH_STATUS_SUCCESS) {
1645  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Cannot locate domain %s\n", domain);
1646  switch_event_destroy(&my_params);
1647  continue;
1648  }
1649 
1650  switch_event_destroy(&my_params);
1651 
1652  if ((ut = switch_xml_child(x_domain, "users"))) {
1653  x_domain = ut;
1654  }
1655 
1656  for (ut = switch_xml_child(x_domain, "user"); ut; ut = ut->next) {
1657  const char *user_cidr = switch_xml_attr(ut, "cidr");
1658  const char *id = switch_xml_attr(ut, "id");
1659 
1660  if (id && user_cidr) {
1661  char *token = switch_mprintf("%s@%s", id, domain);
1662  switch_assert(token);
1663  switch_network_list_add_cidr_token(list, user_cidr, ok, token);
1664  free(token);
1665  }
1666  }
1667 
1668  for (gts = switch_xml_child(x_domain, "groups"); gts; gts = gts->next) {
1669  for (gt = switch_xml_child(gts, "group"); gt; gt = gt->next) {
1670  for (uts = switch_xml_child(gt, "users"); uts; uts = uts->next) {
1671  for (ut = switch_xml_child(uts, "user"); ut; ut = ut->next) {
1672  const char *user_cidr = switch_xml_attr(ut, "cidr");
1673  const char *id = switch_xml_attr(ut, "id");
1674 
1675  if (id && user_cidr) {
1676  char *token = switch_mprintf("%s@%s", id, domain);
1677  switch_assert(token);
1678  switch_network_list_add_cidr_port_token(list, user_cidr, ok, token, &port_range);
1679  free(token);
1680  }
1681  }
1682  }
1683  }
1684  }
1685 
1686  switch_xml_free(xml_root);
1687  } else if (cidr) {
1688  switch_network_list_add_cidr_port_token(list, cidr, ok, NULL, &port_range);
1689  } else if (host && mask) {
1690  switch_network_list_add_host_port_mask(list, host, mask, ok, &port_range);
1691  }
1692  }
1693 
1694  switch_core_hash_insert(IP_LIST.hash, name, list);
1695  }
1696  }
1697 
1698  switch_xml_free(xml);
1699  }
1700 
1701  switch_mutex_unlock(runtime.global_mutex);
1702 }
1703 
1704 SWITCH_DECLARE(uint32_t) switch_core_max_dtmf_duration(uint32_t duration)
1705 {
1706  if (duration) {
1707  if (duration > SWITCH_MAX_DTMF_DURATION) {
1708  duration = SWITCH_MAX_DTMF_DURATION;
1709  }
1710  if (duration < SWITCH_MIN_DTMF_DURATION) {
1711  duration = SWITCH_MIN_DTMF_DURATION;
1712  }
1713  runtime.max_dtmf_duration = duration;
1714  if (duration < runtime.min_dtmf_duration) {
1715  runtime.min_dtmf_duration = duration;
1716  }
1717  }
1718  return runtime.max_dtmf_duration;
1719 }
1720 
1721 SWITCH_DECLARE(uint32_t) switch_core_default_dtmf_duration(uint32_t duration)
1722 {
1723  if (duration) {
1724  if (duration < SWITCH_MIN_DTMF_DURATION) {
1725  duration = SWITCH_MIN_DTMF_DURATION;
1726  }
1727  if (duration > SWITCH_MAX_DTMF_DURATION) {
1728  duration = SWITCH_MAX_DTMF_DURATION;
1729  }
1730  runtime.default_dtmf_duration = duration;
1731 
1732  if (duration < runtime.min_dtmf_duration) {
1733  runtime.min_dtmf_duration = duration;
1734  }
1735 
1736  if (duration > runtime.max_dtmf_duration) {
1737  runtime.max_dtmf_duration = duration;
1738  }
1739 
1740  }
1741  return runtime.default_dtmf_duration;
1742 }
1743 
1744 SWITCH_DECLARE(uint32_t) switch_core_min_dtmf_duration(uint32_t duration)
1745 {
1746  if (duration) {
1747  if (duration < SWITCH_MIN_DTMF_DURATION) {
1748  duration = SWITCH_MIN_DTMF_DURATION;
1749  }
1750  if (duration > SWITCH_MAX_DTMF_DURATION) {
1751  duration = SWITCH_MAX_DTMF_DURATION;
1752  }
1753 
1754  runtime.min_dtmf_duration = duration;
1755 
1756  if (duration > runtime.max_dtmf_duration) {
1757  runtime.max_dtmf_duration = duration;
1758  }
1759  }
1760  return runtime.min_dtmf_duration;
1761 }
1762 
1763 SWITCH_DECLARE(switch_status_t) switch_core_thread_set_cpu_affinity(int cpu)
1764 {
1765  switch_status_t status = SWITCH_STATUS_FALSE;
1766 
1767  if (cpu > -1) {
1768 
1769 #ifdef HAVE_CPU_SET_MACROS
1770  cpu_set_t set;
1771 
1772  CPU_ZERO(&set);
1773  CPU_SET(cpu, &set);
1774 
1775  if (!sched_setaffinity(0, sizeof(set), &set)) {
1776  status = SWITCH_STATUS_SUCCESS;
1777  }
1778 
1779 #else
1780 #if WIN32
1781  if (SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR) cpu)) {
1782  status = SWITCH_STATUS_SUCCESS;
1783  }
1784 #endif
1785 #endif
1786  }
1787 
1788  return status;
1789 }
1790 
1791 
1792 SWITCH_DECLARE(int) switch_core_test_flag(int flag)
1793 {
1794  return switch_test_flag((&runtime), flag);
1795 }
1796 
1797 
1798 SWITCH_DECLARE(switch_status_t) switch_core_init(switch_core_flag_t flags, switch_bool_t console, const char **err)
1799 {
1800  switch_uuid_t uuid;
1801  char guess_ip[256];
1802  int mask = 0;
1803  struct in_addr in;
1804 
1805 
1806  if (runtime.runlevel > 0) {
1807  /* one per customer */
1808  return SWITCH_STATUS_SUCCESS;
1809  }
1810 
1811  memset(&runtime, 0, sizeof(runtime));
1812  gethostname(runtime.hostname, sizeof(runtime.hostname));
1813 
1814  runtime.shutdown_cause = SWITCH_CAUSE_SYSTEM_SHUTDOWN;
1815  runtime.max_db_handles = 50;
1816  runtime.db_handle_timeout = 5000000;
1817  runtime.event_heartbeat_interval = 20;
1818 
1819  runtime.runlevel++;
1820  runtime.dummy_cng_frame.data = runtime.dummy_data;
1821  runtime.dummy_cng_frame.datalen = sizeof(runtime.dummy_data);
1822  runtime.dummy_cng_frame.buflen = sizeof(runtime.dummy_data);
1823  runtime.dbname = "core";
1824  switch_set_flag((&runtime.dummy_cng_frame), SFF_CNG);
1825  switch_set_flag((&runtime), SCF_AUTO_SCHEMAS);
1826  switch_set_flag((&runtime), SCF_CLEAR_SQL);
1827  switch_set_flag((&runtime), SCF_API_EXPANSION);
1828  switch_set_flag((&runtime), SCF_SESSION_THREAD_POOL);
1829 #ifdef WIN32
1830  switch_set_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
1831 #endif
1832  switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
1833  if (flags & SCF_LOG_DISABLE) {
1834  runtime.hard_log_level = SWITCH_LOG_DISABLE;
1835  flags &= ~SCF_LOG_DISABLE;
1836  } else {
1837  runtime.hard_log_level = SWITCH_LOG_DEBUG;
1838  }
1839  runtime.mailer_app = "sendmail";
1840  runtime.mailer_app_args = "-t";
1841  runtime.max_dtmf_duration = SWITCH_MAX_DTMF_DURATION;
1842  runtime.default_dtmf_duration = SWITCH_DEFAULT_DTMF_DURATION;
1843  runtime.min_dtmf_duration = SWITCH_MIN_DTMF_DURATION;
1844  runtime.odbc_dbtype = DBTYPE_DEFAULT;
1845  runtime.dbname = NULL;
1846 #ifndef WIN32
1847  runtime.cpu_count = sysconf (_SC_NPROCESSORS_ONLN);
1848 #else
1849  {
1850  SYSTEM_INFO sysinfo;
1851  GetSystemInfo( &sysinfo );
1852  runtime.cpu_count = sysinfo.dwNumberOfProcessors;
1853  }
1854 #endif
1855 
1856  if (!runtime.cpu_count) runtime.cpu_count = 1;
1857 
1858  if (sqlite3_initialize() != SQLITE_OK) {
1859  *err = "FATAL ERROR! Could not initialize SQLite\n";
1860  return SWITCH_STATUS_MEMERR;
1861  }
1862 
1863  /* INIT APR and Create the pool context */
1864  if (fspr_initialize() != SWITCH_STATUS_SUCCESS) {
1865  *err = "FATAL ERROR! Could not initialize APR\n";
1866  return SWITCH_STATUS_MEMERR;
1867  }
1868 
1869  if (!(runtime.memory_pool = switch_core_memory_init())) {
1870  *err = "FATAL ERROR! Could not allocate memory pool\n";
1871  return SWITCH_STATUS_MEMERR;
1872  }
1873  switch_assert(runtime.memory_pool != NULL);
1874 
1875  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.base_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1876  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.mod_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1877  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.conf_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1878  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.log_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1879  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.run_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1880  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.db_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1881  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.script_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1882  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.htdocs_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1883  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1884  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.fonts_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1885  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.images_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1886  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.recordings_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1887  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.sounds_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1888  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.temp_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1889  switch_dir_make_recursive(SWITCH_GLOBAL_dirs.certs_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
1890 
1891  switch_mutex_init(&runtime.uuid_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
1892 
1893  switch_mutex_init(&runtime.throttle_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
1894 
1895  switch_mutex_init(&runtime.session_hash_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
1896  switch_mutex_init(&runtime.global_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
1897 
1898  switch_thread_rwlock_create(&runtime.global_var_rwlock, runtime.memory_pool);
1899  switch_core_set_globals();
1900  switch_core_session_init(runtime.memory_pool);
1901  switch_event_create_plain(&runtime.global_vars, SWITCH_EVENT_CHANNEL_DATA);
1902  switch_core_hash_init_case(&runtime.mime_types, SWITCH_FALSE);
1903  switch_core_hash_init_case(&runtime.mime_type_exts, SWITCH_FALSE);
1904  switch_core_hash_init_case(&runtime.ptimes, SWITCH_FALSE);
1905  load_mime_types();
1906  runtime.flags |= flags;
1907  runtime.sps_total = 30;
1908 
1909  *err = NULL;
1910 
1911  if (console) {
1912  runtime.console = stdout;
1913  }
1914 
1915  SSL_library_init();
1916  switch_ssl_init_ssl_locks();
1917  OpenSSL_add_all_algorithms();
1918  switch_curl_init();
1919 
1920  switch_core_set_variable("hostname", runtime.hostname);
1921  switch_find_local_ip(guess_ip, sizeof(guess_ip), &mask, AF_INET);
1922  switch_core_set_variable("local_ip_v4", guess_ip);
1923  in.s_addr = mask;
1924  switch_core_set_variable("local_mask_v4", inet_ntoa(in));
1925 
1926 
1927  switch_find_local_ip(guess_ip, sizeof(guess_ip), NULL, AF_INET6);
1928  switch_core_set_variable("local_ip_v6", guess_ip);
1929  switch_core_set_variable("base_dir", SWITCH_GLOBAL_dirs.base_dir);
1930  switch_core_set_variable("recordings_dir", SWITCH_GLOBAL_dirs.recordings_dir);
1931  switch_core_set_variable("sound_prefix", SWITCH_GLOBAL_dirs.sounds_dir);
1932  switch_core_set_variable("sounds_dir", SWITCH_GLOBAL_dirs.sounds_dir);
1933  switch_core_set_variable("conf_dir", SWITCH_GLOBAL_dirs.conf_dir);
1934  switch_core_set_variable("log_dir", SWITCH_GLOBAL_dirs.log_dir);
1935  switch_core_set_variable("run_dir", SWITCH_GLOBAL_dirs.run_dir);
1936  switch_core_set_variable("db_dir", SWITCH_GLOBAL_dirs.db_dir);
1937  switch_core_set_variable("mod_dir", SWITCH_GLOBAL_dirs.mod_dir);
1938  switch_core_set_variable("htdocs_dir", SWITCH_GLOBAL_dirs.htdocs_dir);
1939  switch_core_set_variable("script_dir", SWITCH_GLOBAL_dirs.script_dir);
1940  switch_core_set_variable("temp_dir", SWITCH_GLOBAL_dirs.temp_dir);
1941  switch_core_set_variable("grammar_dir", SWITCH_GLOBAL_dirs.grammar_dir);
1942  switch_core_set_variable("fonts_dir", SWITCH_GLOBAL_dirs.fonts_dir);
1943  switch_core_set_variable("images_dir", SWITCH_GLOBAL_dirs.images_dir);
1944  switch_core_set_variable("certs_dir", SWITCH_GLOBAL_dirs.certs_dir);
1945  switch_core_set_variable("storage_dir", SWITCH_GLOBAL_dirs.storage_dir);
1946  switch_core_set_variable("cache_dir", SWITCH_GLOBAL_dirs.cache_dir);
1947  switch_core_set_variable("data_dir", SWITCH_GLOBAL_dirs.data_dir);
1948  switch_core_set_variable("localstate_dir", SWITCH_GLOBAL_dirs.localstate_dir);
1949  switch_console_init(runtime.memory_pool);
1950  switch_event_init(runtime.memory_pool);
1951  switch_channel_global_init(runtime.memory_pool);
1952 
1953  if (switch_xml_init(runtime.memory_pool, err) != SWITCH_STATUS_SUCCESS) {
1954  /* allow missing configuration if MINIMAL */
1955  if (!(flags & SCF_MINIMAL)) {
1956  fspr_terminate();
1957  return SWITCH_STATUS_MEMERR;
1958  }
1959  }
1960 
1961  if (switch_test_flag((&runtime), SCF_USE_AUTO_NAT)) {
1962  switch_nat_init(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_NAT_MAPPING));
1963  }
1964 
1965  switch_log_init(runtime.memory_pool, runtime.colorize_console);
1966 
1967  runtime.tipping_point = 0;
1968  runtime.timer_affinity = -1;
1969  runtime.microseconds_per_tick = 20000;
1970 
1971  if (flags & SCF_MINIMAL) return SWITCH_STATUS_SUCCESS;
1972 
1973  switch_load_core_config("switch.conf");
1974 
1975  switch_core_state_machine_init(runtime.memory_pool);
1976 
1977  switch_core_media_init();
1978  switch_scheduler_task_thread_start();
1979 
1980  switch_nat_late_init();
1981 
1982  switch_rtp_init(runtime.memory_pool);
1983 
1984  runtime.running = 1;
1985  runtime.initiated = switch_mono_micro_time_now();
1986 
1987  switch_scheduler_add_task(switch_epoch_time_now(NULL), heartbeat_callback, "heartbeat", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL);
1988 
1989  switch_scheduler_add_task(switch_epoch_time_now(NULL), check_ip_callback, "check_ip", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL | SSHF_OWN_THREAD);
1990 
1991  switch_uuid_get(&uuid);
1992  switch_uuid_format(runtime.uuid_str, &uuid);
1993  switch_core_set_variable("core_uuid", runtime.uuid_str);
1994 
1995 
1996  return SWITCH_STATUS_SUCCESS;
1997 }
1998 
1999 
2000 #ifdef TRAP_BUS
2001 static void handle_SIGBUS(int sig)
2002 {
2003  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Sig BUS!\n");
2004  return;
2005 }
2006 #endif
2007 
2008 static void handle_SIGHUP(int sig)
2009 {
2010  if (sig) {
2011  switch_event_t *event;
2012 
2013  if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
2014  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Trapped-Signal", "HUP");
2015  switch_event_fire(&event);
2016  }
2017  }
2018  return;
2019 }
2020 
2021 
2022 SWITCH_DECLARE(uint32_t) switch_default_ptime(const char *name, uint32_t number)
2023 {
2024  uint32_t *p;
2025 
2026  if ((p = switch_core_hash_find(runtime.ptimes, name))) {
2027  return *p;
2028  }
2029 
2030  return 20;
2031 }
2032 
2033 SWITCH_DECLARE(uint32_t) switch_default_rate(const char *name, uint32_t number)
2034 {
2035 
2036  if (!strcasecmp(name, "opus")) {
2037  return 48000;
2038  } else if (!strncasecmp(name, "h26", 3)) { // h26x
2039  return 90000;
2040  } else if (!strncasecmp(name, "vp", 2)) { // vp8, vp9
2041  return 90000;
2042  }
2043 
2044  return 8000;
2045 }
2046 
2047 static uint32_t d_30 = 30;
2048 
2049 static void switch_load_core_config(const char *file)
2050 {
2051  switch_xml_t xml = NULL, cfg = NULL;
2052 
2053  switch_core_hash_insert(runtime.ptimes, "ilbc", &d_30);
2054  switch_core_hash_insert(runtime.ptimes, "isac", &d_30);
2055  switch_core_hash_insert(runtime.ptimes, "G723", &d_30);
2056 
2057 
2058  if ((xml = switch_xml_open_cfg(file, &cfg, NULL))) {
2059  switch_xml_t settings, param;
2060 
2061  if ((settings = switch_xml_child(cfg, "default-ptimes"))) {
2062  for (param = switch_xml_child(settings, "codec"); param; param = param->next) {
2063  const char *var = switch_xml_attr_soft(param, "name");
2064  const char *val = switch_xml_attr_soft(param, "ptime");
2065 
2066  if (!zstr(var) && !zstr(val)) {
2067  uint32_t *p;
2068  uint32_t v = switch_atoul(val);
2069 
2070  if (!strcasecmp(var, "G723") || !strcasecmp(var, "iLBC")) {
2071  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error adding %s, defaults cannot be changed\n", var);
2072  continue;
2073  }
2074 
2075  if (v == 0) {
2076  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error adding %s, invalid ptime\n", var);
2077  continue;
2078  }
2079 
2080  p = switch_core_alloc(runtime.memory_pool, sizeof(*p));
2081  *p = v;
2082  switch_core_hash_insert(runtime.ptimes, var, p);
2083  }
2084 
2085  }
2086  }
2087 
2088  if ((settings = switch_xml_child(cfg, "settings"))) {
2089  for (param = switch_xml_child(settings, "param"); param; param = param->next) {
2090  const char *var = switch_xml_attr_soft(param, "name");
2091  const char *val = switch_xml_attr_soft(param, "value");
2092 
2093  if (!strcasecmp(var, "loglevel")) {
2094  int level;
2095  if (*val > 47 && *val < 58) {
2096  level = atoi(val);
2097  } else {
2098  level = switch_log_str2level(val);
2099  }
2100 
2101  if (level != SWITCH_LOG_INVALID) {
2102  switch_core_session_ctl(SCSC_LOGLEVEL, &level);
2103  }
2104 #ifdef HAVE_SETRLIMIT
2105  } else if (!strcasecmp(var, "dump-cores") && switch_true(val)) {
2106  struct rlimit rlp;
2107  memset(&rlp, 0, sizeof(rlp));
2108  rlp.rlim_cur = RLIM_INFINITY;
2109  rlp.rlim_max = RLIM_INFINITY;
2110  setrlimit(RLIMIT_CORE, &rlp);
2111 #endif
2112  } else if (!strcasecmp(var, "debug-level")) {
2113  int tmp = atoi(val);
2114  if (tmp > -1 && tmp < 11) {
2115  switch_core_session_ctl(SCSC_DEBUG_LEVEL, &tmp);
2116  }
2117  } else if (!strcasecmp(var, "max-db-handles")) {
2118  long tmp = atol(val);
2119 
2120  if (tmp > 4 && tmp < 5001) {
2121  runtime.max_db_handles = (uint32_t) tmp;
2122  } else {
2123  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "max-db-handles must be between 5 and 5000\n");
2124  }
2125  } else if (!strcasecmp(var, "odbc-skip-autocommit-flip")) {
2126  if (switch_true(val)) {
2127  switch_odbc_skip_autocommit_flip();
2128  }
2129  } else if (!strcasecmp(var, "db-handle-timeout")) {
2130  long tmp = atol(val);
2131 
2132  if (tmp > 0 && tmp < 5001) {
2133  runtime.db_handle_timeout = (uint32_t) tmp * 1000000;
2134  } else {
2135  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "db-handle-timeout must be between 1 and 5000\n");
2136  }
2137 
2138  } else if (!strcasecmp(var, "event-heartbeat-interval")) {
2139  long tmp = atol(val);
2140 
2141  if (tmp > 0) {
2142  runtime.event_heartbeat_interval = (uint32_t) tmp;
2143  } else {
2144  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "heartbeat-interval must be a greater than 0\n");
2145  }
2146 
2147  } else if (!strcasecmp(var, "multiple-registrations")) {
2148  runtime.multiple_registrations = switch_true(val);
2149  } else if (!strcasecmp(var, "auto-create-schemas")) {
2150  if (switch_true(val)) {
2151  switch_set_flag((&runtime), SCF_AUTO_SCHEMAS);
2152  } else {
2153  switch_clear_flag((&runtime), SCF_AUTO_SCHEMAS);
2154  }
2155  } else if (!strcasecmp(var, "session-thread-pool")) {
2156  if (switch_true(val)) {
2157  switch_set_flag((&runtime), SCF_SESSION_THREAD_POOL);
2158  } else {
2159  switch_clear_flag((&runtime), SCF_SESSION_THREAD_POOL);
2160  }
2161  } else if (!strcasecmp(var, "auto-clear-sql")) {
2162  if (switch_true(val)) {
2163  switch_set_flag((&runtime), SCF_CLEAR_SQL);
2164  } else {
2165  switch_clear_flag((&runtime), SCF_CLEAR_SQL);
2166  }
2167  } else if (!strcasecmp(var, "api-expansion")) {
2168  if (switch_true(val)) {
2169  switch_set_flag((&runtime), SCF_API_EXPANSION);
2170  } else {
2171  switch_clear_flag((&runtime), SCF_API_EXPANSION);
2172  }
2173  } else if (!strcasecmp(var, "enable-early-hangup") && switch_true(val)) {
2174  switch_set_flag((&runtime), SCF_EARLY_HANGUP);
2175  } else if (!strcasecmp(var, "colorize-console") && switch_true(val)) {
2176  runtime.colorize_console = SWITCH_TRUE;
2177  } else if (!strcasecmp(var, "core-db-pre-trans-execute") && !zstr(val)) {
2178  runtime.core_db_pre_trans_execute = switch_core_strdup(runtime.memory_pool, val);
2179  } else if (!strcasecmp(var, "core-db-post-trans-execute") && !zstr(val)) {
2180  runtime.core_db_post_trans_execute = switch_core_strdup(runtime.memory_pool, val);
2181  } else if (!strcasecmp(var, "core-db-inner-pre-trans-execute") && !zstr(val)) {
2182  runtime.core_db_inner_pre_trans_execute = switch_core_strdup(runtime.memory_pool, val);
2183  } else if (!strcasecmp(var, "core-db-inner-post-trans-execute") && !zstr(val)) {
2184  runtime.core_db_inner_post_trans_execute = switch_core_strdup(runtime.memory_pool, val);
2185  } else if (!strcasecmp(var, "dialplan-timestamps")) {
2186  if (switch_true(val)) {
2187  switch_set_flag((&runtime), SCF_DIALPLAN_TIMESTAMPS);
2188  } else {
2189  switch_clear_flag((&runtime), SCF_DIALPLAN_TIMESTAMPS);
2190  }
2191  } else if (!strcasecmp(var, "mailer-app") && !zstr(val)) {
2192  runtime.mailer_app = switch_core_strdup(runtime.memory_pool, val);
2193  } else if (!strcasecmp(var, "mailer-app-args") && val) {
2194  runtime.mailer_app_args = switch_core_strdup(runtime.memory_pool, val);
2195  } else if (!strcasecmp(var, "sessions-per-second") && !zstr(val)) {
2196  switch_core_sessions_per_second(atoi(val));
2197  } else if (!strcasecmp(var, "max-dtmf-duration") && !zstr(val)) {
2198  int tmp = atoi(val);
2199  if (tmp > 0) {
2200  switch_core_max_dtmf_duration((uint32_t) tmp);
2201  }
2202  } else if (!strcasecmp(var, "min-dtmf-duration") && !zstr(val)) {
2203  int tmp = atoi(val);
2204  if (tmp > 0) {
2205  switch_core_min_dtmf_duration((uint32_t) tmp);
2206  }
2207  } else if (!strcasecmp(var, "default-dtmf-duration") && !zstr(val)) {
2208  int tmp = atoi(val);
2209  if (tmp > 0) {
2210  switch_core_default_dtmf_duration((uint32_t) tmp);
2211  }
2212  } else if (!strcasecmp(var, "enable-use-system-time")) {
2213  switch_time_set_use_system_time(switch_true(val));
2214  } else if (!strcasecmp(var, "enable-monotonic-timing")) {
2215  switch_time_set_monotonic(switch_true(val));
2216  } else if (!strcasecmp(var, "enable-softtimer-timerfd")) {
2217  int ival = 0;
2218  if (val) {
2219  if (switch_true(val)) {
2220  ival = 2;
2221  } else {
2222  if (strcasecmp(val, "broadcast")) {
2223  ival = 1;
2224  } else if (strcasecmp(val, "fd-per-timer")) {
2225  ival = 2;
2226  }
2227  }
2228  }
2229  switch_time_set_timerfd(ival);
2230  } else if (!strcasecmp(var, "enable-clock-nanosleep")) {
2231  switch_time_set_nanosleep(switch_true(val));
2232  } else if (!strcasecmp(var, "enable-cond-yield")) {
2233  switch_time_set_cond_yield(switch_true(val));
2234  } else if (!strcasecmp(var, "enable-timer-matrix")) {
2235  switch_time_set_matrix(switch_true(val));
2236  } else if (!strcasecmp(var, "max-sessions") && !zstr(val)) {
2237  switch_core_session_limit(atoi(val));
2238  } else if (!strcasecmp(var, "verbose-channel-events") && !zstr(val)) {
2239  int v = switch_true(val);
2240  if (v) {
2241  switch_set_flag((&runtime), SCF_VERBOSE_EVENTS);
2242  } else {
2243  switch_clear_flag((&runtime), SCF_VERBOSE_EVENTS);
2244  }
2245  } else if (!strcasecmp(var, "threaded-system-exec") && !zstr(val)) {
2246 #ifdef WIN32
2247  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "threaded-system-exec is not implemented on this platform\n");
2248 #else
2249  int v = switch_true(val);
2250  if (v) {
2251  switch_set_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
2252  } else {
2253  switch_clear_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
2254  }
2255 #endif
2256  } else if (!strcasecmp(var, "spawn-instead-of-system") && !zstr(val)) {
2257 #ifdef WIN32
2258  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "spawn-instead-of-system is not implemented on this platform\n");
2259 #else
2260  int v = switch_true(val);
2261  if (v) {
2262  switch_core_set_variable("spawn_instead_of_system", "true");
2263  } else {
2264  switch_core_set_variable("spawn_instead_of_system", "false");
2265  }
2266 #endif
2267  } else if (!strcasecmp(var, "exclude-error-log-from-xml-cdr") && !zstr(val)) {
2268  int v = switch_true(val);
2269  if (v) {
2270  switch_core_set_variable("exclude_error_log_from_xml_cdr", "true");
2271  } else {
2272  switch_core_set_variable("exclude_error_log_from_xml_cdr", "false");
2273  }
2274  } else if (!strcasecmp(var, "min-idle-cpu") && !zstr(val)) {
2275  switch_core_min_idle_cpu(atof(val));
2276  } else if (!strcasecmp(var, "tipping-point") && !zstr(val)) {
2277  runtime.tipping_point = atoi(val);
2278  } else if (!strcasecmp(var, "cpu-idle-smoothing-depth") && !zstr(val)) {
2279  runtime.cpu_idle_smoothing_depth = atoi(val);
2280  } else if (!strcasecmp(var, "events-use-dispatch") && !zstr(val)) {
2281  runtime.events_use_dispatch = switch_true(val);
2282  } else if (!strcasecmp(var, "initial-event-threads") && !zstr(val)) {
2283  int tmp;
2284 
2285  if (!runtime.events_use_dispatch) {
2286  runtime.events_use_dispatch = 1;
2287  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
2288  "Implicitly setting events-use-dispatch based on usage of this initial-event-threads parameter.\n");
2289  }
2290 
2291  tmp = atoi(val);
2292 
2293  if (tmp > runtime.cpu_count / 2) {
2294  tmp = runtime.cpu_count / 2;
2295  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "This value cannot be higher than %d so setting it to that value\n",
2296  runtime.cpu_count / 2);
2297  }
2298 
2299  if (tmp < 1) {
2300  tmp = 1;
2301  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "This value cannot be lower than 1 so setting it to that level\n");
2302  }
2303 
2304  switch_event_launch_dispatch_threads(tmp);
2305 
2306  } else if (!strcasecmp(var, "1ms-timer") && switch_true(val)) {
2307  runtime.microseconds_per_tick = 1000;
2308  } else if (!strcasecmp(var, "timer-affinity") && !zstr(val)) {
2309  if (!strcasecmp(val, "disabled")) {
2310  runtime.timer_affinity = -1;
2311  } else {
2312  runtime.timer_affinity = atoi(val);
2313  }
2314  } else if (!strcasecmp(var, "ice-resolve-candidate")) {
2315  switch_core_media_set_resolveice(switch_true(val));
2316  } else if (!strcasecmp(var, "rtp-start-port") && !zstr(val)) {
2317  switch_rtp_set_start_port((switch_port_t) atoi(val));
2318  } else if (!strcasecmp(var, "rtp-end-port") && !zstr(val)) {
2319  switch_rtp_set_end_port((switch_port_t) atoi(val));
2320  } else if (!strcasecmp(var, "rtp-port-usage-robustness") && switch_true(val)) {
2321  runtime.port_alloc_flags |= SPF_ROBUST_UDP;
2322  } else if (!strcasecmp(var, "core-db-name") && !zstr(val)) {
2323  runtime.dbname = switch_core_strdup(runtime.memory_pool, val);
2324  } else if (!strcasecmp(var, "core-db-dsn") && !zstr(val)) {
2325  runtime.odbc_dsn = switch_core_strdup(runtime.memory_pool, val);
2326  } else if (!strcasecmp(var, "core-non-sqlite-db-required") && !zstr(val)) {
2327  switch_set_flag((&runtime), SCF_CORE_NON_SQLITE_DB_REQ);
2328  } else if (!strcasecmp(var, "core-dbtype") && !zstr(val)) {
2329  if (!strcasecmp(val, "MSSQL")) {
2330  runtime.odbc_dbtype = DBTYPE_MSSQL;
2331  } else {
2332  runtime.odbc_dbtype = DBTYPE_DEFAULT;
2333  }
2334  } else if (!strcasecmp(var, "switchname") && !zstr(val)) {
2335  runtime.switchname = switch_core_strdup(runtime.memory_pool, val);
2336  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Set switchname to %s\n", runtime.switchname);
2337  } else if (!strcasecmp(var, "rtp-retain-crypto-keys")) {
2338  if (switch_true(val)) {
2339  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
2340  "rtp-retain-crypto-keys enabled. Could be used to decrypt secure media.\n");
2341  }
2342  switch_core_set_variable("rtp_retain_crypto_keys", val);
2343  } else if (!strcasecmp(var, "caller-profile-soft-variables-uses-prefix") && !zstr(val)) {
2344  int v = switch_true(val);
2345  if (v) {
2346  switch_set_flag((&runtime), SCF_CPF_SOFT_PREFIX);
2347  } else {
2348  switch_clear_flag((&runtime), SCF_CPF_SOFT_PREFIX);
2349  }
2350  } else if (!strcasecmp(var, "caller-profile-soft-lookup-values") && !zstr(val)) {
2351  int v = switch_true(val);
2352  if (v) {
2353  switch_set_flag((&runtime), SCF_CPF_SOFT_LOOKUP);
2354  } else {
2355  switch_clear_flag((&runtime), SCF_CPF_SOFT_LOOKUP);
2356  }
2357  } else if (!strcasecmp(var, "event-channel-key-separator") && !zstr(val)) {
2358  runtime.event_channel_key_separator = switch_core_strdup(runtime.memory_pool, val);
2359  } else if (!strcasecmp(var, "event-channel-enable-hierarchy-deliver") && !zstr(val)) {
2360  int v = switch_true(val);
2361  if (v) {
2362  switch_set_flag((&runtime), SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY);
2363  } else {
2364  switch_clear_flag((&runtime), SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY);
2365  }
2366  } else if (!strcasecmp(var, "event-channel-hierarchy-deliver-once") && !zstr(val)) {
2367  int v = switch_true(val);
2368  if (v) {
2369  switch_set_flag((&runtime), SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE);
2370  } else {
2371  switch_clear_flag((&runtime), SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE);
2372  }
2373  } else if (!strcasecmp(var, "event-channel-log-undeliverable-json") && !zstr(val)) {
2374  int v = switch_true(val);
2375  if (v) {
2376  switch_set_flag((&runtime), SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON);
2377  } else {
2378  switch_clear_flag((&runtime), SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON);
2379  }
2380  } else if (!strcasecmp(var, "max-audio-channels") && !zstr(val)) {
2381  switch_core_max_audio_channels(atoi(val));
2382  }
2383  }
2384  }
2385 
2386  if (runtime.event_channel_key_separator == NULL) {
2387  runtime.event_channel_key_separator = switch_core_strdup(runtime.memory_pool, ".");
2388  }
2389 
2390  if ((settings = switch_xml_child(cfg, "variables"))) {
2391  for (param = switch_xml_child(settings, "variable"); param; param = param->next) {
2392  const char *var = switch_xml_attr_soft(param, "name");
2393  const char *val = switch_xml_attr_soft(param, "value");
2394  if (var && val) {
2395  switch_core_set_variable(var, val);
2396  }
2397  }
2398  }
2399 
2400  switch_xml_free(xml);
2401  }
2402 
2403 
2404 }
2405 
2406 SWITCH_DECLARE(const char *) switch_core_banner(void)
2407 {
2408 
2409  return ("\n"
2410  ".=============================================================.\n"
2411  "| _____ ______ _____ _____ ____ _ _ |\n"
2412  "| | ___| __ ___ ___/ ___\\ \\ / /_ _|_ _/ ___| | | | |\n"
2413  "| | |_ | '__/ _ \\/ _ \\___ \\\\ \\ /\\ / / | | | || | | |_| | |\n"
2414  "| | _|| | | __/ __/___) |\\ V V / | | | || |___| _ | |\n"
2415  "| |_| |_| \\___|\\___|____/ \\_/\\_/ |___| |_| \\____|_| |_| |\n"
2416  "| |\n"
2417  ".=============================================================."
2418  "\n"
2419 
2420  "| Anthony Minessale II, Michael Jerris, Brian West, Others |\n"
2421  "| FreeSWITCH (http://www.freeswitch.org) |\n"
2422  "| Paypal Donations Appreciated: paypal@freeswitch.org |\n"
2423  "| Brought to you by ClueCon http://www.cluecon.com/ |\n"
2424  ".=============================================================.\n"
2425  "\n");
2426 }
2427 
2428 switch_status_t switch_core_sqldb_init(const char **err)
2429 {
2430  if (switch_core_check_core_db_dsn() != SWITCH_STATUS_SUCCESS) {
2431  *err = "NO SUITABLE DATABASE INTERFACE IS AVAILABLE TO SERVE 'core-db-dsn'!\n";
2432  return SWITCH_STATUS_GENERR;
2433  }
2434 
2435  if (switch_core_sqldb_start(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_SQL) ? SWITCH_TRUE : SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) {
2436  *err = "Error activating database";
2437  return SWITCH_STATUS_GENERR;
2438  }
2439 
2440  return SWITCH_STATUS_SUCCESS;
2441 }
2442 
2443 SWITCH_DECLARE(switch_status_t) switch_core_init_and_modload(switch_core_flag_t flags, switch_bool_t console, const char **err)
2444 {
2445  switch_event_t *event;
2446  char *cmd;
2447  int x = 0;
2448  const char *use = NULL;
2449 #include "cc.h"
2450 
2451 
2452  if (switch_core_init(flags, console, err) != SWITCH_STATUS_SUCCESS) {
2453  return SWITCH_STATUS_GENERR;
2454  }
2455 
2456  if (runtime.runlevel > 1) {
2457  /* one per customer */
2458  return SWITCH_STATUS_SUCCESS;
2459  }
2460 
2461  runtime.runlevel++;
2462  runtime.events_use_dispatch = 1;
2463 
2464  switch_core_set_signal_handlers();
2465  switch_load_network_lists(SWITCH_FALSE);
2466 
2467  switch_msrp_init();
2468 
2469  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Bringing up environment.\n");
2470  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Loading Modules.\n");
2471  if (switch_loadable_module_init(SWITCH_TRUE) != SWITCH_STATUS_SUCCESS) {
2472  *err = "Cannot load modules";
2473  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error: %s\n", *err);
2474  return SWITCH_STATUS_GENERR;
2475  }
2476 
2477  switch_load_network_lists(SWITCH_FALSE);
2478 
2479  switch_load_core_config("post_load_switch.conf");
2480 
2481  switch_core_set_signal_handlers();
2482 
2483  if (switch_event_create(&event, SWITCH_EVENT_STARTUP) == SWITCH_STATUS_SUCCESS) {
2484  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Ready");
2485  switch_event_fire(&event);
2486  }
2487 
2488  switch_core_screen_size(&x, NULL);
2489 
2490  use = (x > 100) ? cc : cc_s;
2491 
2492 #ifdef WIN32
2493  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s%s\n\n", switch_core_banner(), use);
2494 #else
2495  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s%s%s%s%s%s\n\n",
2496  SWITCH_SEQ_DEFAULT_COLOR,
2497  SWITCH_SEQ_FYELLOW, SWITCH_SEQ_BBLUE,
2498  switch_core_banner(),
2499  use, SWITCH_SEQ_DEFAULT_COLOR);
2500 
2501 #endif
2502 
2503 
2504  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
2505  "\nFreeSWITCH Version %s (%s)\n\nFreeSWITCH Started\nMax Sessions [%u]\nSession Rate [%d]\nSQL [%s]\n",
2506  switch_version_full(), switch_version_revision_human(),
2507  switch_core_session_limit(0),
2508  switch_core_sessions_per_second(0), switch_test_flag((&runtime), SCF_USE_SQL) ? "Enabled" : "Disabled");
2509 
2510 
2511  if (x < 160) {
2512  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\n[This app Best viewed at 160x60 or more..]\n");
2513  }
2514 
2515  switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
2516 
2517  if ((cmd = switch_core_get_variable_dup("api_on_startup"))) {
2518  switch_stream_handle_t stream = { 0 };
2519  SWITCH_STANDARD_STREAM(stream);
2520  switch_console_execute(cmd, 0, &stream);
2521  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Startup command [%s] executed. Output:\n%s\n", cmd, (char *)stream.data);
2522  free(stream.data);
2523  free(cmd);
2524  }
2525 
2526 #ifdef HAVE_SYSTEMD
2527  sd_notifyf(0, "READY=1\n"
2528  "MAINPID=%lu\n", (unsigned long) getpid());
2529 #endif
2530 
2531  return SWITCH_STATUS_SUCCESS;
2532 
2533 }
2534 
2535 SWITCH_DECLARE(void) switch_core_measure_time(switch_time_t total_ms, switch_core_time_duration_t *duration)
2536 {
2537  switch_time_t temp = total_ms / 1000;
2538  memset(duration, 0, sizeof(*duration));
2539  duration->mms = (uint32_t) (total_ms % 1000);
2540  duration->ms = (uint32_t) (temp % 1000);
2541  temp = temp / 1000;
2542  duration->sec = (uint32_t) (temp % 60);
2543  temp = temp / 60;
2544  duration->min = (uint32_t) (temp % 60);
2545  temp = temp / 60;
2546  duration->hr = (uint32_t) (temp % 24);
2547  temp = temp / 24;
2548  duration->day = (uint32_t) (temp % 365);
2549  duration->yr = (uint32_t) (temp / 365);
2550 }
2551 
2552 SWITCH_DECLARE(switch_time_t) switch_core_uptime(void)
2553 {
2554  return switch_mono_micro_time_now() - runtime.initiated;
2555 }
2556 
2557 
2558 #ifdef _MSC_VER
2559 static void win_shutdown(void)
2560 {
2561 
2562  HANDLE shutdown_event;
2563  char path[512];
2564  /* for windows we need the event to signal for shutting down a background FreeSWITCH */
2565  snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
2566 
2567  /* open the event so we can signal it */
2568  shutdown_event = OpenEvent(EVENT_MODIFY_STATE, FALSE, path);
2569 
2570  if (shutdown_event) {
2571  /* signal the event to shutdown */
2572  SetEvent(shutdown_event);
2573  /* cleanup */
2574  CloseHandle(shutdown_event);
2575  }
2576 }
2577 #endif
2578 
2579 SWITCH_DECLARE(void) switch_core_set_signal_handlers(void)
2580 {
2581  /* set signal handlers */
2582  signal(SIGINT, SIG_IGN);
2583 #ifdef SIGPIPE
2584  signal(SIGPIPE, SIG_IGN);
2585 #endif
2586 #ifdef SIGALRM
2587  signal(SIGALRM, SIG_IGN);
2588 #endif
2589 #ifdef SIGQUIT
2590  signal(SIGQUIT, SIG_IGN);
2591 #endif
2592 #ifdef SIGPOLL
2593  signal(SIGPOLL, SIG_IGN);
2594 #endif
2595 #ifdef SIGIO
2596  signal(SIGIO, SIG_IGN);
2597 #endif
2598 #ifdef TRAP_BUS
2599  signal(SIGBUS, handle_SIGBUS);
2600 #endif
2601 #ifdef SIGUSR1
2602  signal(SIGUSR1, handle_SIGHUP);
2603 #endif
2604  signal(SIGHUP, handle_SIGHUP);
2605 }
2606 
2607 SWITCH_DECLARE(uint32_t) switch_core_debug_level(void)
2608 {
2609  return runtime.debug_level;
2610 }
2611 
2612 SWITCH_DECLARE(int32_t) switch_core_sps(void)
2613 {
2614  return runtime.sps;
2615 }
2616 
2617 SWITCH_DECLARE(int32_t) switch_core_sps_last(void)
2618 {
2619  return runtime.sps_last;
2620 }
2621 
2622 SWITCH_DECLARE(int32_t) switch_core_sps_peak(void)
2623 {
2624  return runtime.sps_peak;
2625 }
2626 
2627 SWITCH_DECLARE(int32_t) switch_core_sps_peak_fivemin(void)
2628 {
2629  return runtime.sps_peak_fivemin;
2630 }
2631 
2632 SWITCH_DECLARE(int32_t) switch_core_sessions_peak(void)
2633 {
2634  return runtime.sessions_peak;
2635 }
2636 
2637 SWITCH_DECLARE(int32_t) switch_core_sessions_peak_fivemin(void)
2638 {
2639  return runtime.sessions_peak_fivemin;
2640 }
2641 
2642 SWITCH_DECLARE(uint32_t) switch_core_max_audio_channels(uint32_t limit)
2643 {
2644  if (limit) {
2645  runtime.max_audio_channels = limit;
2646  }
2647 
2648  return runtime.max_audio_channels;
2649 }
2650 
2651 SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *val)
2652 {
2653  int *intval = (int *) val;
2654  int oldintval = 0, newintval = 0;
2655 
2656  if (intval) {
2657  oldintval = *intval;
2658  }
2659 
2660  if (switch_test_flag((&runtime), SCF_SHUTTING_DOWN)) {
2661  return -1;
2662  }
2663 
2664  switch (cmd) {
2665  case SCSC_RECOVER:
2666  {
2667  char *arg = (char *) val;
2668  char *tech = NULL, *prof = NULL;
2669  int r, flush = 0;
2670 
2671  if (!zstr(arg)) {
2672  tech = strdup(arg);
2673  switch_assert(tech);
2674 
2675  if ((prof = strchr(tech, ':'))) {
2676  *prof++ = '\0';
2677  }
2678 
2679  if (!strcasecmp(tech, "flush")) {
2680  flush++;
2681 
2682  if (prof) {
2683  char *tech = prof;
2684  if ((prof = strchr(tech, ':'))) {
2685  *prof++ = '\0';
2686  }
2687  }
2688  }
2689 
2690  }
2691 
2692  if (flush) {
2693  switch_core_recovery_flush(tech, prof);
2694  r = -1;
2695  } else {
2696  r = switch_core_recovery_recover(tech, prof);
2697  }
2698 
2699  switch_safe_free(tech);
2700  return r;
2701 
2702  }
2703  break;
2704  case SCSC_DEBUG_SQL:
2705  {
2706  if (switch_test_flag((&runtime), SCF_DEBUG_SQL)) {
2707  switch_clear_flag((&runtime), SCF_DEBUG_SQL);
2708  newintval = 0;
2709  } else {
2710  switch_set_flag((&runtime), SCF_DEBUG_SQL);
2711  newintval = 1;
2712  }
2713  }
2714  break;
2715  case SCSC_VERBOSE_EVENTS:
2716  if (intval) {
2717  if (oldintval > -1) {
2718  if (oldintval) {
2719  switch_set_flag((&runtime), SCF_VERBOSE_EVENTS);
2720  } else {
2721  switch_clear_flag((&runtime), SCF_VERBOSE_EVENTS);
2722  }
2723  }
2724  newintval = switch_test_flag((&runtime), SCF_VERBOSE_EVENTS);
2725  }
2726  break;
2727  case SCSC_API_EXPANSION:
2728  if (intval) {
2729  if (oldintval > -1) {
2730  if (oldintval) {
2731  switch_set_flag((&runtime), SCF_API_EXPANSION);
2732  } else {
2733  switch_clear_flag((&runtime), SCF_API_EXPANSION);
2734  }
2735  }
2736  newintval = switch_test_flag((&runtime), SCF_API_EXPANSION);
2737  }
2738  break;
2739  case SCSC_THREADED_SYSTEM_EXEC:
2740  if (intval) {
2741  if (oldintval > -1) {
2742  if (oldintval) {
2743  switch_set_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
2744  } else {
2745  switch_clear_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
2746  }
2747  }
2748  newintval = switch_test_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
2749  }
2750  break;
2751  case SCSC_CALIBRATE_CLOCK:
2752  switch_time_calibrate_clock();
2753  break;
2754  case SCSC_FLUSH_DB_HANDLES:
2755  switch_cache_db_flush_handles();
2756  break;
2757  case SCSC_SEND_SIGHUP:
2758  handle_SIGHUP(1);
2759  break;
2760  case SCSC_SYNC_CLOCK:
2761  switch_time_sync();
2762  newintval = 0;
2763  break;
2764  case SCSC_SYNC_CLOCK_WHEN_IDLE:
2765  newintval = switch_core_session_sync_clock();
2766  break;
2767  case SCSC_SQL:
2768  if (oldintval) {
2769  switch_core_sqldb_resume();
2770  } else {
2771  switch_core_sqldb_pause();
2772  }
2773  break;
2774  case SCSC_PAUSE_ALL:
2775  if (oldintval) {
2776  switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
2777  } else {
2778  switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
2779  }
2780  break;
2781  case SCSC_PAUSE_INBOUND:
2782  if (oldintval) {
2783  switch_set_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS);
2784  } else {
2785  switch_clear_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS);
2786  }
2787  break;
2788  case SCSC_PAUSE_OUTBOUND:
2789  if (oldintval) {
2790  switch_set_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS);
2791  } else {
2792  switch_clear_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS);
2793  }
2794  break;
2795  case SCSC_HUPALL:
2796  switch_core_session_hupall(SWITCH_CAUSE_MANAGER_REQUEST);
2797  break;
2798  case SCSC_CANCEL_SHUTDOWN:
2799  switch_clear_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
2800  break;
2801  case SCSC_SAVE_HISTORY:
2802  switch_console_save_history();
2803  break;
2804  case SCSC_CRASH:
2805  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Declinatio Mortuus Obfirmo!\n");
2806  switch_console_save_history();
2807  abort();
2808  break;
2809  case SCSC_SHUTDOWN_NOW:
2810  switch_console_save_history();
2811  exit(0);
2812  break;
2813  case SCSC_REINCARNATE_NOW:
2814  switch_console_save_history();
2815  exit(SWITCH_STATUS_RESTART);
2816  break;
2817  case SCSC_SHUTDOWN_ELEGANT:
2818  case SCSC_SHUTDOWN_ASAP:
2819  {
2820  int x = 19;
2821  uint32_t count;
2822  switch_event_t *shutdown_requested_event = NULL;
2823  if (switch_event_create(&shutdown_requested_event, SWITCH_EVENT_SHUTDOWN_REQUESTED) == SWITCH_STATUS_SUCCESS) {
2824  switch_event_add_header(shutdown_requested_event, SWITCH_STACK_BOTTOM, "Event-Info", "%s", cmd == SCSC_SHUTDOWN_ASAP ? "ASAP" : "elegant");
2825  switch_event_fire(&shutdown_requested_event);
2826  }
2827  switch_set_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
2828  if (cmd == SCSC_SHUTDOWN_ASAP) {
2829  switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
2830  }
2831 
2832  while (runtime.running && switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED) && (count = switch_core_session_count())) {
2833  switch_yield(500000);
2834  if (++x == 20) {
2835  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
2836  "Shutdown in progress, %u session(s) remain.\nShutting down %s\n",
2837  count, cmd == SCSC_SHUTDOWN_ASAP ? "ASAP" : "once there are no active calls.");
2838  x = 0;
2839  }
2840  }
2841 
2842  if (switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED)) {
2843  switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
2844 #ifdef _MSC_VER
2845  win_shutdown();
2846 #endif
2847 
2848  if (oldintval) {
2849  switch_set_flag((&runtime), SCF_RESTART);
2850  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
2851  } else {
2852  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutting down\n");
2853 #ifdef HAVE_SYSTEMD
2854  sd_notifyf(0, "STOPPING=1\n");
2855 #endif
2856 #ifdef _MSC_VER
2857  fclose(stdin);
2858 #endif
2859  }
2860  runtime.running = 0;
2861  } else {
2862  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutdown Cancelled\n");
2863  switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
2864  }
2865  }
2866  break;
2867  case SCSC_PAUSE_CHECK:
2868  newintval = !!(switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS) == SCF_NO_NEW_SESSIONS);
2869  break;
2870  case SCSC_PAUSE_INBOUND_CHECK:
2871  newintval = !!switch_test_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS);
2872  break;
2873  case SCSC_PAUSE_OUTBOUND_CHECK:
2874  newintval = !!switch_test_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS);
2875  break;
2876  case SCSC_READY_CHECK:
2877  newintval = switch_core_ready();
2878  break;
2879  case SCSC_SHUTDOWN_CHECK:
2880  newintval = !!switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
2881  break;
2882  case SCSC_SHUTDOWN:
2883 
2884 #ifdef _MSC_VER
2885  win_shutdown();
2886 #endif
2887 
2888  if (oldintval) {
2889  switch_set_flag((&runtime), SCF_RESTART);
2890  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
2891  } else {
2892  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutting down\n");
2893 #ifdef _MSC_VER
2894  fclose(stdin);
2895 #endif
2896  }
2897  runtime.running = 0;
2898  break;
2899  case SCSC_CHECK_RUNNING:
2900  newintval = runtime.running;
2901  break;
2902  case SCSC_LOGLEVEL:
2903  if (oldintval >= SWITCH_LOG_DISABLE) {
2904  runtime.hard_log_level = oldintval;
2905  }
2906 
2907  if (runtime.hard_log_level > SWITCH_LOG_DEBUG) {
2908  runtime.hard_log_level = SWITCH_LOG_DEBUG;
2909  }
2910  newintval = runtime.hard_log_level;
2911  break;
2912  case SCSC_DEBUG_LEVEL:
2913  if (oldintval > -1) {
2914  if (oldintval > 10)
2915  oldintval = 10;
2916  runtime.debug_level = oldintval;
2917  }
2918  newintval = runtime.debug_level;
2919  break;
2920  case SCSC_MIN_IDLE_CPU:
2921  {
2922  double *dval = (double *) val;
2923  if (dval) {
2924  *dval = switch_core_min_idle_cpu(*dval);
2925  }
2926  intval = NULL;
2927  }
2928  break;
2929  case SCSC_MAX_SESSIONS:
2930  newintval = switch_core_session_limit(oldintval);
2931  break;
2932  case SCSC_LAST_SPS:
2933  newintval = runtime.sps_last;
2934  break;
2935  case SCSC_SPS_PEAK:
2936  if (oldintval == -1) {
2937  runtime.sps_peak = 0;
2938  }
2939  newintval = runtime.sps_peak;
2940  break;
2941  case SCSC_SPS_PEAK_FIVEMIN:
2942  newintval = runtime.sps_peak_fivemin;
2943  break;
2944  case SCSC_SESSIONS_PEAK:
2945  newintval = runtime.sessions_peak;
2946  break;
2947  case SCSC_SESSIONS_PEAK_FIVEMIN:
2948  newintval = runtime.sessions_peak_fivemin;
2949  break;
2950  case SCSC_MAX_DTMF_DURATION:
2951  newintval = switch_core_max_dtmf_duration(oldintval);
2952  break;
2953  case SCSC_MIN_DTMF_DURATION:
2954  newintval = switch_core_min_dtmf_duration(oldintval);
2955  break;
2956  case SCSC_DEFAULT_DTMF_DURATION:
2957  newintval = switch_core_default_dtmf_duration(oldintval);
2958  break;
2959  case SCSC_SPS:
2960  switch_mutex_lock(runtime.throttle_mutex);
2961  if (oldintval > 0) {
2962  runtime.sps_total = oldintval;
2963  }
2964  newintval = runtime.sps_total;
2965  switch_mutex_unlock(runtime.throttle_mutex);
2966  break;
2967 
2968  case SCSC_RECLAIM:
2969  switch_core_memory_reclaim_all();
2970  newintval = 0;
2971  break;
2972  case SCSC_MDNS_RESOLVE:
2973  switch_core_media_set_resolveice(!!oldintval);
2974  break;
2975  case SCSC_SHUTDOWN_CAUSE:
2976  runtime.shutdown_cause = oldintval;
2977  break;
2978  }
2979 
2980  if (intval) {
2981  *intval = newintval;
2982  }
2983 
2984 
2985  return 0;
2986 }
2987 
2988 SWITCH_DECLARE(switch_core_flag_t) switch_core_flags(void)
2989 {
2990  return runtime.flags;
2991 }
2992 
2993 SWITCH_DECLARE(switch_bool_t) switch_core_running(void)
2994 {
2995  return runtime.running ? SWITCH_TRUE : SWITCH_FALSE;
2996 }
2997 
2998 SWITCH_DECLARE(switch_bool_t) switch_core_ready(void)
2999 {
3000  return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS) == SCF_NO_NEW_SESSIONS) ? SWITCH_FALSE : SWITCH_TRUE;
3001 }
3002 
3003 SWITCH_DECLARE(switch_bool_t) switch_core_ready_inbound(void)
3004 {
3005  return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE;
3006 }
3007 
3008 SWITCH_DECLARE(switch_bool_t) switch_core_ready_outbound(void)
3009 {
3010  return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE;
3011 }
3012 
3013 void switch_core_sqldb_destroy(void)
3014 {
3015  if (switch_test_flag((&runtime), SCF_USE_SQL)) {
3016  switch_core_sqldb_stop();
3017  }
3018 }
3019 
3020 SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
3021 {
3022  switch_event_t *event;
3023 
3024  if (switch_event_create(&event, SWITCH_EVENT_SHUTDOWN) == SWITCH_STATUS_SUCCESS) {
3025  switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Shutting Down");
3026  switch_event_fire(&event);
3027  }
3028 
3029  switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
3030  switch_set_flag((&runtime), SCF_SHUTTING_DOWN);
3031 
3032  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "End existing sessions\n");
3033  switch_core_session_hupall(runtime.shutdown_cause);
3034  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clean up modules.\n");
3035 
3036  switch_loadable_module_shutdown();
3037 
3038  switch_curl_destroy();
3039 
3040  switch_ssl_destroy_ssl_locks();
3041  EVP_cleanup();
3042 
3043  switch_scheduler_task_thread_stop();
3044 
3045  switch_rtp_shutdown();
3046  switch_msrp_destroy();
3047 
3048  if (switch_test_flag((&runtime), SCF_USE_AUTO_NAT)) {
3049  switch_nat_shutdown();
3050  }
3051  switch_xml_destroy();
3052  switch_console_shutdown();
3053  switch_channel_global_uninit();
3054 
3055  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Closing Event Engine.\n");
3056  switch_event_shutdown();
3057 
3058  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Finalizing Shutdown.\n");
3059  switch_log_shutdown();
3060 
3061  switch_core_session_uninit();
3062  switch_core_unset_variables();
3063  switch_core_memory_stop();
3064 
3065  if (runtime.console && runtime.console != stdout && runtime.console != stderr) {
3066  fclose(runtime.console);
3067  runtime.console = NULL;
3068  }
3069 
3070  switch_safe_free(SWITCH_GLOBAL_dirs.base_dir);
3071  switch_safe_free(SWITCH_GLOBAL_dirs.mod_dir);
3072  switch_safe_free(SWITCH_GLOBAL_dirs.conf_dir);
3073  switch_safe_free(SWITCH_GLOBAL_dirs.log_dir);
3074  switch_safe_free(SWITCH_GLOBAL_dirs.db_dir);
3075  switch_safe_free(SWITCH_GLOBAL_dirs.script_dir);
3076  switch_safe_free(SWITCH_GLOBAL_dirs.htdocs_dir);
3077  switch_safe_free(SWITCH_GLOBAL_dirs.grammar_dir);
3078  switch_safe_free(SWITCH_GLOBAL_dirs.fonts_dir);
3079  switch_safe_free(SWITCH_GLOBAL_dirs.images_dir);
3080  switch_safe_free(SWITCH_GLOBAL_dirs.storage_dir);
3081  switch_safe_free(SWITCH_GLOBAL_dirs.cache_dir);
3082  switch_safe_free(SWITCH_GLOBAL_dirs.recordings_dir);
3083  switch_safe_free(SWITCH_GLOBAL_dirs.sounds_dir);
3084  switch_safe_free(SWITCH_GLOBAL_dirs.run_dir);
3085  switch_safe_free(SWITCH_GLOBAL_dirs.temp_dir);
3086  switch_safe_free(SWITCH_GLOBAL_dirs.data_dir);
3087  switch_safe_free(SWITCH_GLOBAL_dirs.localstate_dir);
3088  switch_safe_free(SWITCH_GLOBAL_dirs.certs_dir);
3089  switch_safe_free(SWITCH_GLOBAL_dirs.lib_dir);
3090 
3091  switch_safe_free(SWITCH_GLOBAL_filenames.conf_name);
3092 
3093  switch_event_destroy(&runtime.global_vars);
3094  switch_core_hash_destroy(&runtime.ptimes);
3095  switch_core_hash_destroy(&runtime.mime_types);
3096  switch_core_hash_destroy(&runtime.mime_type_exts);
3097 
3098  if (IP_LIST.hash) {
3099  switch_core_hash_destroy(&IP_LIST.hash);
3100  }
3101 
3102  if (IP_LIST.pool) {
3103  switch_core_destroy_memory_pool(&IP_LIST.pool);
3104  }
3105 
3106  switch_core_media_deinit();
3107 
3108  if (runtime.memory_pool) {
3109  fspr_pool_destroy(runtime.memory_pool);
3110  fspr_terminate();
3111  }
3112 
3113  sqlite3_shutdown();
3114 
3115  return switch_test_flag((&runtime), SCF_RESTART) ? SWITCH_STATUS_RESTART : SWITCH_STATUS_SUCCESS;
3116 }
3117 
3118 SWITCH_DECLARE(switch_status_t) switch_core_management_exec(char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
3119 {
3120  const switch_management_interface_t *ptr;
3121  switch_status_t status = SWITCH_STATUS_FALSE;
3122 
3123  if ((ptr = switch_loadable_module_get_management_interface(relative_oid))) {
3124  status = ptr->management_function(relative_oid, action, data, datalen);
3125  }
3126 
3127  return status;
3128 }
3129 
3130 SWITCH_DECLARE(void) switch_core_memory_reclaim_all(void)
3131 {
3132  switch_core_memory_reclaim_logger();
3133  switch_core_memory_reclaim_events();
3134  switch_core_memory_reclaim();
3135 }
3136 
3137 
3138 struct system_thread_handle {
3139  const char *cmd;
3140  switch_thread_cond_t *cond;
3141  switch_mutex_t *mutex;
3142  switch_memory_pool_t *pool;
3143  int ret;
3144  int *fds;
3145 };
3146 
3147 static void *SWITCH_THREAD_FUNC system_thread(switch_thread_t *thread, void *obj)
3148 {
3149  struct system_thread_handle *sth = (struct system_thread_handle *) obj;
3150 
3151 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
3152  struct rlimit rlim;
3153  struct rlimit rlim_save;
3154 
3155  memset(&rlim, 0, sizeof(rlim));
3156  getrlimit(RLIMIT_STACK, &rlim);
3157 
3158  memset(&rlim_save, 0, sizeof(rlim_save));
3159  getrlimit(RLIMIT_STACK, &rlim_save);
3160 
3161  rlim.rlim_cur = rlim.rlim_max;
3162  if (setrlimit(RLIMIT_STACK, &rlim) < 0) {
3163  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
3164  }
3165 #endif
3166 
3167  if (sth->fds) {
3168  dup2(sth->fds[1], STDOUT_FILENO);
3169  }
3170 
3171  sth->ret = system(sth->cmd);
3172 
3173 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
3174  if (setrlimit(RLIMIT_STACK, &rlim_save) < 0) {
3175  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
3176  }
3177 #endif
3178 
3179  switch_mutex_lock(sth->mutex);
3180  switch_thread_cond_signal(sth->cond);
3181  switch_mutex_unlock(sth->mutex);
3182 
3183  switch_core_destroy_memory_pool(&sth->pool);
3184 
3185  return NULL;
3186 }
3187 
3188 
3189 static int switch_system_thread(const char *cmd, switch_bool_t wait)
3190 {
3191  switch_thread_t *thread;
3192  switch_threadattr_t *thd_attr;
3193  int ret = 0;
3194  struct system_thread_handle *sth;
3195  switch_memory_pool_t *pool;
3196 
3197  if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
3198  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
3199  return 1;
3200  }
3201 
3202  if (!(sth = switch_core_alloc(pool, sizeof(struct system_thread_handle)))) {
3203  switch_core_destroy_memory_pool(&pool);
3204  return 1;
3205  }
3206 
3207  sth->pool = pool;
3208  sth->cmd = switch_core_strdup(pool, cmd);
3209 
3210  switch_thread_cond_create(&sth->cond, sth->pool);
3211  switch_mutex_init(&sth->mutex, SWITCH_MUTEX_NESTED, sth->pool);
3212  switch_mutex_lock(sth->mutex);
3213 
3214  switch_threadattr_create(&thd_attr, sth->pool);
3215  switch_threadattr_stacksize_set(thd_attr, SWITCH_SYSTEM_THREAD_STACKSIZE);
3216  switch_threadattr_detach_set(thd_attr, 1);
3217  switch_thread_create(&thread, thd_attr, system_thread, sth, sth->pool);
3218 
3219  if (wait) {
3220  switch_thread_cond_wait(sth->cond, sth->mutex);
3221  ret = sth->ret;
3222  }
3223  switch_mutex_unlock(sth->mutex);
3224 
3225  return ret;
3226 }
3227 
3228 SWITCH_DECLARE(int) switch_max_file_desc(void)
3229 {
3230  int max = 0;
3231 
3232 #ifndef WIN32
3233 #if defined(HAVE_GETDTABLESIZE)
3234  max = getdtablesize();
3235 #else
3236  max = sysconf(_SC_OPEN_MAX);
3237 #endif
3238 #endif
3239 
3240  return max;
3241 
3242 }
3243 
3244 SWITCH_DECLARE(void) switch_close_extra_files(int *keep, int keep_ttl)
3245 {
3246  int open_max = switch_max_file_desc();
3247  int i, j;
3248 
3249  for (i = 3; i < open_max; i++) {
3250  if (keep) {
3251  for (j = 0; j < keep_ttl; j++) {
3252  if (i == keep[j]) {
3253  goto skip;
3254  }
3255  }
3256  }
3257 
3258  close(i);
3259 
3260  skip:
3261 
3262  continue;
3263 
3264  }
3265 }
3266 
3267 
3268 #ifdef WIN32
3269 static int switch_system_fork(const char *cmd, switch_bool_t wait)
3270 {
3271  return switch_system_thread(cmd, wait);
3272 }
3273 
3274 SWITCH_DECLARE(pid_t) switch_fork(void)
3275 {
3276  return -1;
3277 }
3278 
3279 
3280 #else
3281 
3282 SWITCH_DECLARE(pid_t) switch_fork(void)
3283 {
3284  int i = fork();
3285 
3286  if (!i) {
3287  set_low_priority();
3288  }
3289 
3290  return i;
3291 }
3292 
3293 
3294 
3295 static int switch_system_fork(const char *cmd, switch_bool_t wait)
3296 {
3297  int pid;
3298  char *dcmd = strdup(cmd);
3299 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
3300  struct rlimit rlim;
3301  struct rlimit rlim_save;
3302 #endif
3303 
3304  switch_core_set_signal_handlers();
3305 
3306  pid = switch_fork();
3307 
3308  if (pid) {
3309  if (wait) {
3310  waitpid(pid, NULL, 0);
3311  }
3312  free(dcmd);
3313  } else {
3314  switch_close_extra_files(NULL, 0);
3315 
3316 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
3317  memset(&rlim, 0, sizeof(rlim));
3318  getrlimit(RLIMIT_STACK, &rlim);
3319 
3320  memset(&rlim_save, 0, sizeof(rlim_save));
3321  getrlimit(RLIMIT_STACK, &rlim_save);
3322 
3323  rlim.rlim_cur = rlim.rlim_max;
3324  if (setrlimit(RLIMIT_STACK, &rlim) < 0) {
3325  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
3326  }
3327 #endif
3328 
3329  if (system(dcmd) == -1) {
3330  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute because of a command error : %s\n", dcmd);
3331  }
3332  free(dcmd);
3333  exit(0);
3334  }
3335 
3336  return 0;
3337 }
3338 #endif
3339 
3340 
3341 
3342 SWITCH_DECLARE(int) switch_system(const char *cmd, switch_bool_t wait)
3343 {
3344  int retval = 0;
3345 #ifdef __linux__
3346  switch_bool_t spawn_instead_of_system = switch_true(switch_core_get_variable("spawn_instead_of_system"));
3347 #else
3348  switch_bool_t spawn_instead_of_system = SWITCH_FALSE;
3349 #endif
3350 
3351  if (spawn_instead_of_system) {
3352  retval = switch_stream_spawn(cmd, SWITCH_TRUE, wait, NULL);
3353  } else if (switch_test_flag((&runtime), SCF_THREADED_SYSTEM_EXEC)) {
3354  retval = switch_system_thread(cmd, wait);
3355  } else {
3356  retval = switch_system_fork(cmd, wait);
3357  }
3358  return retval;
3359 }
3360 
3361 
3362 
3363 SWITCH_DECLARE(int) switch_stream_system_fork(const char *cmd, switch_stream_handle_t *stream)
3364 {
3365  return switch_stream_system(cmd, stream);
3366 }
3367 
3368 #ifdef __linux__
3369 extern char **environ;
3370 #endif
3371 
3372 SWITCH_DECLARE(int) switch_stream_spawn(const char *cmd, switch_bool_t shell, switch_bool_t wait, switch_stream_handle_t *stream)
3373 {
3374 #ifndef __linux__
3375  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "posix_spawn is unsupported on current platform\n");
3376  return 1;
3377 #else
3378  int status = 0;
3379  char buffer[1024];
3380  pid_t pid;
3381  char *pdata = NULL, *argv[64];
3382  posix_spawn_file_actions_t action;
3383  posix_spawnattr_t *attr;
3384  int cout_pipe[2];
3385  int cerr_pipe[2];
3386  struct pollfd pfds[2] = { {0} };
3387 
3388  if (zstr(cmd)) {
3389  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to execute switch_spawn_stream because of empty command\n");
3390  return 1;
3391  }
3392 
3393  if (shell) {
3394  argv[0] = switch_core_get_variable("spawn_system_shell");
3395  argv[1] = "-c";
3396  argv[2] = (char *)cmd;
3397  argv[3] = NULL;
3398  if (zstr(argv[0])) {
3399  argv[0] = "/bin/sh";
3400  }
3401  } else {
3402  if (!(pdata = strdup(cmd))) {
3403  return 1;
3404  }
3405  if (!switch_separate_string(pdata, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) {
3406  free(pdata);
3407  return 1;
3408  }
3409  }
3410 
3411  if (!(attr = malloc(sizeof(posix_spawnattr_t)))) {
3412  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute switch_spawn_stream because of a memory error: %s\n", cmd);
3413  switch_safe_free(pdata);
3414  return 1;
3415  }
3416 
3417  if (stream) {
3418  if (pipe(cout_pipe)) {
3419  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute switch_spawn_stream because of a pipe error: %s\n", cmd);
3420  free(attr);
3421  switch_safe_free(pdata);
3422  return 1;
3423  }
3424 
3425  if (pipe(cerr_pipe)) {
3426  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute switch_spawn_stream because of a pipe error: %s\n", cmd);
3427  close(cout_pipe[0]);
3428  close(cout_pipe[1]);
3429  free(attr);
3430  switch_safe_free(pdata);
3431  return 1;
3432  }
3433  }
3434 
3435  memset(attr, 0, sizeof(posix_spawnattr_t));
3436  posix_spawnattr_init(attr);
3437  posix_spawnattr_setflags(attr, POSIX_SPAWN_USEVFORK);
3438 
3439  posix_spawn_file_actions_init(&action);
3440 
3441  if (stream) {
3442  posix_spawn_file_actions_addclose(&action, cout_pipe[0]);
3443  posix_spawn_file_actions_addclose(&action, cerr_pipe[0]);
3444  posix_spawn_file_actions_adddup2(&action, cout_pipe[1], 1);
3445  posix_spawn_file_actions_adddup2(&action, cerr_pipe[1], 2);
3446 
3447  posix_spawn_file_actions_addclose(&action, cout_pipe[1]);
3448  posix_spawn_file_actions_addclose(&action, cerr_pipe[1]);
3449  }
3450 
3451  if (posix_spawnp(&pid, argv[0], &action, attr, argv, environ) != 0) {
3452  status = 1;
3453  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to execute posix_spawnp: %s\n", cmd);
3454  if (stream) {
3455  close(cout_pipe[0]), close(cerr_pipe[0]);
3456  close(cout_pipe[1]), close(cerr_pipe[1]);
3457  }
3458  } else {
3459  if (stream) {
3460  close(cout_pipe[1]), close(cerr_pipe[1]); /* close child-side of pipes */
3461 
3462  pfds[0] = (struct pollfd) {
3463  .fd = cout_pipe[0],
3464  .events = POLLIN,
3465  .revents = 0
3466  };
3467 
3468  pfds[1] = (struct pollfd) {
3469  .fd = cerr_pipe[0],
3470  .events = POLLIN,
3471  .revents = 0
3472  };
3473 
3474  while (poll(pfds, 2, /*timeout*/-1) > 0) {
3475  if (pfds[0].revents & POLLIN) {
3476  int bytes_read = read(cout_pipe[0], buffer, sizeof(buffer));
3477  stream->raw_write_function(stream, (unsigned char *)buffer, bytes_read);
3478  } else if (pfds[1].revents & POLLIN) {
3479  int bytes_read = read(cerr_pipe[0], buffer, sizeof(buffer));
3480  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "STDERR of cmd (%s): %.*s\n", cmd, bytes_read, buffer);
3481  } else {
3482  break; /* nothing left to read */
3483  }
3484  }
3485 
3486  close(cout_pipe[0]), close(cerr_pipe[0]);
3487  }
3488 
3489  if (wait) {
3490  if (waitpid(pid, &status, 0) != pid) {
3491  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "waitpid failed: %s\n", cmd);
3492  } else if (status != 0) {
3493  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Exit status (%d): %s\n", status, cmd);
3494  }
3495  }
3496  }
3497 
3498  posix_spawnattr_destroy(attr);
3499  free(attr);
3500  posix_spawn_file_actions_destroy(&action);
3501  switch_safe_free(pdata);
3502 
3503  return status;
3504 #endif
3505 }
3506 
3507 SWITCH_DECLARE(int) switch_spawn(const char *cmd, switch_bool_t wait)
3508 {
3509  return switch_stream_spawn(cmd, SWITCH_FALSE, wait, NULL);
3510 }
3511 
3512 SWITCH_DECLARE(switch_status_t) switch_core_get_stacksizes(switch_size_t *cur, switch_size_t *max)
3513 {
3514 #ifdef HAVE_SETRLIMIT
3515  struct rlimit rlp;
3516 
3517  memset(&rlp, 0, sizeof(rlp));
3518  getrlimit(RLIMIT_STACK, &rlp);
3519 
3520  *cur = rlp.rlim_cur;
3521  *max = rlp.rlim_max;
3522 
3523  return SWITCH_STATUS_SUCCESS;
3524 
3525 #else
3526 
3527  return SWITCH_STATUS_FALSE;
3528 
3529 #endif
3530 
3531 
3532 
3533 }
3534 
3535 
3536 SWITCH_DECLARE(int) switch_stream_system(const char *cmd, switch_stream_handle_t *stream)
3537 {
3538 #ifdef __linux__
3539  switch_bool_t spawn_instead_of_system = switch_true(switch_core_get_variable("spawn_instead_of_system"));
3540 #else
3541  switch_bool_t spawn_instead_of_system = SWITCH_FALSE;
3542 #endif
3543 
3544  if (spawn_instead_of_system){
3545  return switch_stream_spawn(cmd, SWITCH_TRUE, SWITCH_TRUE, stream);
3546  } else {
3547  char buffer[128];
3548  size_t bytes;
3549  FILE* pipe = popen(cmd, "r");
3550  if (!pipe) return 1;
3551 
3552  while (!feof(pipe)) {
3553  while ((bytes = fread(buffer, 1, 128, pipe)) > 0) {
3554  if (stream != NULL) {
3555  stream->raw_write_function(stream, (unsigned char *)buffer, bytes);
3556  }
3557  }
3558  }
3559 
3560  if (ferror(pipe)) {
3561  pclose(pipe);
3562  return 1;
3563  }
3564 
3565  pclose(pipe);
3566  return 0;
3567  }
3568 }
3569 
3570 SWITCH_DECLARE(uint16_t) switch_core_get_rtp_port_range_start_port(void)
3571 {
3572  uint16_t start_port = 0;
3573 
3574  /* By default pass rtp port range start value as zero in order to get actual
3575  * RTP port range start value as configured */
3576  start_port = (uint16_t)switch_rtp_set_start_port((switch_port_t)start_port);
3577 
3578  return start_port;
3579 }
3580 
3581 SWITCH_DECLARE(uint16_t) switch_core_get_rtp_port_range_end_port(void)
3582 {
3583  uint16_t end_port = 0;
3584 
3585  /* By default pass rtp port range end value as zero in order to get actual
3586  * RTP port range end value as configured */
3587  end_port = (uint16_t)switch_rtp_set_end_port((switch_port_t)end_port);
3588 
3589  return end_port;
3590 }
3591 
3592 SWITCH_DECLARE(const char *) switch_core_get_event_channel_key_separator(void)
3593 {
3594  return runtime.event_channel_key_separator;
3595 }
3596 
3597 /* For Emacs:
3598  * Local Variables:
3599  * mode:c
3600  * indent-tabs-mode:t
3601  * tab-width:4
3602  * c-basic-offset:4
3603  * End:
3604  * For VIM:
3605  * vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
3606  */
switch_msrp.h
SCSC_CANCEL_SHUTDOWN
Definition: switch_types.h:2275
switch_channel_global_uninit
void switch_channel_global_uninit(void)
Definition: switch_channel.c:5025
switch_core_set_signal_handlers
void switch_core_set_signal_handlers(void)
Definition: switch_core.c:2579
switch_state_handler_table
Definition: switch_module_interfaces.h:65
switch_core_memory_init
switch_memory_pool_t * switch_core_memory_init(void)
Definition: switch_core_memory.c:689
switch_core_permanent_strdup
#define switch_core_permanent_strdup(_todup)
Copy a string using permanent memory allocation.
Definition: switch_core.h:707
switch_directories::temp_dir
char * temp_dir
Definition: switch_types.h:558
CF_VIDEO
Definition: switch_types.h:1487
change_user_group
int32_t change_user_group(const char *user, const char *group)
Change user and/or group of the running process.
Definition: switch_core.c:1083
switch_core_get_switchname
const char * switch_core_get_switchname(void)
Definition: switch_core.c:361
switch_runtime::runlevel
uint32_t runlevel
Definition: switch_core_pvt.h:264
switch_event_fire
#define switch_event_fire(event)
Fire an event filling in most of the arguements with obvious values.
Definition: switch_event.h:413
switch_xml_free
void switch_xml_free(_In_opt_ switch_xml_t xml)
frees the memory allocated for an switch_xml structure
switch_time_sync
void switch_time_sync(void)
Definition: switch_time.c:609
switch_filenames::conf_name
char * conf_name
Definition: switch_types.h:577
switch_core_new_memory_pool
#define switch_core_new_memory_pool(p)
Create a new sub memory pool from the core&#39;s master pool.
Definition: switch_core.h:633
switch_msrp_destroy
switch_status_t switch_msrp_destroy(void)
Definition: switch_msrp.c:349
SCF_USE_SQL
Definition: switch_types.h:362
switch_runtime::min_dtmf_duration
uint32_t min_dtmf_duration
Definition: switch_core_pvt.h:256
switch_core_sps
int32_t switch_core_sps(void)
Definition: switch_core.c:2612
switch_runtime::core_db_inner_post_trans_execute
char * core_db_inner_post_trans_execute
Definition: switch_core_pvt.h:284
switch_thread_rwlock_unlock
switch_status_t switch_thread_rwlock_unlock(switch_thread_rwlock_t *rwlock)
Definition: switch_apr.c:286
switch_core_mime_add_type
switch_status_t switch_core_mime_add_type(const char *type, const char *ext)
Definition: switch_core.c:1232
switch_xml_attr_soft
const char * switch_xml_attr_soft(_In_ switch_xml_t xml, _In_z_ const char *attr)
returns the value of the requested tag attribute, or "" if not found
switch_core_time_duration::min
uint32_t min
Definition: switch_core.h:53
switch_runtime::sps_peak
int32_t sps_peak
Definition: switch_core_pvt.h:248
SWITCH_IO_FLAG_NONE
Definition: switch_types.h:1960
check_ip
static void check_ip(void)
Definition: switch_core.c:132
switch_thread_cond_create
switch_status_t switch_thread_cond_create(switch_thread_cond_t **cond, switch_memory_pool_t *pool)
Definition: switch_apr.c:373
switch_directories
Definition: switch_types.h:550
switch_runtime::dummy_cng_frame
switch_frame_t dummy_cng_frame
Definition: switch_core_pvt.h:258
switch_ip_list_t::pool
switch_memory_pool_t * pool
Definition: switch_core.c:1368
system_thread_handle::cmd
const char * cmd
Definition: switch_core.c:3139
SCF_CPF_SOFT_LOOKUP
Definition: switch_types.h:389
switch_directories::htdocs_dir
char * htdocs_dir
Definition: switch_types.h:559
switch_true
static switch_bool_t switch_true(const char *expr)
Evaluate the truthfullness of a string expression.
Definition: switch_utils.h:519
switch_xml_locate_domain
switch_status_t switch_xml_locate_domain(_In_z_ const char *domain_name, _In_opt_ switch_event_t *params, _Out_ switch_xml_t *root, _Out_ switch_xml_t *domain)
switch_runtime::console
FILE * console
Definition: switch_core_pvt.h:235
switch_core_memory_reclaim_logger
void switch_core_memory_reclaim_logger(void)
Definition: switch_log.c:783
SCSC_RECOVER
Definition: switch_types.h:2296
switch_core_time_duration::day
uint32_t day
Definition: switch_core.h:55
switch_core_sqldb_start
switch_status_t switch_core_sqldb_start(switch_memory_pool_t *pool, switch_bool_t manage)
Definition: switch_core_sqldb.c:3565
switch_set_flag
#define switch_set_flag(obj, flag)
Set a flag on an arbitrary object.
Definition: switch_utils.h:700
switch_test_subnet
#define switch_test_subnet(_ip, _net, _mask)
Definition: switch_utils.h:1380
SWITCH_THREAD_FUNC
#define SWITCH_THREAD_FUNC
Definition: switch_platform.h:203
switch_core_dump_variables
void switch_core_dump_variables(switch_stream_handle_t *stream)
Definition: switch_core.c:345
switch_event_add_header_string_nodup
switch_status_t switch_event_add_header_string_nodup(switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
Definition: switch_event.c:1239
SCSC_MIN_DTMF_DURATION
Definition: switch_types.h:2271
switch_text_channel_t
switch_text_channel_t
A target to write log/debug info to.
Definition: switch_types.h:1312
SCF_CLEAR_SQL
Definition: switch_types.h:380
switch_curl.h
switch_nat_shutdown
void switch_nat_shutdown(void)
Shuts down the NAT Traversal System.
Definition: switch_nat.c:741
switch_core_sps_peak_fivemin
int32_t switch_core_sps_peak_fivemin(void)
Definition: switch_core.c:2627
SWITCH_CHANNEL_LOG
#define SWITCH_CHANNEL_LOG
Definition: switch_types.h:1330
switch_runtime::initiated
switch_time_t initiated
Definition: switch_core_pvt.h:225
SWITCH_TRUE
Definition: switch_types.h:439
switch_core_uptime
switch_time_t switch_core_uptime(void)
Number of microseconds the system has been up.
Definition: switch_core.c:2552
switch_core_get_rtp_port_range_end_port
uint16_t switch_core_get_rtp_port_range_end_port(void)
Get RTP port range end value.
Definition: switch_core.c:3581
switch_core_hash_destroy
switch_status_t switch_core_hash_destroy(_Inout_ switch_hash_t **hash)
Destroy an existing hash table.
number
const char *const const double number
Definition: switch_cJSON.h:254
switch_directories::cache_dir
char * cache_dir
Definition: switch_types.h:562
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.
SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON
Definition: switch_types.h:392
switch_core_sessions_peak
int32_t switch_core_sessions_peak(void)
Definition: switch_core.c:2632
switch_xml_attr
const char * switch_xml_attr(_In_opt_ switch_xml_t xml, _In_opt_z_ const char *attr)
returns the value of the requested tag attribute, or NULL if not found
switch_event_del_header
#define switch_event_del_header(_e, _h)
Definition: switch_event.h:212
switch_runtime::state_handlers
const switch_state_handler_table_t * state_handlers[SWITCH_MAX_STATE_HANDLERS]
Definition: switch_core_pvt.h:233
switch_core_sessions_per_second
uint32_t switch_core_sessions_per_second(_In_ uint32_t new_limit)
Set/Get Session Rate Limit.
switch_runtime::events_use_dispatch
int events_use_dispatch
Definition: switch_core_pvt.h:285
switch_stream_handle::raw_write_function
switch_stream_handle_raw_write_function_t raw_write_function
Definition: switch_module_interfaces.h:97
switch_core_test_flag
int switch_core_test_flag(int flag)
Definition: switch_core.c:1792
switch_core_hash_init
#define switch_core_hash_init(_hash)
Definition: switch_core.h:1431
switch_runtime::sps_total
uint32_t sps_total
Definition: switch_core_pvt.h:245
switch_core_add_state_handler
int switch_core_add_state_handler(const switch_state_handler_table_t *state_handler)
Definition: switch_core.c:317
SCSC_PAUSE_OUTBOUND_CHECK
Definition: switch_types.h:2288
SCSC_SHUTDOWN_CAUSE
Definition: switch_types.h:2302
fspr_threadattr_t
Definition: switch_apr.c:648
switch_version_full
const char * switch_version_full(void)
Definition: switch_version.c:53
switch_ssl_init_ssl_locks
void switch_ssl_init_ssl_locks(void)
Definition: switch_core_cert.c:58
switch_directories::base_dir
char * base_dir
Definition: switch_types.h:551
switch_ssl.h
switch_core_pvt.h
switch_time_set_nanosleep
void switch_time_set_nanosleep(switch_bool_t enable)
Definition: switch_time.c:366
switch_runtime::timer_affinity
int32_t timer_affinity
Definition: switch_core_pvt.h:268
switch_network_list_create
switch_status_t switch_network_list_create(switch_network_list_t **list, const char *name, switch_bool_t default_type, switch_memory_pool_t *pool)
Definition: switch_utils.c:459
SCSC_SHUTDOWN
Definition: switch_types.h:2262
switch_network_list_add_cidr_token
switch_status_t switch_network_list_add_cidr_token(switch_network_list_t *list, const char *cidr_str, switch_bool_t ok, const char *token)
Definition: switch_utils.c:702
SWITCH_STATUS_MEMERR
Definition: switch_types.h:1240
switch_runtime::core_db_post_trans_execute
char * core_db_post_trans_execute
Definition: switch_core_pvt.h:282
switch_directories::fonts_dir
char * fonts_dir
Definition: switch_types.h:567
switch_runtime::dbname
char * dbname
Definition: switch_core_pvt.h:262
set_low_priority
int32_t set_low_priority(void)
Definition: switch_core.c:945
ip_t
Definition: switch_utils.h:277
SWITCH_LOG_INFO
Definition: switch_types.h:1290
system_thread_handle::mutex
switch_mutex_t * mutex
Definition: switch_core.c:3141
switch_core_memory_stop
void switch_core_memory_stop(void)
Definition: switch_core_memory.c:671
switch_core_running
switch_bool_t switch_core_running(void)
Definition: switch_core.c:2993
SWITCH_LOG_DISABLE
Definition: switch_types.h:1297
switch_scheduler_task_thread_start
void switch_scheduler_task_thread_start(void)
Start the scheduler system.
Definition: switch_scheduler.c:354
switch_bool_t
switch_bool_t
Definition: switch_types.h:437
switch_parse_cidr
int switch_parse_cidr(const char *string, ip_t *ip, ip_t *mask, uint32_t *bitp)
Definition: switch_utils.c:743
switch_max_file_desc
int switch_max_file_desc(void)
Definition: switch_core.c:3228
switch_core_strdup
#define switch_core_strdup(_pool, _todup)
Copy a string using memory allocation from a given pool.
Definition: switch_core.h:733
SCF_API_EXPANSION
Definition: switch_types.h:385
switch_close_extra_files
void switch_close_extra_files(int *keep, int keep_ttl)
Definition: switch_core.c:3244
SCSC_LOGLEVEL
Definition: switch_types.h:2264
SCF_AUTO_SCHEMAS
Definition: switch_types.h:377
SCF_SESSION_THREAD_POOL
Definition: switch_types.h:386
switch_runtime::max_audio_channels
uint32_t max_audio_channels
Definition: switch_core_pvt.h:288
SCF_VERBOSE_EVENTS
Definition: switch_types.h:375
switch_core_session_sync_clock
int switch_core_session_sync_clock(void)
Definition: switch_core_session.c:1509
switch_threadattr_stacksize_set
switch_status_t switch_threadattr_stacksize_set(switch_threadattr_t *attr, switch_size_t stacksize)
Definition: switch_apr.c:683
DBTYPE_MSSQL
Definition: switch_core_pvt.h:221
switch_runtime
Definition: switch_core_pvt.h:224
switch_core_destroy_memory_pool
#define switch_core_destroy_memory_pool(p)
Returns a subpool back to the main pool.
Definition: switch_core.h:642
pool
switch_memory_pool_t * pool
Definition: switch_channel.c:50
switch_core_session_read_video_frame
switch_status_t switch_core_session_read_video_frame(_In_ switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
Read a video frame from a session.
switch_event_add_header
switch_status_t switch_event_add_header(switch_event_t *event, switch_stack_t stack, const char *header_name, const char *fmt,...) PRINTF_FUNCTION(4
Add a header to an event.
switch_event
Representation of an event.
Definition: switch_event.h:80
SCSC_REINCARNATE_NOW
Definition: switch_types.h:2280
cc
const char * cc
Definition: cc.h:2
switch_core_set_globals
void switch_core_set_globals(void)
Initiate Globals.
Definition: switch_core.c:633
switch_core_session_init
void switch_core_session_init(switch_memory_pool_t *pool)
Definition: switch_core_session.c:2625
switch_network_list_add_host_port_mask
switch_status_t switch_network_list_add_host_port_mask(switch_network_list_t *list, const char *host, const char *mask_str, switch_bool_t ok, switch_network_port_range_p port)
Definition: switch_utils.c:707
DBTYPE_DEFAULT
Definition: switch_core_pvt.h:220
switch_event_header
An event Header.
Definition: switch_event.h:65
value
const char *const const char *const const cJSON *const value
Definition: switch_cJSON_Utils.h:39
switch_network_list_add_cidr
#define switch_network_list_add_cidr(_list, _cidr_str, _ok)
Definition: switch_utils.h:1366
SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY
Definition: switch_types.h:390
switch_runtime::global_var_rwlock
switch_thread_rwlock_t * global_var_rwlock
Definition: switch_core_pvt.h:244
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_network_list_validate_ip6_port_token
switch_bool_t switch_network_list_validate_ip6_port_token(switch_network_list_t *list, ip_t ip, int port, const char **token)
Definition: switch_utils.c:497
switch_event_launch_dispatch_threads
void switch_event_launch_dispatch_threads(uint32_t max)
Definition: switch_event.c:653
switch_network_port_range::port
int port
Definition: switch_utils.h:52
switch_core_session
Definition: switch_core_pvt.h:86
SCF_SHUTDOWN_REQUESTED
Definition: switch_types.h:369
switch_loadable_module_get_management_interface
switch_management_interface_t * switch_loadable_module_get_management_interface(const char *relative_oid)
Retrieve the management interface by it&#39;s registered name.
Definition: switch_loadable_module.c:2601
switch_core_destroy
switch_status_t switch_core_destroy(void)
Destroy the core.
Definition: switch_core.c:3020
switch_directories::certs_dir
char * certs_dir
Definition: switch_types.h:566
SSHF_NONE
Definition: switch_types.h:488
cc_s
const char * cc_s
Definition: cc.h:3
SCSC_THREADED_SYSTEM_EXEC
Definition: switch_types.h:2291
switch_runtime::global_vars
switch_event_t * global_vars
Definition: switch_core_pvt.h:228
switch_scheduler_task_thread_stop
void switch_scheduler_task_thread_stop(void)
Stop the scheduler system.
Definition: switch_scheduler.c:367
switch_directories::mod_dir
char * mod_dir
Definition: switch_types.h:552
switch_runtime::hostname
char hostname[256]
Definition: switch_core_pvt.h:273
SWITCH_DECLARE_DATA
#define SWITCH_DECLARE_DATA
Definition: switch_platform.h:197
switch_directories::localstate_dir
char * localstate_dir
Definition: switch_types.h:570
SCSC_PAUSE_CHECK
Definition: switch_types.h:2289
switch_default_ptime
uint32_t switch_default_ptime(const char *name, uint32_t number)
Definition: switch_core.c:2022
SSHF_OWN_THREAD
Definition: switch_types.h:489
switch_xml
A representation of an XML tree.
Definition: switch_xml.h:79
switch_runtime::throttle_mutex
switch_mutex_t * throttle_mutex
Definition: switch_core_pvt.h:241
SWITCH_DEFAULT_DTMF_DURATION
#define SWITCH_DEFAULT_DTMF_DURATION
Definition: switch_types.h:116
SCSC_MIN_IDLE_CPU
Definition: switch_types.h:2284
switch_thread_cond_wait
switch_status_t switch_thread_cond_wait(switch_thread_cond_t *cond, switch_mutex_t *mutex)
Definition: switch_apr.c:378
switch_core_cpu_count
uint32_t switch_core_cpu_count(void)
Definition: switch_core.c:1055
switch_core_mime_type2ext
const char * switch_core_mime_type2ext(const char *mime)
Definition: switch_core.c:1219
switch_runtime::shutdown_cause
switch_call_cause_t shutdown_cause
Definition: switch_core_pvt.h:289
SCSC_SAVE_HISTORY
Definition: switch_types.h:2282
SCSC_SESSIONS_PEAK_FIVEMIN
Definition: switch_types.h:2300
BUFSIZE
#define BUFSIZE
switch_console_shutdown
switch_status_t switch_console_shutdown(void)
Definition: switch_console.c:1674
switch_directories::log_dir
char * log_dir
Definition: switch_types.h:554
switch_core_init_and_modload
switch_status_t switch_core_init_and_modload(switch_core_flag_t flags, switch_bool_t console, const char **err)
Definition: switch_core.c:2443
switch_runtime::state_handler_index
int state_handler_index
Definition: switch_core_pvt.h:234
switch_load_core_config
static void switch_load_core_config(const char *file)
Definition: switch_core.c:2049
switch_event_dup
switch_status_t switch_event_dup(switch_event_t **event, switch_event_t *todup)
Duplicate an event.
Definition: switch_event.c:1334
switch_time_set_timerfd
void switch_time_set_timerfd(int enable)
Definition: switch_time.c:348
SCSC_HUPALL
Definition: switch_types.h:2261
cur
pack cur
Definition: switch_bitpack.h:88
SWITCH_MAX_STATE_HANDLERS
#define SWITCH_MAX_STATE_HANDLERS
Definition: switch_types.h:592
SCSC_SYNC_CLOCK
Definition: switch_types.h:2269
switch_network_port_range
Definition: switch_utils.h:51
thread
static switch_thread_t * thread
Definition: switch_log.c:486
switch_core_thread_set_cpu_affinity
switch_status_t switch_core_thread_set_cpu_affinity(int cpu)
Definition: switch_core.c:1763
system_thread_handle::cond
switch_thread_cond_t * cond
Definition: switch_core.c:3140
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_core_get_stacksizes
switch_status_t switch_core_get_stacksizes(switch_size_t *cur, switch_size_t *max)
Definition: switch_core.c:3512
switch_rtp_set_start_port
switch_port_t switch_rtp_set_start_port(switch_port_t port)
Set/Get RTP start port.
Definition: switch_rtp.c:2582
switch_channel_test_flag
uint32_t switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flag)
Test for presence of given flag on a given channel.
Definition: switch_channel.c:1677
switch_core_flag_t
uint32_t switch_core_flag_t
Definition: switch_types.h:395
switch_runtime::microseconds_per_tick
uint32_t microseconds_per_tick
Definition: switch_core_pvt.h:267
runtime
struct switch_runtime runtime
Definition: switch_core.c:86
switch_directories::grammar_dir
char * grammar_dir
Definition: switch_types.h:560
switch_nat.h
switch_scheduler_add_task
uint32_t switch_scheduler_add_task(time_t task_runtime, switch_scheduler_func_t func, const char *desc, const char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags)
Schedule a task in the future.
Definition: switch_scheduler.c:211
switch_core_sqldb_destroy
void switch_core_sqldb_destroy(void)
Definition: switch_core.c:3013
switch_core_session_read_frame
switch_status_t switch_core_session_read_frame(_In_ switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
Read a frame from a session.
SWITCH_LOG_WARNING
Definition: switch_types.h:1292
SCF_CORE_NON_SQLITE_DB_REQ
Definition: switch_types.h:383
switch_loadable_module_shutdown
void switch_loadable_module_shutdown(void)
Shutdown the module backend and call the shutdown routine in all loaded modules.
Definition: switch_loadable_module.c:2386
SCSC_PAUSE_ALL
Definition: switch_types.h:2260
switch_stream_system
int switch_stream_system(const char *cmd, switch_stream_handle_t *stream)
Definition: switch_core.c:3536
SWITCH_PREFIX_DIR
#define SWITCH_PREFIX_DIR
Definition: switch_core_session.c:2561
switch_frame::data
void * data
Definition: switch_frame.h:66
switch_core_mime_index
switch_hash_index_t * switch_core_mime_index(void)
Definition: switch_core.c:1227
switch_core_thread_session::pool
switch_memory_pool_t * pool
Definition: switch_core.h:225
switch_core_get_rtp_port_range_start_port
uint16_t switch_core_get_rtp_port_range_start_port(void)
Get RTP port range start value.
Definition: switch_core.c:3570
SCF_USE_AUTO_NAT
Definition: switch_types.h:370
zstr
#define zstr(x)
Definition: switch_utils.h:314
switch_check_network_list_ip_port_token
switch_bool_t switch_check_network_list_ip_port_token(const char *ip_str, int port, const char *list_name, const char **token)
Definition: switch_core.c:1374
switch_core_session_id
switch_size_t switch_core_session_id(void)
Provide the current session_id.
Definition: switch_core_session.c:2536
switch_core_get_state_handler
const switch_state_handler_table_t * switch_core_get_state_handler(int index)
Definition: switch_core.c:335
switch_core_max_dtmf_duration
uint32_t switch_core_max_dtmf_duration(uint32_t duration)
Definition: switch_core.c:1704
switch_curl_destroy
void switch_curl_destroy(void)
Definition: switch_curl.c:56
SWITCH_CAUSE_SYSTEM_SHUTDOWN
Definition: switch_types.h:2226
switch_core_get_domain
char * switch_core_get_domain(switch_bool_t dup)
Definition: switch_core.c:367
switch_directories::data_dir
char * data_dir
Definition: switch_types.h:569
SCF_THREADED_SYSTEM_EXEC
Definition: switch_types.h:381
SWITCH_SEQ_FYELLOW
#define SWITCH_SEQ_FYELLOW
Definition: switch_types.h:95
switch_mutex_unlock
switch_status_t switch_mutex_unlock(switch_mutex_t *lock)
Definition: switch_apr.c:313
switch_core_media_deinit
void switch_core_media_deinit(void)
Definition: switch_core_media.c:14240
SWITCH_EVENT_SHUTDOWN_REQUESTED
Definition: switch_types.h:2163
switch_msrp_init
switch_status_t switch_msrp_init(void)
Definition: switch_msrp.c:294
SCSC_PAUSE_INBOUND_CHECK
Definition: switch_types.h:2287
switch_event_shutdown
switch_status_t switch_event_shutdown(void)
Stop the eventing system.
Definition: switch_event.c:549
SWITCH_PRI_REALTIME
Definition: switch_types.h:2605
switch_rtp_init
void switch_rtp_init(switch_memory_pool_t *pool)
Initilize the RTP System.
Definition: switch_rtp.c:1522
switch_system
int switch_system(const char *cmd, switch_bool_t wait)
Definition: switch_core.c:3342
switch_thread_rwlock_rdlock
switch_status_t switch_thread_rwlock_rdlock(switch_thread_rwlock_t *rwlock)
Definition: switch_apr.c:250
switch_core_session_get_channel
_Ret_ switch_channel_t * switch_core_session_get_channel(_In_ switch_core_session_t *session)
Retrieve a pointer to the channel object associated with a given session.
SCSC_DEBUG_SQL
Definition: switch_types.h:2293
switch_event_init
switch_status_t switch_event_init(switch_memory_pool_t *pool)
Start the eventing system.
Definition: switch_event.c:692
switch_runtime::sessions_peak
int32_t sessions_peak
Definition: switch_core_pvt.h:250
switch_clear_flag
#define switch_clear_flag(obj, flag)
Clear a flag on an arbitrary object while locked.
Definition: switch_utils.h:724
SWITCH_MUTEX_NESTED
#define SWITCH_MUTEX_NESTED
Definition: switch_apr.h:318
switch_core_min_dtmf_duration
uint32_t switch_core_min_dtmf_duration(uint32_t duration)
Definition: switch_core.c:1744
switch_ip_list_t::hash
switch_hash_t * hash
Definition: switch_core.c:1369
switch_runtime::ptimes
switch_hash_t * ptimes
Definition: switch_core_pvt.h:231
switch_channel_global_init
void switch_channel_global_init(switch_memory_pool_t *pool)
Definition: switch_channel.c:5016
set_auto_priority
int32_t set_auto_priority(void)
Definition: switch_core.c:1065
switch_thread_rwlock_wrlock
switch_status_t switch_thread_rwlock_wrlock(switch_thread_rwlock_t *rwlock)
Definition: switch_apr.c:260
switch_runtime::dummy_data
char dummy_data[5]
Definition: switch_core_pvt.h:259
switch_system_thread
static int switch_system_thread(const char *cmd, switch_bool_t wait)
Definition: switch_core.c:3189
switch_runtime::odbc_dbtype
switch_dbtype_t odbc_dbtype
Definition: switch_core_pvt.h:272
switch_nat_init
void switch_nat_init(switch_memory_pool_t *pool, switch_bool_t mapping)
Initilize the NAT Traversal System.
Definition: switch_nat.c:399
SWITCH_PATH_SEPARATOR
#define SWITCH_PATH_SEPARATOR
Definition: switch_types.h:124
switch_threadattr_detach_set
switch_status_t switch_threadattr_detach_set(switch_threadattr_t *attr, int32_t on)
Definition: switch_apr.c:678
switch_time_t
int64_t switch_time_t
Definition: switch_apr.h:188
switch_core_idle_cpu
double switch_core_idle_cpu(void)
Definition: switch_core_session.c:2611
SCSC_PAUSE_INBOUND
Definition: switch_types.h:2258
switch_frame::buflen
uint32_t buflen
Definition: switch_frame.h:70
switch_runtime::sessions_peak_fivemin
int32_t sessions_peak_fivemin
Definition: switch_core_pvt.h:251
switch_xml::next
switch_xml_t next
Definition: switch_xml.h:91
switch_network_list_add_host_mask
switch_status_t switch_network_list_add_host_mask(switch_network_list_t *list, const char *host, const char *mask_str, switch_bool_t ok)
Definition: switch_utils.c:737
switch_core_service_thread
static void *SWITCH_THREAD_FUNC switch_core_service_thread(switch_thread_t *thread, void *obj)
Definition: switch_core.c:501
SWITCH_LOG_NOTICE
Definition: switch_types.h:1291
switch_core_get_variables
switch_status_t switch_core_get_variables(switch_event_t **event)
Definition: switch_core.c:386
switch_yield
#define switch_yield(ms)
Wait a desired number of microseconds and yield the CPU.
Definition: switch_utils.h:998
SCSC_SPS
Definition: switch_types.h:2265
switch_runtime::event_channel_key_separator
char * event_channel_key_separator
Definition: switch_core_pvt.h:287
switch_runtime::colorize_console
switch_bool_t colorize_console
Definition: switch_core_pvt.h:260
switch_separate_string
unsigned int switch_separate_string(_In_ char *buf, char delim, _Post_count_(return) char **array, unsigned int arraylen)
Separate a string into an array based on a character delimiter.
SWITCH_STATUS_GENERR
Definition: switch_types.h:1243
SWITCH_EVENT_STARTUP
Definition: switch_types.h:2099
switch_frame::datalen
uint32_t datalen
Definition: switch_frame.h:68
main_ip6
static char main_ip6[256]
Definition: switch_core.c:130
switch_string_var_check
static switch_bool_t switch_string_var_check(char *s, switch_bool_t disable)
Definition: switch_utils.h:763
switch_core_get_uuid
char * switch_core_get_uuid(void)
Retrieve the unique identifier from the core.
Definition: switch_core.c:495
switch_testv6_subnet
switch_bool_t switch_testv6_subnet(ip_t _ip, ip_t _net, ip_t _mask)
Definition: switch_utils.c:483
switch_network_port_range::ports
int ports[MAX_NETWORK_PORTS]
Definition: switch_utils.h:53
switch_core_session::frame_read_mutex
switch_mutex_t * frame_read_mutex
Definition: switch_core_pvt.h:119
SWITCH_MAX_DTMF_DURATION
#define SWITCH_MAX_DTMF_DURATION
Definition: switch_types.h:119
SCF_DIALPLAN_TIMESTAMPS
Definition: switch_types.h:387
switch_event_header::name
char * name
Definition: switch_event.h:67
switch_time_set_matrix
void switch_time_set_matrix(switch_bool_t enable)
Definition: switch_time.c:360
SWITCH_LOG_CONSOLE
Definition: switch_types.h:1296
SCF_SHUTTING_DOWN
Definition: switch_types.h:366
switch_mutex_lock
switch_status_t switch_mutex_lock(switch_mutex_t *lock)
Definition: switch_apr.c:308
switch_core_flags
switch_core_flag_t switch_core_flags(void)
return core flags
Definition: switch_core.c:2988
switch_core_thread_session_end
void switch_core_thread_session_end(switch_core_session_t *session)
Definition: switch_core.c:557
switch_core_session_uninit
void switch_core_session_uninit(void)
Definition: switch_core_session.c:2637
switch_log_str2level
switch_log_level_t switch_log_str2level(_In_z_ const char *str)
Return the level number of the specified log level name.
SCSC_MAX_SESSIONS
Definition: switch_types.h:2268
ip_t::v4
uint32_t v4
Definition: switch_utils.h:278
switch_core_setrlimits
void switch_core_setrlimits(void)
Definition: switch_core.c:1322
SSHF_NO_DEL
Definition: switch_types.h:491
switch_core_session_hupall
void switch_core_session_hupall(_In_ switch_call_cause_t cause)
Hangup all sessions.
switch_core_alloc
#define switch_core_alloc(_pool, _mem)
Allocate memory directly from a memory pool.
Definition: switch_core.h:684
switch_management_interface
Abstract interface to a management module.
Definition: switch_module_interfaces.h:549
switch_core_time_duration::ms
uint32_t ms
Definition: switch_core.h:51
SWITCH_EVENT_HEARTBEAT
Definition: switch_types.h:2122
index
int index
Definition: switch_cJSON.h:160
SWITCH_THREAD_STACKSIZE
#define SWITCH_THREAD_STACKSIZE
Definition: switch_types.h:584
SWITCH_SYSTEM_THREAD_STACKSIZE
#define SWITCH_SYSTEM_THREAD_STACKSIZE
Definition: switch_types.h:585
switch_session_ctl_t
switch_session_ctl_t
Definition: switch_types.h:2257
switch_event_add_header_string
switch_status_t switch_event_add_header_string(switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
Add a string header to an event.
Definition: switch_event.c:1247
SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE
Definition: switch_types.h:391
switch_core_memory_reclaim_all
void switch_core_memory_reclaim_all(void)
Definition: switch_core.c:3130
d_30
static uint32_t d_30
Definition: switch_core.c:2047
switch_rtp_set_end_port
switch_port_t switch_rtp_set_end_port(switch_port_t port)
Set/Get RTP end port.
Definition: switch_rtp.c:2596
SCSC_FLUSH_DB_HANDLES
Definition: switch_types.h:2278
switch_safe_free
#define switch_safe_free(it)
Free a pointer and set it to NULL unless it already is NULL.
Definition: switch_utils.h:885
switch_core_max_audio_channels
uint32_t switch_core_max_audio_channels(uint32_t limit)
Definition: switch_core.c:2642
SCSC_MAX_DTMF_DURATION
Definition: switch_types.h:2270
set_normal_priority
int32_t set_normal_priority(void)
Set the maximum priority the process can obtain.
Definition: switch_core.c:1060
SWITCH_SIG_BREAK
Definition: switch_types.h:1735
switch_atoul
unsigned long switch_atoul(const char *nptr)
Definition: switch_utils.c:4300
load_mime_types
static void load_mime_types(void)
Definition: switch_core.c:1272
SCSC_API_EXPANSION
Definition: switch_types.h:2295
switch_mutex_init
switch_status_t switch_mutex_init(switch_mutex_t **lock, unsigned int flags, switch_memory_pool_t *pool)
Definition: switch_apr.c:293
switch_core_sqldb_resume
void switch_core_sqldb_resume(void)
Definition: switch_core_sqldb.c:3862
system_thread_handle::fds
int * fds
Definition: switch_core.c:3144
SWITCH_LOG_DEBUG1
Definition: switch_types.h:1288
switch_console_init
switch_status_t switch_console_init(switch_memory_pool_t *pool)
Definition: switch_console.c:1663
switch_network_ipv4_mapped_ipv6_addr
char * switch_network_ipv4_mapped_ipv6_addr(const char *ip_str)
Definition: switch_utils.c:582
SCF_USE_NAT_MAPPING
Definition: switch_types.h:379
SWITCH_STATUS_BREAK
Definition: switch_types.h:1245
switch_spawn
int switch_spawn(const char *cmd, switch_bool_t wait)
Definition: switch_core.c:3507
SCF_NO_NEW_OUTBOUND_SESSIONS
Definition: switch_types.h:363
system_thread_handle
Definition: switch_core.c:3138
SWITCH_TIME_T_FMT
#define SWITCH_TIME_T_FMT
Definition: switch_platform.h:291
IP_LIST
static switch_ip_list_t IP_LIST
Definition: switch_core.c:1372
switch_hashtable
Definition: switch_hashtable_private.h:35
switch_directories::sounds_dir
char * sounds_dir
Definition: switch_types.h:564
switch_runtime::mime_type_exts
switch_hash_t * mime_type_exts
Definition: switch_core_pvt.h:230
switch_runtime::event_heartbeat_interval
uint32_t event_heartbeat_interval
Definition: switch_core_pvt.h:278
send_heartbeat
static void send_heartbeat(void)
Definition: switch_core.c:89
switch_frame
An abstraction of a data frame.
Definition: switch_frame.h:54
SCSC_SPS_PEAK_FIVEMIN
Definition: switch_types.h:2298
switch_size_t
uintptr_t switch_size_t
Definition: switch_platform.h:225
switch_core_set_variable
void switch_core_set_variable(const char *varname, const char *value)
Definition: switch_core.c:442
switch_runtime::db_handle_timeout
uint32_t db_handle_timeout
Definition: switch_core_pvt.h:277
switch_core_data_channel
FILE * switch_core_data_channel(switch_text_channel_t channel)
Retrieve a FILE stream of a given text channel name.
Definition: switch_core.c:286
switch_stream_handle
Definition: switch_module_interfaces.h:94
SFF_CNG
Definition: switch_types.h:1681
switch_port_t
uint16_t switch_port_t
Definition: switch_types.h:2320
switch_fp_read_dline
switch_size_t switch_fp_read_dline(FILE *fd, char **buf, switch_size_t *len)
Definition: switch_utils.c:892
system_thread_handle::ret
int ret
Definition: switch_core.c:3143
SCSC_MDNS_RESOLVE
Definition: switch_types.h:2301
switch_directories::images_dir
char * images_dir
Definition: switch_types.h:568
switch_inet_pton
int switch_inet_pton(int af, const char *src, void *dst)
Definition: inet_pton.c:74
switch_core_runtime_loop
void switch_core_runtime_loop(int bg)
Run endlessly until the system is shutdown.
Definition: switch_core.c:1187
switch_runtime::session_hash_mutex
switch_mutex_t * session_hash_mutex
Definition: switch_core_pvt.h:242
SCSC_DEBUG_LEVEL
Definition: switch_types.h:2277
SCSC_SHUTDOWN_ASAP
Definition: switch_types.h:2274
SWITCH_STANDARD_STREAM
#define SWITCH_STANDARD_STREAM(s)
Definition: switch_console.h:46
SWITCH_EVENT_TRAP
Definition: switch_types.h:2123
switch_core_session_count
uint32_t switch_core_session_count(void)
Provide the total number of sessions.
Definition: switch_core_session.c:2518
switch_core_min_idle_cpu
double switch_core_min_idle_cpu(double new_limit)
Definition: switch_core_session.c:2601
switch_event_header::value
char * value
Definition: switch_event.h:69
MAX_NETWORK_PORTS
#define MAX_NETWORK_PORTS
Definition: switch_utils.h:49
switch_nat_late_init
void switch_nat_late_init(void)
Initilize the rest of the NAT Traversal System.
Definition: switch_nat.c:708
handle_SIGHUP
static void handle_SIGHUP(int sig)
Definition: switch_core.c:2008
main_ip4
static char main_ip4[256]
Definition: switch_core.c:129
switch_fork
pid_t switch_fork(void)
Definition: switch_core.c:3282
switch_event_create_plain
static switch_status_t switch_event_create_plain(switch_event_t **event, switch_event_types_t event_id)
Definition: switch_event.h:386
switch_system_fork
static int switch_system_fork(const char *cmd, switch_bool_t wait)
Definition: switch_core.c:3295
switch_core_thread_session::objs
void * objs[SWITCH_MAX_CORE_THREAD_SESSION_OBJS]
Definition: switch_core.h:222
switch_core_memory_reclaim_events
void switch_core_memory_reclaim_events(void)
Definition: switch_event.c:524
switch_xml_destroy
switch_status_t switch_xml_destroy(void)
Definition: switch_xml.c:2473
SWITCH_CAUSE_MANAGER_REQUEST
Definition: switch_types.h:2228
switch_runtime::flags
uint32_t flags
Definition: switch_core_pvt.h:238
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_directories::storage_dir
char * storage_dir
Definition: switch_types.h:561
set_realtime_priority
int32_t set_realtime_priority(void)
Definition: switch_core.c:981
SCSC_LAST_SPS
Definition: switch_types.h:2266
switch_log_shutdown
switch_status_t switch_log_shutdown(void)
Shut down the logging engine.
Definition: switch_log.c:799
switch_runtime::global_mutex
switch_mutex_t * global_mutex
Definition: switch_core_pvt.h:243
SCSC_RECLAIM
Definition: switch_types.h:2267
SCF_EARLY_HANGUP
Definition: switch_types.h:371
switch_rtp_shutdown
void switch_rtp_shutdown(void)
Definition: switch_rtp.c:2552
switch_mutex_t
struct fspr_thread_mutex_t switch_mutex_t
Definition: switch_apr.h:314
switch_directories::recordings_dir
char * recordings_dir
Definition: switch_types.h:563
SCSC_CRASH
Definition: switch_types.h:2283
switch_core_sqldb_pause
void switch_core_sqldb_pause(void)
Definition: switch_core_sqldb.c:3854
SWITCH_EVENT_SHUTDOWN
Definition: switch_types.h:2100
switch_cache_db_flush_handles
void switch_cache_db_flush_handles(void)
Definition: switch_core_sqldb.c:343
switch_core_media_set_resolveice
void switch_core_media_set_resolveice(switch_bool_t resolve_ice)
Definition: switch_core_media.c:294
switch_thread_cond_signal
switch_status_t switch_thread_cond_signal(switch_thread_cond_t *cond)
Definition: switch_apr.c:394
SCF_LOG_DISABLE
Definition: switch_types.h:393
switch_runtime::mime_types
switch_hash_t * mime_types
Definition: switch_core_pvt.h:229
SCSC_READY_CHECK
Definition: switch_types.h:2290
CF_SERVICE_VIDEO
Definition: switch_types.h:1538
switch_thread_start_t
void *(SWITCH_THREAD_FUNC * switch_thread_start_t)(switch_thread_t *, void *)
Definition: switch_apr.h:950
SWITCH_DEFAULT_DIR_PERMS
#define SWITCH_DEFAULT_DIR_PERMS
Definition: switch_types.h:120
ip
char * ip
Definition: switch_msrp.c:60
switch_runtime::max_dtmf_duration
uint32_t max_dtmf_duration
Definition: switch_core_pvt.h:255
switch_core_sqldb_init
switch_status_t switch_core_sqldb_init(const char **err)
Definition: switch_core.c:2428
switch_core_set_var_conditional
switch_bool_t switch_core_set_var_conditional(const char *varname, const char *value, const char *val2)
Definition: switch_core.c:464
switch_core_default_dtmf_duration
uint32_t switch_core_default_dtmf_duration(uint32_t duration)
Definition: switch_core.c:1721
switch_uuid_format
void switch_uuid_format(char *buffer, const switch_uuid_t *uuid)
Definition: switch_apr.c:1140
switch_core_get_variable_pdup
char * switch_core_get_variable_pdup(const char *varname, switch_memory_pool_t *pool)
Definition: switch_core.c:419
switch_core_session_limit
uint32_t switch_core_session_limit(_In_ uint32_t new_limit)
Set/Get Session Limit.
switch_network_list_add_cidr_port_token
switch_status_t switch_network_list_add_cidr_port_token(switch_network_list_t *list, const char *cidr_str, switch_bool_t ok, const char *token, switch_network_port_range_p port)
Definition: switch_utils.c:675
switch_core_sessions_peak_fivemin
int32_t switch_core_sessions_peak_fivemin(void)
Definition: switch_core.c:2637
switch_stream_handle::write_function
switch_stream_handle_write_function_t write_function
Definition: switch_module_interfaces.h:96
switch_ip_list_t
Definition: switch_core.c:1367
switch_uuid_t
Definition: switch_apr.h:539
SWITCH_MIN_DTMF_DURATION
#define SWITCH_MIN_DTMF_DURATION
Definition: switch_types.h:118
switch_time_set_monotonic
void switch_time_set_monotonic(switch_bool_t enable)
Definition: switch_time.c:331
switch_runtime::sps_last
int32_t sps_last
Definition: switch_core_pvt.h:247
SWITCH_EVENT_GENERAL
Definition: switch_types.h:2136
system_thread
static void *SWITCH_THREAD_FUNC system_thread(switch_thread_t *thread, void *obj)
Definition: switch_core.c:3147
SWITCH_SIZE_T_FMT
#define SWITCH_SIZE_T_FMT
Definition: switch_platform.h:258
switch_status_t
switch_status_t
Common return values.
Definition: switch_types.h:1233
SWITCH_LOG_CRIT
Definition: switch_types.h:1294
SWITCH_LOG_DEBUG
Definition: switch_types.h:1289
switch_runtime::sps
int32_t sps
Definition: switch_core_pvt.h:246
path
const char *const const char *const path
Definition: switch_cJSON_Utils.h:39
switch_string_replace
char * switch_string_replace(const char *string, const char *search, const char *replace)
Definition: switch_utils.c:3041
switch_stream_handle::data
void * data
Definition: switch_module_interfaces.h:98
switch_event_header::next
struct switch_event_header * next
Definition: switch_event.h:76
switch_apr_pvt.h
switch_xml_open_cfg
switch_xml_t switch_xml_open_cfg(_In_z_ const char *file_path, _Out_ switch_xml_t *node, _In_opt_ switch_event_t *params)
open a config in the core registry
switch_runtime::mailer_app
char * mailer_app
Definition: switch_core_pvt.h:253
switch_directories::conf_dir
char * conf_dir
Definition: switch_types.h:553
switch_core_get_hostname
const char * switch_core_get_hostname(void)
Definition: switch_core.c:356
switch_dir_make_recursive
switch_status_t switch_dir_make_recursive(const char *path, switch_fileperms_t perm, switch_memory_pool_t *pool)
Definition: switch_apr.c:551
SPF_ROBUST_UDP
Definition: switch_types.h:342
switch_console_save_history
void switch_console_save_history(void)
Definition: switch_console.c:975
switch_core_unset_variables
static void switch_core_unset_variables(void)
Definition: switch_core.c:434
switch_odbc_skip_autocommit_flip
void switch_odbc_skip_autocommit_flip(void)
Definition: switch_odbc.c:67
switch_core_sqldb_stop
void switch_core_sqldb_stop(void)
Definition: switch_core_sqldb.c:3918
SCSC_SQL
Definition: switch_types.h:2294
switch_core_hash_init_case
switch_status_t switch_core_hash_init_case(_Out_ switch_hash_t **hash, switch_bool_t case_sensitive)
Initialize a hash table.
switch_core_hash_insert
#define switch_core_hash_insert(_h, _k, _d)
Definition: switch_core.h:1479
switch_runtime::hard_log_level
switch_log_level_t hard_log_level
Definition: switch_core_pvt.h:252
FALSE
#define FALSE
Definition: switch_platform.h:338
switch_core_time_duration::hr
uint32_t hr
Definition: switch_core.h:54
switch_time_calibrate_clock
void switch_time_calibrate_clock(void)
Definition: switch_time.c:208
switch_core_sps_peak
int32_t switch_core_sps_peak(void)
Definition: switch_core.c:2622
switch.h
Main Library Header.
switch_runtime::default_dtmf_duration
uint32_t default_dtmf_duration
Definition: switch_core_pvt.h:257
CF_SERVICE
Definition: switch_types.h:1473
SWITCH_SEQ_DEFAULT_COLOR
#define SWITCH_SEQ_DEFAULT_COLOR
Definition: switch_types.h:70
switch_runtime::tipping_point
uint32_t tipping_point
Definition: switch_core_pvt.h:265
SWITCH_EVENT_CHANNEL_DATA
Definition: switch_types.h:2135
switch_event_create
#define switch_event_create(event, id)
Create a new event assuming it will not be custom event and therefore hiding the unused parameters...
Definition: switch_event.h:384
SCF_MINIMAL
Definition: switch_types.h:378
switch_core_ready_outbound
switch_bool_t switch_core_ready_outbound(void)
Determines if the core is ready to place outbound calls.
Definition: switch_core.c:3008
switch_core_banner
const char * switch_core_banner(void)
Definition: switch_core.c:2406
switch_runtime::sps_peak_fivemin
int32_t sps_peak_fivemin
Definition: switch_core_pvt.h:249
switch_core_recovery_flush
void switch_core_recovery_flush(const char *technology, const char *profile_name)
Definition: switch_core_sqldb.c:3133
SWITCH_DECLARE
#define SWITCH_DECLARE(type)
Definition: switch_platform.h:195
switch_thread_cond_t
struct fspr_thread_cond_t switch_thread_cond_t
Definition: switch_apr.h:463
SWITCH_GLOBAL_filenames
switch_filenames SWITCH_GLOBAL_filenames
Definition: switch_core.c:83
switch_uuid_get
void switch_uuid_get(switch_uuid_t *uuid)
Definition: switch_apr.c:1152
switch_runtime::running
uint8_t running
Definition: switch_core_pvt.h:236
switch_runtime::max_db_handles
uint32_t max_db_handles
Definition: switch_core_pvt.h:276
switch_network_list_validate_ip_port_token
switch_bool_t switch_network_list_validate_ip_port_token(switch_network_list_t *list, uint32_t ip, int port, const char **token)
Definition: switch_utils.c:546
switch_event_get_header
#define switch_event_get_header(_e, _h)
Definition: switch_event.h:172
switch_mono_micro_time_now
switch_time_t switch_mono_micro_time_now(void)
Definition: switch_time.c:316
switch_channel_set_flag
#define switch_channel_set_flag(_c, _f)
Definition: switch_channel.h:408
switch_hashtable_iterator
Definition: switch_hashtable_private.h:29
switch_xml_child
switch_xml_t switch_xml_child(_In_ switch_xml_t xml, _In_z_ const char *name)
returns the first child tag (one level deeper) with the given name or NULL \ if not found ...
switch_core_init
switch_status_t switch_core_init(switch_core_flag_t flags, switch_bool_t console, const char **err)
Definition: switch_core.c:1798
SWITCH_STANDARD_SCHED_FUNC
SWITCH_STANDARD_SCHED_FUNC(heartbeat_callback)
Definition: switch_core.c:225
SWITCH_GLOBAL_dirs
switch_directories SWITCH_GLOBAL_dirs
Definition: switch_core.c:82
switch_set_string
#define switch_set_string(_dst, _src)
Definition: switch_utils.h:734
SWITCH_STATUS_TIMEOUT
Definition: switch_types.h:1236
switch_time_set_use_system_time
void switch_time_set_use_system_time(switch_bool_t enable)
Definition: switch_time.c:342
SWITCH_LOG_ERROR
Definition: switch_types.h:1293
SCF_NO_NEW_INBOUND_SESSIONS
Definition: switch_types.h:364
switch_filenames
Definition: switch_types.h:576
switch_stream_system_fork
int switch_stream_system_fork(const char *cmd, switch_stream_handle_t *stream)
Definition: switch_core.c:3363
switch_stun.h
SCSC_CHECK_RUNNING
Definition: switch_types.h:2263
switch_runtime::core_db_pre_trans_execute
char * core_db_pre_trans_execute
Definition: switch_core_pvt.h:281
switch_runtime::port_alloc_flags
uint32_t port_alloc_flags
Definition: switch_core_pvt.h:286
switch_stream_spawn
int switch_stream_spawn(const char *cmd, switch_bool_t shell, switch_bool_t wait, switch_stream_handle_t *stream)
Definition: switch_core.c:3372
switch_time_set_cond_yield
void switch_time_set_cond_yield(switch_bool_t enable)
Definition: switch_time.c:373
buffer
char * buffer
Definition: switch_cJSON.h:153
switch_core_mime_ext2type
const char * switch_core_mime_ext2type(const char *ext)
Definition: switch_core.c:1211
switch_epoch_time_now
time_t switch_epoch_time_now(time_t *t)
Get the current epoch time.
Definition: switch_time.c:322
switch_network_port_range::min_port
int min_port
Definition: switch_utils.h:54
SWITCH_SEQ_BBLUE
#define SWITCH_SEQ_BBLUE
Definition: switch_types.h:104
switch_core_time_duration::sec
uint32_t sec
Definition: switch_core.h:52
SCSC_CALIBRATE_CLOCK
Definition: switch_types.h:2281
SCSC_SPS_PEAK
Definition: switch_types.h:2297
SCSC_SYNC_CLOCK_WHEN_IDLE
Definition: switch_types.h:2292
switch_runtime::mailer_app_args
char * mailer_app_args
Definition: switch_core_pvt.h:254
switch_check_network_list_ip_token
switch_bool_t switch_check_network_list_ip_token(const char *ip_str, const char *list_name, const char **token)
Definition: switch_core.c:1447
SWITCH_STATUS_FALSE
Definition: switch_types.h:1235
switch_runtime::cpu_count
int cpu_count
Definition: switch_core_pvt.h:279
switch_loadable_module_init
switch_status_t switch_loadable_module_init(switch_bool_t autoload)
Initilize the module backend and load all the modules.
Definition: switch_loadable_module.c:2080
switch_core_thread_session
A generic object to pass as a thread&#39;s session object to allow mutiple arguements and a pool...
Definition: switch_core.h:216
SCF_DEBUG_SQL
Definition: switch_types.h:384
switch_runtime::uuid_mutex
switch_mutex_t * uuid_mutex
Definition: switch_core_pvt.h:240
switch_core_get_variable
char * switch_core_get_variable(const char *varname)
Definition: switch_core.c:395
switch_core_debug_level
uint32_t switch_core_debug_level(void)
Definition: switch_core.c:2607
SWITCH_STATUS_SUCCESS
Definition: switch_types.h:1234
switch_thread_rwlock_create
switch_status_t switch_thread_rwlock_create(switch_thread_rwlock_t **rwlock, switch_memory_pool_t *pool)
Definition: switch_apr.c:235
switch_runtime::switchname
char * switchname
Definition: switch_core_pvt.h:274
switch_runtime::memory_pool
switch_memory_pool_t * memory_pool
Definition: switch_core_pvt.h:232
switch_test_flag
#define switch_test_flag(obj, flag)
Test for the existance of a flag on an arbitary object.
Definition: switch_utils.h:693
CF_SERVICE_AUDIO
Definition: switch_types.h:1537
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_log_init
switch_status_t switch_log_init(_In_ switch_memory_pool_t *pool, _In_ switch_bool_t colorize)
Initilize the logging engine.
switch_core_management_exec
switch_status_t switch_core_management_exec(char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
Execute a management operation.
Definition: switch_core.c:3118
switch_threadattr_create
switch_status_t switch_threadattr_create(switch_threadattr_t **new_attr, switch_memory_pool_t *pool)
Definition: switch_apr.c:665
switch_thread_create
switch_status_t switch_thread_create(switch_thread_t **new_thread, switch_threadattr_t *attr, switch_thread_start_t func, void *data, switch_memory_pool_t *cont)
Definition: switch_apr.c:698
switch_console_execute
switch_status_t switch_console_execute(char *xcmd, int rec, switch_stream_handle_t *istream)
Definition: switch_console.c:345
switch_management_interface::management_function
switch_status_t(* management_function)(char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
Definition: switch_module_interfaces.h:553
SCSC_PAUSE_OUTBOUND
Definition: switch_types.h:2259
switch_find_local_ip
switch_status_t switch_find_local_ip(_Out_opt_bytecapcount_(len) char *buf, _In_ int len, _In_opt_ int *mask, _In_ int family)
find local ip of the box
switch_runtime::debug_level
uint32_t debug_level
Definition: switch_core_pvt.h:263
count
int count
Definition: switch_cJSON.h:204
switch_core_get_console
FILE * switch_core_get_console(void)
Get the output console.
Definition: switch_core.c:253
switch_memory_pool_t
struct fspr_pool_t switch_memory_pool_t
Definition: switch_types.h:2318
switch_load_network_lists
void switch_load_network_lists(switch_bool_t reload)
Definition: switch_core.c:1452
name
const char *const name
Definition: switch_cJSON.h:250
SCSC_SHUTDOWN_NOW
Definition: switch_types.h:2279
SWITCH_STACK_BOTTOM
Definition: switch_types.h:1204
switch_core_get_variable_dup
char * switch_core_get_variable_dup(const char *varname)
Definition: switch_core.c:404
switch_event_destroy
void switch_event_destroy(switch_event_t **event)
Destroy an event.
Definition: switch_event.c:1289
switch_network_list
Definition: switch_utils.c:79
switch_core_set_process_privileges
int32_t switch_core_set_process_privileges(void)
Switch on the privilege awareness for the process and request required privileges.
Definition: switch_core.c:910
SCF_NO_NEW_SESSIONS
Definition: switch_types.h:365
SCSC_SEND_SIGHUP
Definition: switch_types.h:2276
switch_core_service_session_av
void switch_core_service_session_av(switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)
Definition: switch_core.c:573
switch_runtime::cpu_idle_smoothing_depth
uint32_t cpu_idle_smoothing_depth
Definition: switch_core_pvt.h:266
switch_directories::db_dir
char * db_dir
Definition: switch_types.h:556
switch_core_memory_reclaim
void switch_core_memory_reclaim(void)
Definition: switch_core_memory.c:554
switch_version_revision_human
const char * switch_version_revision_human(void)
Definition: switch_version.c:52
switch_core_time_duration::yr
uint32_t yr
Definition: switch_core.h:56
switch_core_session_ctl
int32_t switch_core_session_ctl(switch_session_ctl_t cmd, void *val)
send a control message to the core
Definition: switch_core.c:2651
switch_core_media_init
void switch_core_media_init(void)
Definition: switch_core_media.c:14226
SCF_RESTART
Definition: switch_types.h:368
switch_runtime::core_db_inner_pre_trans_execute
char * core_db_inner_pre_trans_execute
Definition: switch_core_pvt.h:283
switch_runtime::multiple_registrations
int multiple_registrations
Definition: switch_core_pvt.h:275
switch_channel_clear_flag
void switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flag)
Clear given flag(s) from a channel.
Definition: switch_channel.c:2145
switch_curl_init
void switch_curl_init(void)
Definition: switch_curl.c:51
SWITCH_PRI_LOW
Definition: switch_types.h:2602
switch_assert
#define switch_assert(expr)
Definition: switch_platform.h:347
switch_thread_t
struct fspr_thread_t switch_thread_t
Definition: switch_apr.h:941
switch_core_recovery_recover
int switch_core_recovery_recover(const char *technology, const char *profile_name)
Definition: switch_core_sqldb.c:3270
switch_core_remove_state_handler
void switch_core_remove_state_handler(const switch_state_handler_table_t *state_handler)
Definition: switch_core.c:292
SWITCH_FALSE
Definition: switch_types.h:438
SWITCH_STATUS_RESTART
Definition: switch_types.h:1237
switch_core_state_machine_init
void switch_core_state_machine_init(switch_memory_pool_t *pool)
Definition: switch_core_state_machine.c:420
SCSC_SESSIONS_PEAK
Definition: switch_types.h:2299
switch_directories::run_dir
char * run_dir
Definition: switch_types.h:555
switch_core_session_kill_channel
#define switch_core_session_kill_channel(session, sig)
Send a signal to a channel.
Definition: switch_core.h:1393
switch_core_ready_inbound
switch_bool_t switch_core_ready_inbound(void)
Determines if the core is ready to take inbound calls.
Definition: switch_core.c:3003
switch_runtime::odbc_dsn
char * odbc_dsn
Definition: switch_core_pvt.h:261
switch_core_hash_first
#define switch_core_hash_first(_h)
Definition: switch_core.h:1592
switch_core_ready
switch_bool_t switch_core_ready(void)
Determines if the core is ready to take calls.
Definition: switch_core.c:2998
switch_mprintf
SWITCH_BEGIN_EXTERN_C char * switch_mprintf(const char *zFormat,...)
Definition: switch_mprintf.c:897
switch_directories::lib_dir
char * lib_dir
Definition: switch_types.h:565
switch_console_loop
void switch_console_loop(void)
A simple comand loop that reads input from the terminal.
Definition: switch_console.c:1555
switch_core_sps_last
int32_t switch_core_sps_last(void)
Definition: switch_core.c:2617
switch_runtime::uuid_str
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH+1]
Definition: switch_core_pvt.h:237
switch_core_time_duration::mms
uint32_t mms
Definition: switch_core.h:50
memset
memset(buf, 0, buflen)
switch_directories::script_dir
char * script_dir
Definition: switch_types.h:557
switch_core_measure_time
void switch_core_measure_time(switch_time_t total_ms, switch_core_time_duration_t *duration)
Breakdown a number of milliseconds into various time spec.
Definition: switch_core.c:2535
SCSC_SHUTDOWN_CHECK
Definition: switch_types.h:2286
switch_core_launch_thread
switch_thread_t * switch_core_launch_thread(switch_thread_start_t func, void *obj, switch_memory_pool_t *pool)
Definition: switch_core.c:601
SCSC_DEFAULT_DTMF_DURATION
Definition: switch_types.h:2272
switch_ssl_destroy_ssl_locks
void switch_ssl_destroy_ssl_locks(void)
Definition: switch_core_cert.c:85
switch_core_check_core_db_dsn
switch_status_t switch_core_check_core_db_dsn(void)
Returns error if no suitable database interface found to serve core db dsn.
Definition: switch_core_sqldb.c:422
SCSC_SHUTDOWN_ELEGANT
Definition: switch_types.h:2273
switch_core_screen_size
void switch_core_screen_size(int *x, int *y)
Definition: switch_core.c:261
switch_management_action_t
switch_management_action_t
Definition: switch_types.h:481
switch_event::headers
switch_event_header_t * headers
Definition: switch_event.h:90
switch_core_time_duration
Definition: switch_core.h:49
SCF_CPF_SOFT_PREFIX
Definition: switch_types.h:388
switch_default_rate
uint32_t switch_default_rate(const char *name, uint32_t number)
Definition: switch_core.c:2033
switch_xml_init
switch_status_t switch_xml_init(_In_ switch_memory_pool_t *pool, _Out_ const char **err)
initilize the core XML backend
SCSC_VERBOSE_EVENTS
Definition: switch_types.h:2285
switch_network_port_range::max_port
int max_port
Definition: switch_utils.h:55
switch_core_session_launch_thread
void switch_core_session_launch_thread(_In_ switch_core_session_t *session, _In_ void *(*func)(switch_thread_t *, void *), _In_opt_ void *obj)
Launch a thread designed to exist within the scope of a given session.
SWITCH_LOG_INVALID
Definition: switch_types.h:1298
system_thread_handle::pool
switch_memory_pool_t * pool
Definition: switch_core.c:3142
switch_channel
Definition: switch_channel.c:152
switch_core_set_console
switch_status_t switch_core_set_console(const char *console)
Set the output console to the desired file.
Definition: switch_core.c:243
switch_threadattr_priority_set
switch_status_t switch_threadattr_priority_set(switch_threadattr_t *attr, switch_thread_priority_t priority)
Definition: switch_apr.c:688
switch_core_get_event_channel_key_separator
const char * switch_core_get_event_channel_key_separator(void)
Definition: switch_core.c:3592
Generated by   doxygen 1.8.13