BASE = $(switch_srcdir)
OSARCH=`uname -s`
-if CRASHPROT
-AM_CFLAGS += -DCRASH_PROT
-endif
-
.DEFAULT:
@cd src/mod && $(MAKE) $(AM_MAKEFLAGS) $@
<settings>
<!--Most channels to allow at once -->
<param name="max-sessions" value="1000"/>
+ <!--Try to catch any crashes that can be recoverable (in the context of a call)-->
+ <param name="crash-protection" value="false"/>
<!--RTP port range -->
<!--<param name="rtp-start-port" value="16384"/>-->
<!--<param name="rtp-end-port" value="32768"/>-->
LIBCURL_CHECK_CONFIG([yes], [7.13.0], [LIBCURL_DEPS=''], [LIBCURL_DEPS='${switch_srcdir}/libs/curl/lib/libcurl.la';LIBCURL='${switch_srcdir}/libs/curl/lib/libcurl.la';LIBCURL_CPPFLAGS='-I${switch_srcdir}/libs/curl/include'])
AC_SUBST(LIBCURL_DEPS)
-AC_ARG_ENABLE(crash-protection,
- [ --enable-crash-protection Compile with CRASH Protection],,[enable_crash_prot="no"])
-
AC_ARG_ENABLE(core-odbc-support,
[ --enable-core-odbc-support Compile with ODBC Support],,[enable_core_odbc_support="no"])
#AX_LIB_MYSQL([MINIMUM-VERSION])
AX_LIB_MYSQL
-AM_CONDITIONAL([CRASHPROT],[test "x$enable_crash_prot" != "xno"])
AM_CONDITIONAL([ADD_ODBC],[test "x$enable_core_odbc_support" != "xno"])
AM_CONDITIONAL([ADD_LIBEDIT],[test "x$enable_core_libedit_support" != "xno"])
AM_CONDITIONAL([HAVE_MYSQL],[test "$found_mysql" = "yes"])
/* #define DEBUG_ALLOC */
#define DO_EVENTS
-#ifdef CRASH_PROT
-#define __CP "ENABLED"
-#else
-#define __CP "DISABLED"
-#endif
-
#define SWITCH_EVENT_QUEUE_LEN 256
#define SWITCH_MESSAGE_QUEUE_LEN 256
#define SWITCH_SQL_QUEUE_LEN 2000
struct switch_media_bug *next;
};
+struct switch_runtime {
+ switch_time_t initiated;
+ switch_hash_t *global_vars;
+ switch_memory_pool_t *memory_pool;
+ const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS];
+ int state_handler_index;
+ FILE *console;
+ uint8_t running;
+ char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
+ uint32_t no_new_sessions;
+ uint32_t shutting_down;
+ uint32_t crash_prot;
+};
+
+extern struct switch_runtime runtime;
+
void switch_core_sqldb_start(switch_memory_pool_t *pool);
void switch_core_sqldb_stop(void);
void switch_core_session_init(switch_memory_pool_t *pool);
(expr && ( !strcasecmp(expr, "yes") ||\
!strcasecmp(expr, "on") ||\
!strcasecmp(expr, "true") ||\
+!strcasecmp(expr, "enabled") ||\
+!strcasecmp(expr, "active") ||\
atoi(expr))) ? SWITCH_TRUE : SWITCH_FALSE
/*!
\brief find local ip of the box
SWITCH_DECLARE_DATA switch_directories SWITCH_GLOBAL_dirs = { 0 };
/* The main runtime obj we keep this hidden for ourselves */
-static struct {
- switch_time_t initiated;
- switch_hash_t *global_vars;
- switch_memory_pool_t *memory_pool;
- const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS];
- int state_handler_index;
- FILE *console;
- uint8_t running;
- char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
- uint32_t no_new_sessions;
- uint32_t shutting_down;
-} runtime;
-
+struct switch_runtime runtime;
static void send_heartbeat(void)
{
switch_core_set_globals();
switch_core_session_init(runtime.memory_pool);
- switch_core_state_machine_init(runtime.memory_pool);
switch_core_hash_init(&runtime.global_vars, runtime.memory_pool);
const char *var = switch_xml_attr_soft(param, "name");
const char *val = switch_xml_attr_soft(param, "value");
- if (!strcasecmp(var, "max-sessions")) {
+ if (!strcasecmp(var, "crash-protection")) {
+ runtime.crash_prot = switch_true(val);
+ } else if (!strcasecmp(var, "max-sessions")) {
switch_core_session_limit(atoi(val));
}
else if (!strcasecmp(var, "rtp-start-port")) {
switch_xml_free(xml);
}
+ switch_core_state_machine_init(runtime.memory_pool);
+
*err = NULL;
if (console) {
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,
- "\nFreeSWITCH Version %s Started.\nCrash Protection [%s]\nMax Sessions[%u]\n\n", SWITCH_VERSION_FULL, __CP,
+ "\nFreeSWITCH Version %s Started.\nCrash Protection [%s]\nMax Sessions[%u]\n\n", SWITCH_VERSION_FULL,
+ runtime.crash_prot ? "Enabled" : "Disabled",
switch_core_session_limit(0));
return SWITCH_STATUS_SUCCESS;
static struct {
switch_memory_pool_t *memory_pool;
-} runtime;
+} memory_manager;
SWITCH_DECLARE(switch_memory_pool_t *) switch_core_session_get_pool(switch_core_session_t *session)
{
SWITCH_DECLARE(void *) switch_core_permanent_alloc(switch_size_t memory)
{
void *ptr = NULL;
- assert(runtime.memory_pool != NULL);
+ assert(memory_manager.memory_pool != NULL);
#ifdef DEBUG_ALLOC
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Perm Allocate %d\n", memory);
#endif
- if ((ptr = apr_palloc(runtime.memory_pool, memory)) != 0) {
+ if ((ptr = apr_palloc(memory_manager.memory_pool, memory)) != 0) {
memset(ptr, 0, memory);
}
return ptr;
{
char *duped = NULL;
switch_size_t len;
- assert(runtime.memory_pool != NULL);
+ assert(memory_manager.memory_pool != NULL);
if (!todup)
return NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Perm Allocate %d\n", len);
#endif
- if (todup && (duped = apr_palloc(runtime.memory_pool, len)) != 0) {
+ if (todup && (duped = apr_palloc(memory_manager.memory_pool, len)) != 0) {
strncpy(duped, todup, len);
}
return duped;
switch_memory_pool_t *switch_core_memory_init(void)
{
- memset(&runtime, 0, sizeof(runtime));
+ memset(&memory_manager, 0, sizeof(memory_manager));
- apr_pool_create(&runtime.memory_pool, NULL);
- return runtime.memory_pool;
+ apr_pool_create(&memory_manager.memory_pool, NULL);
+ return memory_manager.memory_pool;
}
uint32_t session_count;
uint32_t session_limit;
switch_size_t session_id;
-} runtime;
+} session_manager;
#ifdef SWITCH_DEBUG_RWLOCKS
switch_core_session_t *session = NULL;
if (uuid_str) {
- switch_mutex_lock(runtime.session_table_mutex);
- if ((session = switch_core_hash_find(runtime.session_table, uuid_str))) {
+ switch_mutex_lock(session_manager.session_table_mutex);
+ if ((session = switch_core_hash_find(session_manager.session_table, uuid_str))) {
/* Acquire a read lock on the session */
#ifdef SWITCH_DEBUG_RWLOCKS
if (switch_core_session_perform_read_lock(session, file, func, line) != SWITCH_STATUS_SUCCESS) {
session = NULL;
}
}
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_unlock(session_manager.session_table_mutex);
}
/* if its not NULL, now it's up to you to rwunlock this */
switch_channel_t *channel;
uint32_t loops = 0;
- switch_mutex_lock(runtime.session_table_mutex);
- for (hi = switch_hash_first(runtime.memory_pool, runtime.session_table); hi; hi = switch_hash_next(hi)) {
+ switch_mutex_lock(session_manager.session_table_mutex);
+ for (hi = switch_hash_first(session_manager.memory_pool, session_manager.session_table); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, NULL, NULL, &val);
if (val) {
session = (switch_core_session_t *) val;
switch_core_session_kill_channel(session, SWITCH_SIG_KILL);
}
}
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_unlock(session_manager.session_table_mutex);
- while (runtime.session_count > 0) {
+ while (session_manager.session_count > 0) {
switch_yield(100000);
if (++loops == 100) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Giving up with %d session%s remaining\n",
- runtime.session_count, runtime.session_count == 1 ? "" : "s");
+ session_manager.session_count, session_manager.session_count == 1 ? "" : "s");
break;
}
}
switch_core_session_t *session = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
- switch_mutex_lock(runtime.session_table_mutex);
- if ((session = switch_core_hash_find(runtime.session_table, uuid_str)) != 0) {
+ switch_mutex_lock(session_manager.session_table_mutex);
+ if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) {
/* Acquire a read lock on the session or forget it the channel is dead */
if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
if (switch_channel_get_state(session->channel) < CS_HANGUP) {
switch_core_session_rwunlock(session);
}
}
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_unlock(session_manager.session_table_mutex);
return status;
}
switch_core_session_t *session = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
- switch_mutex_lock(runtime.session_table_mutex);
- if ((session = switch_core_hash_find(runtime.session_table, uuid_str)) != 0) {
+ switch_mutex_lock(session_manager.session_table_mutex);
+ if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) {
/* Acquire a read lock on the session or forget it the channel is dead */
if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
if (switch_channel_get_state(session->channel) < CS_HANGUP) {
switch_core_session_rwunlock(session);
}
}
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_unlock(session_manager.session_table_mutex);
return status;
}
switch_scheduler_del_task_group((*session)->uuid_str);
- switch_mutex_lock(runtime.session_table_mutex);
- switch_core_hash_delete(runtime.session_table, (*session)->uuid_str);
- if (runtime.session_count) {
- runtime.session_count--;
+ switch_mutex_lock(session_manager.session_table_mutex);
+ switch_core_hash_delete(session_manager.session_table, (*session)->uuid_str);
+ if (session_manager.session_count) {
+ session_manager.session_count--;
}
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_unlock(session_manager.session_table_mutex);
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_DESTROY) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data((*session)->channel, event);
assert(endpoint_interface != NULL);
- switch_mutex_lock(runtime.session_table_mutex);
- count = runtime.session_count;
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_lock(session_manager.session_table_mutex);
+ count = session_manager.session_count;
+ switch_mutex_unlock(session_manager.session_table_mutex);
- if ((count + 1) > runtime.session_limit) {
+ if ((count + 1) > session_manager.session_limit) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Over Session Limit!\n");
return NULL;
}
switch_thread_rwlock_create(&session->rwlock, session->pool);
snprintf(session->name, sizeof(session->name), "%"SWITCH_SIZE_T_FMT, session->id);
- switch_mutex_lock(runtime.session_table_mutex);
- session->id = runtime.session_id++;
- switch_core_hash_insert(runtime.session_table, session->uuid_str, session);
- runtime.session_count++;
- switch_mutex_unlock(runtime.session_table_mutex);
+ switch_mutex_lock(session_manager.session_table_mutex);
+ session->id = session_manager.session_id++;
+ switch_core_hash_insert(session_manager.session_table, session->uuid_str, session);
+ session_manager.session_count++;
+ switch_mutex_unlock(session_manager.session_table_mutex);
return session;
}
SWITCH_DECLARE(uint32_t) switch_core_session_count(void)
{
- return runtime.session_count;
+ return session_manager.session_count;
}
SWITCH_DECLARE(switch_size_t) switch_core_session_id(void)
{
- return runtime.session_id;
+ return session_manager.session_id;
}
SWITCH_DECLARE(uint32_t) switch_core_session_limit(uint32_t new_limit)
{
if (new_limit) {
- runtime.session_limit = new_limit;
+ session_manager.session_limit = new_limit;
}
- return runtime.session_limit;
+ return session_manager.session_limit;
}
void switch_core_session_init(switch_memory_pool_t *pool)
{
- memset(&runtime, 0, sizeof(runtime));
- runtime.session_limit = 1000;
- runtime.session_id = 1;
- runtime.memory_pool = pool;
- switch_core_hash_init(&runtime.session_table, runtime.memory_pool);
- switch_mutex_init(&runtime.session_table_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
+ memset(&session_manager, 0, sizeof(session_manager));
+ session_manager.session_limit = 1000;
+ session_manager.session_id = 1;
+ session_manager.memory_pool = pool;
+ switch_core_hash_init(&session_manager.session_table, session_manager.memory_pool);
+ switch_mutex_init(&session_manager.session_table_mutex, SWITCH_MUTEX_NESTED, session_manager.memory_pool);
}
switch_queue_t *sql_queue;
switch_memory_pool_t *memory_pool;
int thread_running;
-} runtime;
+} sql_manager;
static switch_status_t switch_core_db_persistant_execute_trans(switch_core_db_t *db, char *sql, uint32_t retries)
{
char *sql;
switch_size_t newlen;
- if (!runtime.event_db) {
- runtime.event_db = switch_core_db_handle();
+ if (!sql_manager.event_db) {
+ sql_manager.event_db = switch_core_db_handle();
}
- runtime.thread_running = 1;
+ sql_manager.thread_running = 1;
for (;;) {
- if (switch_queue_trypop(runtime.sql_queue, &pop) == SWITCH_STATUS_SUCCESS) {
+ if (switch_queue_trypop(sql_manager.sql_queue, &pop) == SWITCH_STATUS_SUCCESS) {
sql = (char *) pop;
if (sql) {
if (trans && ((itterations == target) || nothing_in_queue)) {
- if (switch_core_db_persistant_execute_trans(runtime.event_db, sqlbuf, 1000) != SWITCH_STATUS_SUCCESS) {
+ if (switch_core_db_persistant_execute_trans(sql_manager.event_db, sqlbuf, 1000) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL thread unable to commit transaction, records lost!\n");
}
itterations = 0;
sql = switch_mprintf("insert into tasks values('%q','%q','%q','%q')",
switch_event_get_header(event, "task-id"),
switch_event_get_header(event, "task-desc"),
- switch_event_get_header(event, "task-group"), switch_event_get_header(event, "task-runtime")
+ switch_event_get_header(event, "task-group"), switch_event_get_header(event, "task-sql_manager")
);
break;
case SWITCH_EVENT_DEL_SCHEDULE:
sql = switch_mprintf("delete from tasks where task_id=%q", switch_event_get_header(event, "task-id"));
break;
case SWITCH_EVENT_RE_SCHEDULE:
- sql = switch_mprintf("update tasks set task_runtime='%q' where task_id=%q",
- switch_event_get_header(event, "task-runtime"), switch_event_get_header(event, "task-id"));
+ sql = switch_mprintf("update tasks set task_sql_manager='%q' where task_id=%q",
+ switch_event_get_header(event, "task-sql_manager"), switch_event_get_header(event, "task-id"));
break;
case SWITCH_EVENT_CHANNEL_DESTROY:
sql = switch_mprintf("delete from channels where uuid='%q'", switch_event_get_header(event, "unique-id"));
}
if (sql) {
- switch_queue_push(runtime.sql_queue, sql);
+ switch_queue_push(sql_manager.sql_queue, sql);
sql = NULL;
}
}
switch_thread_t *thread;
switch_threadattr_t *thd_attr;;
- runtime.memory_pool = pool;
+ sql_manager.memory_pool = pool;
/* Activate SQL database */
- if ((runtime.db = switch_core_db_handle()) == 0) {
+ if ((sql_manager.db = switch_core_db_handle()) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB!\n");
} else {
char create_channels_sql[] =
char create_tasks_sql[] =
"CREATE TABLE tasks (\n"
" task_id INTEGER(4),\n"
- " task_desc VARCHAR(255),\n" " task_group VARCHAR(255),\n" " task_runtime INTEGER(8)\n" ");\n";
+ " task_desc VARCHAR(255),\n" " task_group VARCHAR(255),\n" " task_sql_manager INTEGER(8)\n" ");\n";
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Opening DB\n");
- switch_core_db_exec(runtime.db, "drop table channels", NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, "drop table calls", NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, "drop table interfaces", NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, "drop table tasks", NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, create_channels_sql, NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, create_calls_sql, NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, create_interfaces_sql, NULL, NULL, NULL);
- switch_core_db_exec(runtime.db, create_tasks_sql, NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, "drop table channels", NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, "drop table calls", NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, "drop table interfaces", NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, "drop table tasks", NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, create_channels_sql, NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, create_calls_sql, NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, create_interfaces_sql, NULL, NULL, NULL);
+ switch_core_db_exec(sql_manager.db, create_tasks_sql, NULL, NULL, NULL);
if (switch_event_bind("core_db", SWITCH_EVENT_ALL, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind event handler!\n");
}
}
- switch_queue_create(&runtime.sql_queue, SWITCH_SQL_QUEUE_LEN, runtime.memory_pool);
+ switch_queue_create(&sql_manager.sql_queue, SWITCH_SQL_QUEUE_LEN, sql_manager.memory_pool);
- switch_threadattr_create(&thd_attr, runtime.memory_pool);
+ switch_threadattr_create(&thd_attr, sql_manager.memory_pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_thread_create(&thread, thd_attr, switch_core_sql_thread, NULL, runtime.memory_pool);
- while (!runtime.thread_running) {
+ switch_thread_create(&thread, thd_attr, switch_core_sql_thread, NULL, sql_manager.memory_pool);
+ while (!sql_manager.thread_running) {
switch_yield(10000);
}
}
void switch_core_sqldb_stop(void)
{
- switch_queue_push(runtime.sql_queue, NULL);
+ switch_queue_push(sql_manager.sql_queue, NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Waiting for unfinished SQL transactions\n");
- while (switch_queue_size(runtime.sql_queue) > 0) {
+ while (switch_queue_size(sql_manager.sql_queue) > 0) {
switch_yield(10000);
}
- switch_core_db_close(runtime.db);
- switch_core_db_close(runtime.event_db);
+ switch_core_db_close(sql_manager.db);
+ switch_core_db_close(sql_manager.event_db);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Standard HIBERNATE\n");
}
-
-#ifdef CRASH_PROT
-static switch_hash_t *stack_table;
+static switch_hash_t *stack_table = NULL;
#if defined (__GNUC__) && defined (LINUX)
#include <execinfo.h>
#include <stdio.h>
abort();
}
}
-#endif
+
void switch_core_state_machine_init(switch_memory_pool_t *pool)
{
- (void)0;
-#ifdef CRASH_PROT
- switch_core_hash_init(&stack_table, pool);
-#endif
+ if (runtime.crash_prot) {
+ switch_core_hash_init(&stack_table, pool);
+ }
}
SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session)
const switch_endpoint_interface_t *endpoint_interface;
const switch_state_handler_table_t *driver_state_handler = NULL;
const switch_state_handler_table_t *application_state_handler = NULL;
-
-#ifdef CRASH_PROT
- switch_thread_id_t thread_id = switch_thread_self();
+ switch_thread_id_t thread_id;
jmp_buf env;
int sig;
- signal(SIGSEGV, handle_fatality);
- signal(SIGFPE, handle_fatality);
+ if (runtime.crash_prot) {
+ thread_id = switch_thread_self();
+ signal(SIGSEGV, handle_fatality);
+ signal(SIGFPE, handle_fatality);
#ifndef WIN32
- signal(SIGBUS, handle_fatality);
+ signal(SIGBUS, handle_fatality);
#endif
- if ((sig = setjmp(env)) != 0) {
- switch_event_t *event;
+ if ((sig = setjmp(env)) != 0) {
+ switch_event_t *event;
- if (switch_event_create(&event, SWITCH_EVENT_SESSION_CRASH) == SWITCH_STATUS_SUCCESS) {
- switch_channel_event_set_data(session->channel, event);
- switch_event_fire(&event);
+ if (switch_event_create(&event, SWITCH_EVENT_SESSION_CRASH) == SWITCH_STATUS_SUCCESS) {
+ switch_channel_event_set_data(session->channel, event);
+ switch_event_fire(&event);
+ }
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread has crashed for channel %s\n", switch_channel_get_name(session->channel));
+ switch_channel_hangup(session->channel, SWITCH_CAUSE_CRASH);
+ } else {
+ apr_hash_set(stack_table, &thread_id, sizeof(thread_id), &env);
}
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread has crashed for channel %s\n", switch_channel_get_name(session->channel));
- switch_channel_hangup(session->channel, SWITCH_CAUSE_CRASH);
- } else {
- apr_hash_set(stack_table, &thread_id, sizeof(thread_id), &env);
}
-#endif
+
+
/*
Life of the channel. you have channel and pool in your session
everywhere you go you use the session to malloc with
done:
switch_mutex_unlock(session->mutex);
-#ifdef CRASH_PROT
- apr_hash_set(stack_table, &thread_id, sizeof(thread_id), NULL);
-#endif
+ if (runtime.crash_prot) {
+ apr_hash_set(stack_table, &thread_id, sizeof(thread_id), NULL);
+ }
session->thread_running = 0;
}
projects / thirdparty / freeswitch.git / commitdiff
