static dir_profile_t *load_profile(const char *profile_name)
{
dir_profile_t *profile = NULL;
switch_xml_t x_profiles, x_profile, cfg, xml = NULL;
switch_event_t *event = NULL;
if (!(xml = switch_xml_open_cfg(global_cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", global_cf);
return profile;
}
if (!(x_profiles = switch_xml_child(cfg, "profiles"))) {
goto end;
}
if ((x_profile = switch_xml_find_child(x_profiles, "profile", "name", profile_name))) {
switch_memory_pool_t *pool;
int count;
if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
goto end;
}
if (!(profile = switch_core_alloc(pool, sizeof(dir_profile_t)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n");
switch_core_destroy_memory_pool(&pool);
goto end;
}
profile->pool = pool;
profile_set_config(profile);
/* Add the params to the event structure */
count = (int)switch_event_import_xml(switch_xml_child(x_profile, "param"), "name", "value", &event);
if (switch_xml_config_parse_event(event, count, SWITCH_FALSE, profile->config) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to process configuration\n");
switch_core_destroy_memory_pool(&pool);
goto end;
}
switch_thread_rwlock_create(&profile->rwlock, pool);
profile->name = switch_core_strdup(pool, profile_name);
switch_mutex_init(&profile->mutex, SWITCH_MUTEX_NESTED, profile->pool);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Added Profile %s\n", profile->name);
switch_core_hash_insert(globals.profile_hash, profile->name, profile);
}
end:
switch_xml_free(xml);
return profile;
}
SWITCH_DECLARE(void) EventConsumer::cleanup()
{
uint32_t i;
void *pop;
if (!ready) {
return;
}
ready = 0;
for (i = 0; i < node_index; i++) {
switch_event_unbind(&enodes[i]);
}
node_index = 0;
if (events) {
switch_queue_interrupt_all(events);
}
while(switch_queue_trypop(events, &pop) == SWITCH_STATUS_SUCCESS) {
switch_event_t *event = (switch_event_t *) pop;
switch_event_destroy(&event);
}
switch_core_destroy_memory_pool(&pool);
}
static void *SWITCH_THREAD_FUNC py_thread_run(switch_thread_t *thread, void *obj)
{
switch_memory_pool_t *pool;
struct switch_py_thread *pt = (struct switch_py_thread *) obj;
/* Put thread in pool so we keep track of our threads */
switch_mutex_lock(THREAD_POOL_LOCK);
pt->next = thread_pool_head;
pt->prev = NULL;
if (pt->next)
pt->next->prev = pt;
thread_pool_head = pt;
switch_mutex_unlock(THREAD_POOL_LOCK);
/* Run the python script */
eval_some_python("runtime", pt->args, NULL, NULL, NULL, NULL, pt);
/* Thread is dead, remove from pool */
switch_mutex_lock(THREAD_POOL_LOCK);
if (pt->next)
pt->next->prev = pt->prev;
if (pt->prev)
pt->prev->next = pt->next;
if (thread_pool_head == pt)
thread_pool_head = pt->next;
switch_mutex_unlock(THREAD_POOL_LOCK);
pool = pt->pool;
switch_core_destroy_memory_pool(&pool);
return NULL;
}
static void *torture_thread(switch_thread_t *thread, void *obj)
{
int y = 0;
int z = 0;
switch_core_thread_session_t *ts = obj;
switch_event_t *event;
z = THREADS++;
while (THREADS > 0) {
int x;
for (x = 0; x < 1; x++) {
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, MY_EVENT_COOL) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, "event_info", "hello world %d %d", z, y++);
switch_event_fire(&event);
}
}
switch_yield(100000);
}
if (ts->pool) {
switch_memory_pool_t *pool = ts->pool;
switch_core_destroy_memory_pool(&pool);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Thread Ended\n");
}
SWITCH_DECLARE_CONSTRUCTOR IVRMenu::~IVRMenu()
{
if (menu) {
switch_ivr_menu_stack_free(menu);
}
switch_core_destroy_memory_pool(&pool);
}
void limit_remote_destroy(limit_remote_t **r)
{
if (r && *r) {
switch_hash_index_t *hi;
(*r)->state = REMOTE_OFF;
if ((*r)->thread) {
switch_status_t retval;
switch_thread_join(&retval, (*r)->thread);
}
switch_thread_rwlock_wrlock((*r)->rwlock);
/* Free hashtable data */
for (hi = switch_hash_first(NULL, (*r)->index); hi; hi = switch_hash_next(hi)) {
void *val;
const void *key;
switch_ssize_t keylen;
switch_hash_this(hi, &key, &keylen, &val);
free(val);
}
switch_thread_rwlock_unlock((*r)->rwlock);
switch_thread_rwlock_destroy((*r)->rwlock);
switch_core_destroy_memory_pool(&((*r)->pool));
*r = NULL;
}
}
void unreference()
{
switch_mutex_destroy(_mutex);
if (_can_delete_pool)
switch_core_destroy_memory_pool(&_pool);
}
SWITCH_DECLARE(switch_status_t) switch_file_exists(const char *filename, switch_memory_pool_t *pool)
{
int32_t wanted = APR_FINFO_TYPE;
switch_memory_pool_t *our_pool = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
apr_finfo_t info = { 0 };
if (zstr(filename)) {
return status;
}
if (!pool) {
switch_core_new_memory_pool(&our_pool);
}
apr_stat(&info, filename, wanted, pool ? pool : our_pool);
if (info.filetype != APR_NOFILE) {
status = SWITCH_STATUS_SUCCESS;
}
if (our_pool) {
switch_core_destroy_memory_pool(&our_pool);
}
return status;
}
//SavedCondition(const SavedCondition &);
~SavedCondition()
{
switch_thread_cond_destroy(_condition);
switch_mutex_destroy(_mutex);
if(_can_delete_pool)
switch_core_destroy_memory_pool(&_pool);
}
/* rotate the log file */
static switch_status_t mod_logfile_rotate(logfile_profile_t *profile)
{
unsigned int i = 0;
char *filename = NULL;
switch_status_t stat = 0;
int64_t offset = 0;
switch_memory_pool_t *pool = NULL;
switch_time_exp_t tm;
char date[80] = "";
switch_size_t retsize;
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_mutex_lock(globals.mutex);
switch_time_exp_lt(&tm, switch_micro_time_now());
switch_strftime_nocheck(date, &retsize, sizeof(date), "%Y-%m-%d-%H-%M-%S", &tm);
profile->log_size = 0;
stat = switch_file_seek(profile->log_afd, SWITCH_SEEK_SET, &offset);
if (stat != SWITCH_STATUS_SUCCESS) {
status = SWITCH_STATUS_FALSE;
goto end;
}
switch_core_new_memory_pool(&pool);
filename = switch_core_alloc(pool, strlen(profile->logfile) + WARM_FUZZY_OFFSET);
for (i = 1; i < MAX_ROT; i++) {
sprintf((char *) filename, "%s.%s.%i", profile->logfile, date, i);
if (switch_file_exists(filename, pool) == SWITCH_STATUS_SUCCESS) {
continue;
}
switch_file_close(profile->log_afd);
switch_file_rename(profile->logfile, filename, pool);
if ((status = mod_logfile_openlogfile(profile, SWITCH_FALSE)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error Rotating Log!\n");
goto end;
}
break;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "New log started.\n");
end:
if (pool) {
switch_core_destroy_memory_pool(&pool);
}
switch_mutex_unlock(globals.mutex);
return status;
}
WSClientParser::~WSClientParser() {
// TODO Auto-generated destructor stub
DestroyCall();
switch_mutex_destroy(clientMutex);
switch_core_destroy_memory_pool(&mpPool);
mpPool = NULL;
}
SWITCH_DECLARE_CONSTRUCTOR EventConsumer::~EventConsumer()
{
if (node) {
switch_event_unbind(&node);
}
if (events) {
switch_queue_interrupt_all(events);
}
switch_core_destroy_memory_pool(&pool);
}
SWITCH_DECLARE(switch_status_t) switch_core_directory_close(switch_directory_handle_t *dh)
{
switch_status_t status;
status = dh->directory_interface->directory_close(dh);
UNPROTECT_INTERFACE(dh->directory_interface);
if (switch_test_flag(dh, SWITCH_DIRECTORY_FLAG_FREE_POOL)) {
switch_core_destroy_memory_pool(&dh->memory_pool);
}
return status;
}
SWITCH_DECLARE_CONSTRUCTOR EventConsumer::~EventConsumer()
{
uint32_t i;
for (i = 0; i < node_index; i++) {
switch_event_unbind(&enodes[i]);
}
if (events) {
switch_queue_interrupt_all(events);
}
switch_core_destroy_memory_pool(&pool);
}
void mod_format_cdr_profile_shutdown(cdr_profile_t *profile)
{
int err_dir_index = 0;
for (err_dir_index = 0; err_dir_index < profile->err_dir_count; err_dir_index++) {
switch_safe_free(profile->err_log_dir[err_dir_index]);
}
switch_safe_free(profile->log_dir);
switch_thread_rwlock_destroy(profile->log_path_lock);
switch_core_destroy_memory_pool(&profile->pool);
}
static void do_load(void)
{
switch_mutex_lock(MUTEX);
if (globals.pool) {
switch_core_destroy_memory_pool(&globals.pool);
}
memset(&globals, 0, sizeof(globals));
switch_core_new_memory_pool(&globals.pool);
globals.timeout = 10;
load_config();
switch_mutex_unlock(MUTEX);
}
static void *SWITCH_THREAD_FUNC task_own_thread(switch_thread_t *thread, void *obj)
{
switch_scheduler_task_container_t *tp = (switch_scheduler_task_container_t *) obj;
switch_memory_pool_t *pool;
pool = tp->pool;
tp->pool = NULL;
switch_scheduler_execute(tp);
switch_core_destroy_memory_pool(&pool);
tp->in_thread = 0;
return NULL;
}
switch_status_t mongo_connection_pool_create(mongo_connection_pool_t **conn_pool, switch_size_t min_connections, switch_size_t max_connections,
const char *conn_str)
{
switch_memory_pool_t *pool = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS;
mongo_connection_pool_t *cpool = NULL;
DBClientBase *conn = NULL;
if ((status = switch_core_new_memory_pool(&pool)) != SWITCH_STATUS_SUCCESS) {
return status;
}
if (!(cpool = (mongo_connection_pool_t *)switch_core_alloc(pool, sizeof(mongo_connection_pool_t)))) {
switch_goto_status(SWITCH_STATUS_MEMERR, done);
}
if ((status = switch_mutex_init(&cpool->mutex, SWITCH_MUTEX_NESTED, pool)) != SWITCH_STATUS_SUCCESS) {
goto done;
}
if ((status = switch_queue_create(&cpool->connections, max_connections, pool)) != SWITCH_STATUS_SUCCESS) {
goto done;
}
cpool->min_connections = min_connections;
cpool->max_connections = max_connections;
cpool->conn_str = switch_core_strdup(pool, conn_str);
cpool->pool = pool;
for (cpool->size = 0; cpool->size < min_connections; cpool->size++) {
if (mongo_connection_create(&conn, conn_str) == SWITCH_STATUS_SUCCESS) {
mongo_connection_pool_put(cpool, conn);
} else {
break;
}
}
done:
if (status == SWITCH_STATUS_SUCCESS) {
*conn_pool = cpool;
} else {
switch_core_destroy_memory_pool(&pool);
}
return status;
}
static void socket_destroy(JSContext * cx, JSObject * obj)
{
js_socket_obj_t *socket = JS_GetPrivate(cx, obj);
if (socket == NULL)
return;
if (socket->socket != 0) {
socket->saveDepth = JS_SuspendRequest(cx);
switch_socket_shutdown(socket->socket, SWITCH_SHUTDOWN_READWRITE);
switch_socket_close(socket->socket);
switch_core_destroy_memory_pool(&socket->pool);
JS_ResumeRequest(cx, socket->saveDepth);
}
}
switch_status_t mod_amqp_logging_destroy(mod_amqp_logging_profile_t **prof)
{
mod_amqp_message_t *msg = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS;
mod_amqp_connection_t *conn = NULL, *conn_next = NULL;
switch_memory_pool_t *pool;
mod_amqp_logging_profile_t *profile;
if (!prof || !*prof) {
return SWITCH_STATUS_SUCCESS;
}
profile = *prof;
pool = profile->pool;
if (profile->name) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Profile[%s] shutting down...\n", profile->name);
switch_core_hash_delete(globals.logging_hash, profile->name);
}
profile->running = 0;
if (profile->logging_thread) {
switch_thread_join(&status, profile->logging_thread);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Profile[%s] closing AMQP socket...\n", profile->name);
for (conn = profile->conn_root; conn; conn = conn_next) {
conn_next = conn->next;
mod_amqp_connection_destroy(&conn);
}
profile->conn_active = NULL;
profile->conn_root = NULL;
while (profile->send_queue && switch_queue_trypop(profile->send_queue, (void**)&msg) == SWITCH_STATUS_SUCCESS) {
mod_amqp_util_msg_destroy(&msg);
}
if (pool) {
switch_core_destroy_memory_pool(&pool);
}
*prof = NULL;
return SWITCH_STATUS_SUCCESS;
}
void mongo_connection_pool_destroy(mongo_connection_pool_t **conn_pool)
{
mongo_connection_pool_t *cpool = *conn_pool;
void *data = NULL;
switch_assert(cpool != NULL);
while (switch_queue_trypop(cpool->connections, &data) == SWITCH_STATUS_SUCCESS) {
mongo_connection_destroy((DBClientBase **)&data);
}
switch_mutex_destroy(cpool->mutex);
switch_core_destroy_memory_pool(&cpool->pool);
*conn_pool = NULL;
}
SWITCH_DECLARE(switch_status_t) switch_ivr_menu_stack_free(switch_ivr_menu_t *stack)
{
switch_status_t status = SWITCH_STATUS_FALSE;
if (stack != NULL && stack->pool != NULL) {
if (switch_test_flag(stack, SWITCH_IVR_MENU_FLAG_STACK)
&& switch_test_flag(stack, SWITCH_IVR_MENU_FLAG_FREEPOOL)) {
switch_memory_pool_t *pool = stack->pool;
status = switch_core_destroy_memory_pool(&pool);
} else {
status = SWITCH_STATUS_SUCCESS;
}
}
return status;
}
SWITCH_DECLARE(switch_status_t) switch_core_asr_close(switch_asr_handle_t *ah, switch_asr_flag_t *flags)
{
switch_status_t status;
switch_assert(ah != NULL);
status = ah->asr_interface->asr_close(ah, flags);
switch_set_flag(ah, SWITCH_ASR_FLAG_CLOSED);
UNPROTECT_INTERFACE(ah->asr_interface);
if (switch_test_flag(ah, SWITCH_ASR_FLAG_FREE_POOL)) {
switch_core_destroy_memory_pool(&ah->memory_pool);
}
return status;
}
static void teletone_destroy(JSContext * cx, JSObject * obj)
{
struct teletone_obj *tto = JS_GetPrivate(cx, obj);
switch_memory_pool_t *pool;
if (tto) {
if (tto->timer) {
switch_core_timer_destroy(tto->timer);
}
teletone_destroy_session(&tto->ts);
switch_buffer_destroy(&tto->audio_buffer);
switch_core_codec_destroy(&tto->codec);
pool = tto->pool;
tto->pool = NULL;
if (pool) {
switch_core_destroy_memory_pool(&pool);
}
}
}
SWITCH_DECLARE(switch_status_t) switch_core_timer_destroy(switch_timer_t *timer)
{
if (!timer->timer_interface || !timer->timer_interface->timer_destroy) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer is not properly configured.\n");
return SWITCH_STATUS_GENERR;
}
timer->timer_interface->timer_destroy(timer);
UNPROTECT_INTERFACE(timer->timer_interface);
if (switch_test_flag(timer, SWITCH_TIMER_FLAG_FREE_POOL)) {
switch_core_destroy_memory_pool(&timer->memory_pool);
}
memset(timer, 0, sizeof(*timer));
return SWITCH_STATUS_SUCCESS;
}
/**
* Create new output component
*/
static struct rayo_component *create_output_component(struct rayo_actor *actor, const char *type, iks *output, const char *client_jid)
{
switch_memory_pool_t *pool;
struct output_component *output_component = NULL;
switch_core_new_memory_pool(&pool);
output_component = switch_core_alloc(pool, sizeof(*output_component));
output_component = OUTPUT_COMPONENT(rayo_component_init((struct rayo_component *)output_component, pool, type, "output", NULL, actor, client_jid));
if (output_component) {
output_component->document = iks_copy(output);
output_component->start_offset_ms = iks_find_int_attrib(output, "start-offset");
output_component->repeat_interval_ms = iks_find_int_attrib(output, "repeat-interval");
output_component->repeat_times = iks_find_int_attrib(output, "repeat-times");
output_component->max_time_ms = iks_find_int_attrib(output, "max-time");
output_component->start_paused = iks_find_bool_attrib(output, "start-paused");
output_component->renderer = switch_core_strdup(RAYO_POOL(output_component), iks_find_attrib_soft(output, "renderer"));
/* get custom headers */
{
switch_stream_handle_t headers = { 0 };
iks *header = NULL;
int first = 1;
SWITCH_STANDARD_STREAM(headers);
for (header = iks_find(output, "header"); header; header = iks_next_tag(header)) {
if (!strcmp("header", iks_name(header))) {
const char *name = iks_find_attrib_soft(header, "name");
const char *value = iks_find_attrib_soft(header, "value");
if (!zstr(name) && !zstr(value)) {
headers.write_function(&headers, "%s%s=%s", first ? "{" : ",", name, value);
first = 0;
}
}
}
if (headers.data) {
headers.write_function(&headers, "}");
output_component->headers = switch_core_strdup(RAYO_POOL(output_component), (char *)headers.data);
free(headers.data);
}
}
} else {
switch_core_destroy_memory_pool(&pool);
}
return RAYO_COMPONENT(output_component);
}
switch_status_t mod_amqp_command_destroy(mod_amqp_command_profile_t **prof)
{
switch_status_t ret;
mod_amqp_connection_t *conn = NULL, *conn_next = NULL;
switch_memory_pool_t *pool;
mod_amqp_command_profile_t *profile;
if (!prof || !*prof) {
return SWITCH_STATUS_SUCCESS;
}
profile = *prof;
pool = profile->pool;
if (profile->name) {
switch_core_hash_delete(globals.command_hash, profile->name);
}
profile->running = 0;
if (profile->command_thread) {
switch_thread_join(&ret, profile->command_thread);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Profile[%s] closing AMQP socket...\n", profile->name);
for (conn = profile->conn_root; conn; conn = conn_next) {
mod_amqp_connection_destroy(&conn);
}
profile->conn_active = NULL;
profile->conn_root = NULL;
if (pool) {
switch_core_destroy_memory_pool(&pool);
}
*prof = NULL;
return SWITCH_STATUS_SUCCESS;
}
void switch_load_timezones(switch_bool_t reload)
{
switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, cfg = NULL;
unsigned total = 0;
if (TIMEZONES_LIST.hash) {
switch_core_hash_destroy(&TIMEZONES_LIST.hash);
}
if (TIMEZONES_LIST.pool) {
switch_core_destroy_memory_pool(&TIMEZONES_LIST.pool);
}
memset(&TIMEZONES_LIST, 0, sizeof(TIMEZONES_LIST));
switch_core_new_memory_pool(&TIMEZONES_LIST.pool);
switch_core_hash_init(&TIMEZONES_LIST.hash, TIMEZONES_LIST.pool);
if ((xml = switch_xml_open_cfg("timezones.conf", &cfg, NULL))) {
if ((x_lists = switch_xml_child(cfg, "timezones"))) {
for (x_list = switch_xml_child(x_lists, "zone"); x_list; x_list = x_list->next) {
const char *name = switch_xml_attr(x_list, "name");
const char *value = switch_xml_attr(x_list, "value");
if (zstr(name)) {
continue;
}
if (zstr(value)) {
continue;
}
switch_core_hash_insert(TIMEZONES_LIST.hash, name, switch_core_strdup(TIMEZONES_LIST.pool, value));
total++;
}
}
switch_xml_free(xml);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Timezone %sloaded %d definitions\n", reload ? "re" : "", total);
}
SWITCH_DECLARE(switch_status_t) switch_directory_exists(const char *dirname, switch_memory_pool_t *pool)
{
apr_dir_t *dir_handle;
switch_memory_pool_t *our_pool = NULL;
switch_status_t status;
if (!pool) {
switch_core_new_memory_pool(&our_pool);
pool = our_pool;
}
if ((status = apr_dir_open(&dir_handle, dirname, pool)) == APR_SUCCESS) {
apr_dir_close(dir_handle);
}
if (our_pool) {
switch_core_destroy_memory_pool(&our_pool);
}
return status;
}
static JSBool socket_construct(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{
js_socket_obj_t *js_socket_obj = 0;
switch_memory_pool_t *pool;
switch_socket_t *socket;
switch_status_t ret;
switch_core_new_memory_pool(&pool);
ret = switch_socket_create(&socket, AF_INET, SOCK_STREAM, SWITCH_PROTO_TCP, pool);
if (ret != SWITCH_STATUS_SUCCESS) {
switch_core_destroy_memory_pool(&pool);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Failed to create socket, reason: %d.\n", ret);
return JS_FALSE;
}
// allocate information needed by JS to be able to write to the log.
// (needed since multitple js sessions can write to the same log)
js_socket_obj = switch_core_alloc(pool, sizeof(js_socket_obj_t));
js_socket_obj->pool = pool;
js_socket_obj->socket = socket;
JS_SetPrivate(cx, obj, js_socket_obj);
return JS_TRUE;
}
