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; }