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