switch_core_pvt.h File Reference

#include "switch_profile.h"
#include <switch_private.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>

Include dependency graph for switch_core_pvt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	switch_core_session
struct	switch_media_bug
struct	switch_runtime
struct	switch_session_manager

Macros
#define	DO_EVENTS
#define	SWITCH_EVENT_QUEUE_LEN   256
#define	SWITCH_MESSAGE_QUEUE_LEN   256
#define	SWITCH_BUFFER_BLOCK_FRAMES   25
#define	SWITCH_BUFFER_START_FRAMES   50

Enumerations
enum	switch_session_flag_t {   SSF_NONE = 0, SSF_DESTROYED = (1 << 0), SSF_WARN_TRANSCODE = (1 << 1), SSF_HANGUP = (1 << 2),   SSF_THREAD_STARTED = (1 << 3), SSF_THREAD_RUNNING = (1 << 4), SSF_READ_TRANSCODE = (1 << 5), SSF_WRITE_TRANSCODE = (1 << 6),   SSF_READ_CODEC_RESET = (1 << 7), SSF_WRITE_CODEC_RESET = (1 << 8), SSF_DESTROYABLE = (1 << 9), SSF_MEDIA_BUG_TAP_ONLY = (1 << 10) }
enum	switch_dbtype_t { DBTYPE_DEFAULT = 0, DBTYPE_MSSQL = 1 }

Functions
switch_status_t	switch_core_sqldb_init (const char **err)
void	switch_core_sqldb_destroy (void)
switch_status_t	switch_core_sqldb_start (switch_memory_pool_t *pool, switch_bool_t manage)
void	switch_core_sqldb_stop (void)
void	switch_core_session_init (switch_memory_pool_t *pool)
void	switch_core_session_uninit (void)
void	switch_core_state_machine_init (switch_memory_pool_t *pool)
switch_memory_pool_t *	switch_core_memory_init (void)
void	switch_core_memory_stop (void)

Variables
struct switch_runtime	runtime
struct switch_session_manager	session_manager

Macro Definition Documentation

DO_EVENTS

#define DO_EVENTS

Definition at line 63 of file switch_core_pvt.h.

SWITCH_BUFFER_BLOCK_FRAMES

#define SWITCH_BUFFER_BLOCK_FRAMES   25

Definition at line 68 of file switch_core_pvt.h.

Referenced by switch_core_media_bug_add(), switch_core_session_read_frame(), and switch_core_session_write_frame().

SWITCH_BUFFER_START_FRAMES

#define SWITCH_BUFFER_START_FRAMES   50

Definition at line 69 of file switch_core_pvt.h.

Referenced by switch_core_media_bug_add(), switch_core_session_read_frame(), and switch_core_session_write_frame().

SWITCH_EVENT_QUEUE_LEN

#define SWITCH_EVENT_QUEUE_LEN   256

Definition at line 65 of file switch_core_pvt.h.

Referenced by switch_core_session_request_uuid().

SWITCH_MESSAGE_QUEUE_LEN

#define SWITCH_MESSAGE_QUEUE_LEN   256

Definition at line 66 of file switch_core_pvt.h.

Referenced by switch_core_session_request_uuid().

Enumeration Type Documentation

switch_dbtype_t

enum switch_dbtype_t

Enumerator
DBTYPE_DEFAULT
DBTYPE_MSSQL

Definition at line 219 of file switch_core_pvt.h.

             {
        DBTYPE_DEFAULT = 0,
        DBTYPE_MSSQL = 1,
} switch_dbtype_t;

switch_session_flag_t

enum switch_session_flag_t

Enumerator
SSF_NONE
SSF_DESTROYED
SSF_WARN_TRANSCODE
SSF_HANGUP
SSF_THREAD_STARTED
SSF_THREAD_RUNNING
SSF_READ_TRANSCODE
SSF_WRITE_TRANSCODE
SSF_READ_CODEC_RESET
SSF_WRITE_CODEC_RESET
SSF_DESTROYABLE
SSF_MEDIA_BUG_TAP_ONLY

Definition at line 71 of file switch_core_pvt.h.

             {
        SSF_NONE = 0,
        SSF_DESTROYED = (1 << 0),
        SSF_WARN_TRANSCODE = (1 << 1),
        SSF_HANGUP = (1 << 2),
        SSF_THREAD_STARTED = (1 << 3),
        SSF_THREAD_RUNNING = (1 << 4),
        SSF_READ_TRANSCODE = (1 << 5),
        SSF_WRITE_TRANSCODE = (1 << 6),
        SSF_READ_CODEC_RESET = (1 << 7),
        SSF_WRITE_CODEC_RESET = (1 << 8),
        SSF_DESTROYABLE = (1 << 9),
        SSF_MEDIA_BUG_TAP_ONLY = (1 << 10)
} switch_session_flag_t;

Function Documentation

switch_core_memory_init()

switch_memory_pool_t* switch_core_memory_init

(

void

)

Definition at line 689 of file switch_core_memory.c.

References memory_manager, memset(), pool_thread(), switch_assert, switch_cond_next(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), and switch_threadattr_stacksize_set().

Referenced by switch_core_init().

{
#ifndef INSTANTLY_DESTROY_POOLS
        switch_threadattr_t *thd_attr;
#endif
#ifdef PER_POOL_LOCK
        fspr_allocator_t *my_allocator = NULL;
        fspr_thread_mutex_t *my_mutex;
#endif

        memset(&memory_manager, 0, sizeof(memory_manager));

#ifdef PER_POOL_LOCK
        if ((fspr_allocator_create(&my_allocator)) != APR_SUCCESS) {
                abort();
        }

        if ((fspr_pool_create_ex(&memory_manager.memory_pool, NULL, NULL, my_allocator)) != APR_SUCCESS) {
                fspr_allocator_destroy(my_allocator);
                my_allocator = NULL;
                abort();
        }

        if ((fspr_thread_mutex_create(&my_mutex, APR_THREAD_MUTEX_NESTED, memory_manager.memory_pool)) != APR_SUCCESS) {
                abort();
        }

        fspr_allocator_mutex_set(my_allocator, my_mutex);
        fspr_pool_mutex_set(memory_manager.memory_pool, my_mutex);
        fspr_allocator_owner_set(my_allocator, memory_manager.memory_pool);
        fspr_pool_tag(memory_manager.memory_pool, "core_pool");
#else
        fspr_pool_create(&memory_manager.memory_pool, NULL);
        switch_assert(memory_manager.memory_pool != NULL);
#endif

#ifdef USE_MEM_LOCK
        switch_mutex_init(&memory_manager.mem_lock, SWITCH_MUTEX_NESTED, memory_manager.memory_pool);
#endif

#ifdef INSTANTLY_DESTROY_POOLS
        {
                void *foo;
                foo = (void *) (intptr_t) pool_thread;
        }
#else

        switch_queue_create(&memory_manager.pool_queue, 50000, memory_manager.memory_pool);
        switch_queue_create(&memory_manager.pool_recycle_queue, 50000, memory_manager.memory_pool);

        switch_threadattr_create(&thd_attr, memory_manager.memory_pool);

        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
        switch_thread_create(&pool_thread_p, thd_attr, pool_thread, NULL, memory_manager.memory_pool);

        while (!memory_manager.pool_thread_running) {
                switch_cond_next();
        }
#endif

        return memory_manager.memory_pool;
}

switch_core_memory_stop()

void switch_core_memory_stop

(

void

)

Definition at line 671 of file switch_core_memory.c.

References memory_manager, SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, switch_log_printf(), switch_queue_trypop(), SWITCH_STATUS_SUCCESS, and switch_thread_join().

Referenced by switch_core_destroy().

{
#ifndef INSTANTLY_DESTROY_POOLS
        switch_status_t st;
        void *pop = NULL;

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping memory pool queue.\n");

        memory_manager.pool_thread_running = 0;
        switch_thread_join(&st, pool_thread_p);


        while (switch_queue_trypop(memory_manager.pool_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                fspr_pool_destroy(pop);
        }
#endif
}

switch_core_session_init()

void switch_core_session_init

(

switch_memory_pool_t *

pool

)

Definition at line 2625 of file switch_core_session.c.

References switch_session_manager::cond, switch_session_manager::memory_pool, memset(), switch_session_manager::mutex, pool, switch_session_manager::session_id, switch_session_manager::session_limit, session_manager, switch_session_manager::session_table, switch_core_hash_init, SWITCH_MUTEX_DEFAULT, switch_mutex_init(), switch_queue_create(), switch_thread_cond_create(), and switch_session_manager::thread_queue.

Referenced by switch_core_init().

{
        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);
        switch_mutex_init(&session_manager.mutex, SWITCH_MUTEX_DEFAULT, session_manager.memory_pool);
        switch_thread_cond_create(&session_manager.cond, session_manager.memory_pool);
        switch_queue_create(&session_manager.thread_queue, 100000, session_manager.memory_pool);
}

switch_core_session_uninit()

void switch_core_session_uninit

(

void

)

Definition at line 2637 of file switch_core_session.c.

References switch_session_manager::cond, switch_session_manager::mutex, switch_session_manager::running, session_manager, switch_session_manager::session_table, switch_core_hash_destroy(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_term(), switch_thread_cond_timedwait(), and switch_session_manager::thread_queue.

Referenced by switch_core_destroy().

{
        switch_queue_term(session_manager.thread_queue);
        switch_mutex_lock(session_manager.mutex);
        if (session_manager.running)
                switch_thread_cond_timedwait(session_manager.cond, session_manager.mutex, 10000000);
        switch_mutex_unlock(session_manager.mutex);
        switch_core_hash_destroy(&session_manager.session_table);
}

switch_core_sqldb_destroy()

void switch_core_sqldb_destroy

(

void

)

Definition at line 3013 of file switch_core.c.

References SCF_USE_SQL, switch_core_sqldb_stop(), and switch_test_flag.

Referenced by switch_loadable_module_shutdown().

{
        if (switch_test_flag((&runtime), SCF_USE_SQL)) {
                switch_core_sqldb_stop();
        }
}

switch_core_sqldb_init()

switch_status_t switch_core_sqldb_init

(

const char **

err

)

Definition at line 2428 of file switch_core.c.

References switch_runtime::memory_pool, SCF_USE_SQL, switch_core_check_core_db_dsn(), switch_core_sqldb_start(), SWITCH_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_loadable_module_init().

{
        if (switch_core_check_core_db_dsn() != SWITCH_STATUS_SUCCESS) {
                *err = "NO SUITABLE DATABASE INTERFACE IS AVAILABLE TO SERVE 'core-db-dsn'!\n";
                return SWITCH_STATUS_GENERR;
        }

        if (switch_core_sqldb_start(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_SQL) ? SWITCH_TRUE : SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) {
                *err = "Error activating database";
                return SWITCH_STATUS_GENERR;
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_core_sqldb_start()

switch_status_t switch_core_sqldb_start	(	switch_memory_pool_t *	pool,
		switch_bool_t	manage
	)

Definition at line 3565 of file switch_core_sqldb.c.

References basic_calls_sql, CDF_NONEXPIRING, switch_database_interface::commit, core_event_handler(), create_alias_sql, create_calls_sql, create_channels_sql, create_complete_sql, create_interfaces_sql, create_nat_sql, create_registrations_sql, create_row_size_limited_channels_sql, create_tasks_sql, DBTYPE_DEFAULT, detailed_calls_sql, manage, switch_runtime::odbc_dbtype, switch_cache_db_handle::pool, recovery_sql, runtime, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, SCF_CLEAR_SQL, SCF_CORE_NON_SQLITE_DB_REQ, SCF_USE_SQL, db_job::sql, sql_manager, switch_database_interface::sql_set_auto_commit_attr, switch_cache_db_create_schema(), switch_cache_db_execute_sql(), switch_cache_db_execute_sql_real(), switch_cache_db_release_db_handle(), switch_cache_db_test_reactive(), switch_cache_db_test_reactive_ex(), SWITCH_CHANNEL_LOG, switch_clear_flag, switch_core_db_handle, switch_core_get_hostname(), switch_core_get_switchname(), switch_core_sql_db_thread(), switch_core_sqldb_start_thread(), SWITCH_EVENT_ADD_SCHEDULE, SWITCH_EVENT_ALL, switch_event_bind(), SWITCH_EVENT_CALL_SECURE, SWITCH_EVENT_CALL_UPDATE, SWITCH_EVENT_CHANNEL_ANSWER, SWITCH_EVENT_CHANNEL_BRIDGE, SWITCH_EVENT_CHANNEL_CALLSTATE, SWITCH_EVENT_CHANNEL_CREATE, SWITCH_EVENT_CHANNEL_DESTROY, SWITCH_EVENT_CHANNEL_EXECUTE, SWITCH_EVENT_CHANNEL_HOLD, SWITCH_EVENT_CHANNEL_ORIGINATE, SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA, SWITCH_EVENT_CHANNEL_STATE, SWITCH_EVENT_CHANNEL_UNBRIDGE, SWITCH_EVENT_CHANNEL_UNHOLD, SWITCH_EVENT_CHANNEL_UUID, SWITCH_EVENT_CODEC, SWITCH_EVENT_DEL_SCHEDULE, SWITCH_EVENT_EXE_SCHEDULE, SWITCH_EVENT_LOG, SWITCH_EVENT_MODULE_LOAD, SWITCH_EVENT_MODULE_UNLOAD, SWITCH_EVENT_NAT, SWITCH_EVENT_RE_SCHEDULE, SWITCH_EVENT_SHUTDOWN, SWITCH_EVENT_SUBCLASS_ANY, SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_odbc_SQLEndTran(), switch_odbc_SQLSetAutoCommitAttr(), SWITCH_ODBC_SUCCESS, SWITCH_PRI_REALTIME, switch_safe_free, switch_set_flag, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_string_replace(), switch_stristr(), switch_test_flag, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_priority_set(), switch_threadattr_stacksize_set(), and SWITCH_TRUE.

Referenced by switch_core_sqldb_init().

{
        switch_threadattr_t *thd_attr;

        sql_manager.memory_pool = pool;
        sql_manager.manage = manage;

        switch_mutex_init(&sql_manager.dbh_mutex, SWITCH_MUTEX_NESTED, sql_manager.memory_pool);
        switch_mutex_init(&sql_manager.ctl_mutex, SWITCH_MUTEX_NESTED, sql_manager.memory_pool);

        if (!sql_manager.manage) goto skip;

 top:

        /* Activate SQL database */
        if (switch_core_db_handle(&sql_manager.dbh) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB!\n");

                if (switch_test_flag((&runtime), SCF_CORE_NON_SQLITE_DB_REQ)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure! ODBC IS REQUIRED!\n");
                        return SWITCH_STATUS_FALSE;
                }

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "CORE DATABASE INITIALIZATION FAILURE! CHECK `core-db-dsn`!\n");

                switch_clear_flag((&runtime), SCF_USE_SQL);
                return SWITCH_STATUS_FALSE;
        }


        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Opening DB\n");

        switch (sql_manager.dbh->type) {
        case SCDB_TYPE_DATABASE_INTERFACE:
        case SCDB_TYPE_ODBC:
                if (switch_test_flag((&runtime), SCF_CLEAR_SQL)) {
                        char sql[512] = "";
                        char *tables[] = { "channels", "calls", "tasks", NULL };
                        int i;
                        const char *hostname = switch_core_get_switchname();

                        for (i = 0; tables[i]; i++) {
                                switch_snprintfv(sql, sizeof(sql), "delete from %q where hostname='%q'", tables[i], hostname);
                                switch_cache_db_execute_sql(sql_manager.dbh, sql, NULL);
                        }
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        switch_cache_db_execute_sql(sql_manager.dbh, "drop table channels", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "drop table calls", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "drop view detailed_calls", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "drop view basic_calls", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "drop table interfaces", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "drop table tasks", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "PRAGMA synchronous=OFF;", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "PRAGMA count_changes=OFF;", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "PRAGMA default_cache_size=8000", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "PRAGMA temp_store=MEMORY;", NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, "PRAGMA journal_mode=OFF;", NULL);
                }
                break;
        }

        switch_cache_db_test_reactive(sql_manager.dbh, "select hostname from aliases", "DROP TABLE aliases", create_alias_sql);
        switch_cache_db_test_reactive(sql_manager.dbh, "select hostname from complete", "DROP TABLE complete", create_complete_sql);
        switch_cache_db_test_reactive(sql_manager.dbh, "select hostname from nat", "DROP TABLE nat", create_nat_sql);
        switch_cache_db_test_reactive(sql_manager.dbh, "delete from registrations where reg_user=''",
                                                                  "DROP TABLE registrations", create_registrations_sql);

        switch_cache_db_test_reactive(sql_manager.dbh, "select metadata from registrations", NULL, "ALTER TABLE registrations ADD COLUMN metadata VARCHAR(256)");


        switch_cache_db_test_reactive(sql_manager.dbh, "select hostname from recovery", "DROP TABLE recovery", recovery_sql);
        switch_cache_db_create_schema(sql_manager.dbh, "create index recovery1 on recovery(technology)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index recovery2 on recovery(profile_name)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index recovery3 on recovery(uuid)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index recovery4 on recovery(runtime_uuid)", NULL);




        switch (sql_manager.dbh->type) {
        case SCDB_TYPE_DATABASE_INTERFACE:
        case SCDB_TYPE_ODBC:
                {
                        char *err;
                        int result = 0;

                        switch_cache_db_test_reactive_ex(sql_manager.dbh, "select call_uuid, read_bit_rate, sent_callee_name, initial_cid_name, initial_cid_num, initial_ip_addr, initial_dest, initial_dialplan, initial_context, accountcode from channels", "DROP TABLE channels", create_channels_sql, create_row_size_limited_channels_sql);
                        switch_cache_db_test_reactive(sql_manager.dbh, "select call_uuid from calls", "DROP TABLE calls", create_calls_sql);
                        switch_cache_db_test_reactive(sql_manager.dbh, "select * from basic_calls where sent_callee_name=''", "DROP VIEW basic_calls", basic_calls_sql);
                        switch_cache_db_test_reactive(sql_manager.dbh, "select * from detailed_calls where sent_callee_name=''", "DROP VIEW detailed_calls", detailed_calls_sql);
                        if (runtime.odbc_dbtype == DBTYPE_DEFAULT) {
                                switch_cache_db_test_reactive(sql_manager.dbh, "delete from registrations where reg_user=''",
                                                                                          "DROP TABLE registrations", create_registrations_sql);
                        } else {
                                char *tmp = switch_string_replace(create_registrations_sql, "url      TEXT", "url      VARCHAR(max)");
                                switch_cache_db_test_reactive(sql_manager.dbh, "delete from registrations where reg_user=''",
                                                                                          "DROP TABLE registrations", tmp);
                                free(tmp);
                        }
                        switch_cache_db_test_reactive(sql_manager.dbh, "select ikey from interfaces", "DROP TABLE interfaces", create_interfaces_sql);
                        switch_cache_db_test_reactive(sql_manager.dbh, "select task_id, task_desc, task_group, task_runtime, task_sql_manager, hostname from tasks",
                                                                                  "DROP TABLE tasks", create_tasks_sql);


                        switch(sql_manager.dbh->type) {
                        case SCDB_TYPE_CORE_DB:
                                {
                                        switch_cache_db_execute_sql_real(sql_manager.dbh, "BEGIN EXCLUSIVE", &err);
                                }
                                break;
                        case SCDB_TYPE_ODBC:
                                {
                                        switch_odbc_status_t result;

                                        if ((result = switch_odbc_SQLSetAutoCommitAttr(sql_manager.dbh->native_handle.odbc_dbh, 0)) != SWITCH_ODBC_SUCCESS) {
                                                char tmp[100];
                                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to Set AutoCommit Off", result);
                                                err = strdup(tmp);
                                        }
                                }
                                break;
                        case SCDB_TYPE_DATABASE_INTERFACE:
                                {
                                        switch_database_interface_t *database_interface = sql_manager.dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                                        switch_status_t result;

                                        if ((result = database_interface->sql_set_auto_commit_attr(sql_manager.dbh->native_handle.database_interface_dbh, 0)) != SWITCH_STATUS_SUCCESS) {
                                                char tmp[100];
                                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to Set AutoCommit Off", result);
                                                err = strdup(tmp);
                                        }
                                }
                                break;
                        }

                        switch_cache_db_execute_sql(sql_manager.dbh, "delete from channels where hostname=''", &err);
                        if (!err) {
                                switch_cache_db_execute_sql(sql_manager.dbh, "delete from channels where hostname=''", &err);

                                switch(sql_manager.dbh->type) {
                                case SCDB_TYPE_CORE_DB:
                                        {
                                                switch_cache_db_execute_sql_real(sql_manager.dbh, "COMMIT", &err);
                                        }
                                        break;
                                case SCDB_TYPE_ODBC:
                                        {
                                                if (switch_odbc_SQLEndTran(sql_manager.dbh->native_handle.odbc_dbh, 1) != SWITCH_ODBC_SUCCESS ||
                                                        switch_odbc_SQLSetAutoCommitAttr(sql_manager.dbh->native_handle.odbc_dbh, 1) != SWITCH_ODBC_SUCCESS) {
                                                        char tmp[100];
                                                        switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to commit transaction.", result);
                                                        err = strdup(tmp);
                                                }
                                        }
                                        break;
                                case SCDB_TYPE_DATABASE_INTERFACE:
                                        {
                                                switch_database_interface_t *database_interface = sql_manager.dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                                                switch_status_t result;

                                                if ((result = database_interface->commit(sql_manager.dbh->native_handle.database_interface_dbh)) != SWITCH_STATUS_SUCCESS) {
                                                        char tmp[100];
                                                        switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to commit transaction", result);
                                                        err = strdup(tmp);
                                                }
                                        }
                                        break;
                                }
                        }


                        if (err) {
                                //runtime.odbc_dsn = NULL;
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Database Error [%s]\n", err);
                                //switch_cache_db_release_db_handle(&sql_manager.dbh);
                                if (switch_stristr("read-only", err)) {
                                        switch_safe_free(err);
                                } else {
                                        switch_safe_free(err);
                                        goto top;
                                }
                        }
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        switch_cache_db_execute_sql(sql_manager.dbh, create_channels_sql, NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, create_calls_sql, NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, create_interfaces_sql, NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, create_tasks_sql, NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, detailed_calls_sql, NULL);
                        switch_cache_db_execute_sql(sql_manager.dbh, basic_calls_sql, NULL);

                        if (sql_manager.dbh->native_handle.core_db_dbh->in_memory == SWITCH_TRUE) {
                                switch_set_flag(sql_manager.dbh, CDF_NONEXPIRING);
                        }
                }
                break;
        }

        if (switch_test_flag((&runtime), SCF_CLEAR_SQL)) {
                char sql[512] = "";
                char *tables[] = { "complete", "aliases", "nat", NULL };
                int i;
                const char *hostname = switch_core_get_hostname();

                for (i = 0; tables[i]; i++) {
                        switch_snprintfv(sql, sizeof(sql), "delete from %q where sticky=0 and hostname='%q'", tables[i], hostname);
                        switch_cache_db_execute_sql(sql_manager.dbh, sql, NULL);
                }

                switch_snprintfv(sql, sizeof(sql), "delete from interfaces where hostname='%q'", hostname);
                switch_cache_db_execute_sql(sql_manager.dbh, sql, NULL);
        }

        switch_cache_db_create_schema(sql_manager.dbh, "create index alias1 on aliases (alias)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index tasks1 on tasks (hostname,task_id)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete1 on complete (a1,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete2 on complete (a2,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete3 on complete (a3,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete4 on complete (a4,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete5 on complete (a5,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete6 on complete (a6,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete7 on complete (a7,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete8 on complete (a8,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete9 on complete (a9,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete10 on complete (a10,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index complete11 on complete (a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index nat_map_port_proto on nat (port,proto,hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index chidx1 on channels (hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index uuindex on channels (uuid, hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index uuindex2 on channels (call_uuid)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index callsidx1 on calls (hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index eruuindex on calls (caller_uuid, hostname)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index eeuuindex on calls (callee_uuid)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index eeuuindex2 on calls (call_uuid)", NULL);
        switch_cache_db_create_schema(sql_manager.dbh, "create index regindex1 on registrations (reg_user,realm,hostname)", NULL);


 skip:

        if (sql_manager.manage) {
                /* Initiate switch_sql_queue_manager */
                switch_threadattr_create(&thd_attr, sql_manager.memory_pool);
                switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
                switch_core_sqldb_start_thread();
                switch_thread_create(&sql_manager.db_thread, thd_attr, switch_core_sql_db_thread, NULL, sql_manager.memory_pool);

                /* switch_sql_queue_manager initiated, now we can bind to core_event_handler */
#ifdef SWITCH_SQL_BIND_EVERY_EVENT
                switch_event_bind("core_db", SWITCH_EVENT_ALL, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
#else
                switch_event_bind("core_db", SWITCH_EVENT_ADD_SCHEDULE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_DEL_SCHEDULE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_EXE_SCHEDULE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_RE_SCHEDULE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_DESTROY, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_UUID, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_CREATE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_ANSWER, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_HOLD, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_UNHOLD, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_EXECUTE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_ORIGINATE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CALL_UPDATE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_CALLSTATE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_STATE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_BRIDGE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CHANNEL_UNBRIDGE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_SHUTDOWN, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_LOG, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_MODULE_LOAD, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_MODULE_UNLOAD, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CALL_SECURE, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_NAT, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
                switch_event_bind("core_db", SWITCH_EVENT_CODEC, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL);
#endif
        }

        switch_cache_db_release_db_handle(&sql_manager.dbh);

        return SWITCH_STATUS_SUCCESS;
}

switch_core_sqldb_stop()

void switch_core_sqldb_stop

(

void

)

Definition at line 3918 of file switch_core_sqldb.c.

References core_event_handler(), sql_close(), sql_manager, switch_cache_db_flush_handles(), switch_core_sqldb_stop_thread(), switch_event_unbind_callback(), and switch_thread_join().

Referenced by switch_core_sqldb_destroy().

{
        switch_status_t st;

        switch_event_unbind_callback(core_event_handler);

        if (sql_manager.db_thread && sql_manager.db_thread_running) {
                sql_manager.db_thread_running = -1;
                switch_thread_join(&st, sql_manager.db_thread);
        }

        switch_core_sqldb_stop_thread();

        switch_cache_db_flush_handles();
        sql_close(0);
}

switch_core_state_machine_init()

void switch_core_state_machine_init

(

switch_memory_pool_t *

pool

)

Definition at line 420 of file switch_core_state_machine.c.

Referenced by switch_core_init().

{
        return;
}

Variable Documentation

runtime

struct switch_runtime runtime

Definition at line 86 of file switch_core.c.

Referenced by _switch_cache_db_get_db_handle(), _switch_core_db_handle(), switch_cache_db_create_schema(), switch_cache_db_test_reactive_ex(), switch_cond_next(), switch_cond_yield(), switch_core_add_registration(), switch_core_check_core_db_dsn(), switch_core_db_test_reactive(), switch_core_del_registration(), switch_core_expire_registration(), switch_core_idle_cpu(), switch_core_min_idle_cpu(), switch_core_pool_stats(), switch_core_port_allocator_new(), switch_core_session_event_send(), switch_core_session_findall(), switch_core_session_findall_matching_var(), switch_core_session_hangup_state(), switch_core_session_hupall(), switch_core_session_hupall_endpoint(), switch_core_session_hupall_matching_vars_ans(), switch_core_session_id_dec(), switch_core_session_message_send(), switch_core_session_perform_destroy(), switch_core_session_perform_force_locate(), switch_core_session_perform_locate(), switch_core_session_read_frame(), switch_core_session_read_text_frame(), switch_core_session_read_video_frame(), switch_core_session_request_uuid(), switch_core_session_set_external_id(), switch_core_session_set_uuid(), switch_core_session_sync_clock(), switch_core_session_thread_launch(), switch_core_sessions_per_second(), switch_core_sql_db_thread(), switch_core_sql_exec(), switch_core_sqldb_start(), switch_core_sqldb_start_thread(), switch_event_fire_detailed(), switch_event_shutdown(), switch_log_meta_vprintf(), switch_micro_time_now(), SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_new_profile_timer(), switch_simple_email(), switch_sql_concat(), switch_time_calibrate_clock(), switch_time_sync(), switch_user_sql_thread(), switch_uuid_get(), timer_destroy(), timer_init(), and timer_next().

session_manager

struct switch_session_manager session_manager

Definition at line 42 of file switch_core_session.c.

Referenced by check_queue(), switch_core_session_count(), switch_core_session_debug_pool(), switch_core_session_event_send(), switch_core_session_findall(), switch_core_session_findall_matching_var(), switch_core_session_hupall(), switch_core_session_hupall_endpoint(), switch_core_session_hupall_matching_vars_ans(), switch_core_session_id(), switch_core_session_id_dec(), switch_core_session_init(), switch_core_session_limit(), switch_core_session_message_send(), switch_core_session_perform_destroy(), switch_core_session_perform_force_locate(), switch_core_session_perform_locate(), switch_core_session_request_uuid(), switch_core_session_set_external_id(), switch_core_session_set_uuid(), switch_core_session_sync_clock(), switch_core_session_thread_pool_launch(), switch_core_session_thread_pool_worker(), switch_core_session_uninit(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_thread_pool_launch_thread(), and thread_launch_failure().