int manager_bridging_init(void)
{
int ret = 0;
struct stasis_topic *manager_topic;
struct stasis_topic *bridge_topic;
if (bridge_state_router) {
/* Already initialized */
return 0;
}
ast_register_cleanup(manager_bridging_cleanup);
manager_topic = ast_manager_get_topic();
if (!manager_topic) {
return -1;
}
bridge_topic = ast_bridge_topic_all_cached();
if (!bridge_topic) {
return -1;
}
topic_forwarder = stasis_forward_all(bridge_topic, manager_topic);
if (!topic_forwarder) {
return -1;
}
bridge_state_router = ast_manager_get_message_router();
if (!bridge_state_router) {
return -1;
}
ret |= stasis_message_router_add_cache_update(bridge_state_router,
ast_bridge_snapshot_type(), bridge_snapshot_update, NULL);
ret |= stasis_message_router_add(bridge_state_router,
ast_bridge_merge_message_type(), bridge_merge_cb, NULL);
ret |= stasis_message_router_add(bridge_state_router,
ast_channel_entered_bridge_type(), channel_enter_cb, NULL);
ret |= stasis_message_router_add(bridge_state_router,
ast_channel_left_bridge_type(), channel_leave_cb, NULL);
ret |= ast_manager_register_xml_core("BridgeList", 0, manager_bridges_list);
ret |= ast_manager_register_xml_core("BridgeInfo", 0, manager_bridge_info);
ret |= ast_manager_register_xml_core("BridgeDestroy", 0, manager_bridge_destroy);
ret |= ast_manager_register_xml_core("BridgeKick", 0, manager_bridge_kick);
/* If somehow we failed to add any routes, just shut down the whole
* thing and fail it.
*/
if (ret) {
manager_bridging_cleanup();
return -1;
}
return 0;
}
int astobj2_init(void)
{
#ifdef REF_DEBUG
char ref_filename[1024];
#endif
if (container_init() != 0) {
return -1;
}
#ifdef REF_DEBUG
snprintf(ref_filename, sizeof(ref_filename), "%s/refs", ast_config_AST_LOG_DIR);
ref_log = fopen(ref_filename, "w");
if (!ref_log) {
ast_log(LOG_ERROR, "Could not open ref debug log file: %s\n", ref_filename);
}
#endif
#if defined(AO2_DEBUG)
ast_cli_register_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
#endif /* defined(AO2_DEBUG) */
ast_register_cleanup(astobj2_cleanup);
return 0;
}
/*! \brief Initialize the system level items for \ref stasis */
int ast_stasis_system_init(void)
{
ast_register_cleanup(stasis_system_cleanup);
system_topic = stasis_topic_create("ast_system");
if (!system_topic) {
return 1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_network_change_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_system_registry_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_available_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_offertimerstart_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_requested_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_requestacknowledged_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_callerstopmonitoring_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_callerstartmonitoring_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_callerrecalling_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_recallcomplete_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_failure_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_cc_monitorfailed_type) != 0) {
return -1;
}
return 0;
}
int stasis_wait_init(void)
{
ast_register_cleanup(wait_cleanup);
if (STASIS_MESSAGE_TYPE_INIT(cache_guarantee_type) != 0) {
return -1;
}
return 0;
}
int ast_format_cache_init(void)
{
formats = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_RWLOCK, CACHE_BUCKETS,
format_hash_cb, format_cmp_cb);
if (!formats) {
return -1;
}
ast_register_cleanup(format_cache_shutdown);
return 0;
}
int ast_codec_init(void)
{
codecs = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_RWLOCK, CODEC_BUCKETS, codec_hash, codec_cmp);
if (!codecs) {
return -1;
}
ast_cli_register_multiple(codec_cli, ARRAY_LEN(codec_cli));
ast_register_cleanup(codec_shutdown);
return 0;
}
int ast_format_init(void)
{
interfaces = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK, 0,
FORMAT_INTERFACE_BUCKETS, format_interface_hash_fn, NULL, format_interface_cmp_fn);
if (!interfaces) {
return -1;
}
ast_register_cleanup(format_shutdown);
return 0;
}
int ast_named_locks_init(void)
{
named_locks = ao2_container_alloc_hash(0, 0, NAMED_LOCKS_BUCKETS, named_locks_hash, NULL,
named_locks_cmp);
if (!named_locks) {
return -1;
}
ast_register_cleanup(named_locks_shutdown);
return 0;
}
int stasis_cache_init(void)
{
ast_register_cleanup(stasis_cache_cleanup);
if (STASIS_MESSAGE_TYPE_INIT(stasis_cache_clear_type) != 0) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(stasis_cache_update_type) != 0) {
return -1;
}
return 0;
}
int ast_stasis_channels_init(void)
{
int res = 0;
ast_register_cleanup(stasis_channels_cleanup);
channel_cache_all = stasis_cp_all_create("ast_channel_topic_all",
channel_snapshot_get_id);
if (!channel_cache_all) {
return -1;
}
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_agent_login_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_agent_logoff_type);
channel_cache_by_name = stasis_cache_create(channel_snapshot_get_name);
if (!channel_cache_by_name) {
return -1;
}
/* This should be initialized before the caching topic */
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_snapshot_type);
channel_by_name_topic = stasis_caching_topic_create(
stasis_cp_all_topic(channel_cache_all),
channel_cache_by_name);
if (!channel_by_name_topic) {
return -1;
}
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_dial_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_varset_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_user_event_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_hangup_request_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_dtmf_begin_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_dtmf_end_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_hold_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_unhold_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_chanspy_start_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_chanspy_stop_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_fax_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_hangup_handler_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_moh_start_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_moh_stop_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_monitor_start_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_channel_monitor_stop_type);
return res;
}
int manager_mwi_init(void)
{
int ret = 0;
struct stasis_topic *manager_topic;
struct stasis_topic *mwi_topic;
struct stasis_message_router *message_router;
manager_topic = ast_manager_get_topic();
if (!manager_topic) {
return -1;
}
message_router = ast_manager_get_message_router();
if (!message_router) {
return -1;
}
mwi_topic = ast_mwi_topic_all();
if (!mwi_topic) {
return -1;
}
topic_forwarder = stasis_forward_all(mwi_topic, manager_topic);
if (!topic_forwarder) {
return -1;
}
ast_register_cleanup(manager_mwi_shutdown);
ret |= stasis_message_router_add(message_router,
ast_mwi_state_type(),
mwi_update_cb,
NULL);
ret |= stasis_message_router_add(message_router,
ast_mwi_vm_app_type(),
mwi_app_event_cb,
NULL);
/* If somehow we failed to add any routes, just shut down the whole
* thing and fail it.
*/
if (ret) {
manager_mwi_shutdown();
return -1;
}
return 0;
}
int ast_endpoint_stasis_init(void)
{
int res = 0;
ast_register_cleanup(endpoints_stasis_cleanup);
endpoint_cache_all = stasis_cp_all_create("endpoint_topic_all",
endpoint_snapshot_get_id);
if (!endpoint_cache_all) {
return -1;
}
res |= STASIS_MESSAGE_TYPE_INIT(ast_endpoint_snapshot_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_endpoint_state_type);
res |= STASIS_MESSAGE_TYPE_INIT(ast_endpoint_contact_state_type);
return res;
}
int ast_local_init(void)
{
if (STASIS_MESSAGE_TYPE_INIT(ast_local_optimization_begin_type)) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_local_optimization_end_type)) {
return -1;
}
if (STASIS_MESSAGE_TYPE_INIT(ast_local_bridge_type)) {
return -1;
}
if (!(local_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
return -1;
}
ast_format_cap_append_by_type(local_tech.capabilities, AST_MEDIA_TYPE_UNKNOWN);
locals = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, locals_cmp_cb);
if (!locals) {
ao2_cleanup(local_tech.capabilities);
local_tech.capabilities = NULL;
return -1;
}
/* Make sure we can register our channel type */
if (ast_channel_register(&local_tech)) {
ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
ao2_ref(locals, -1);
ao2_cleanup(local_tech.capabilities);
local_tech.capabilities = NULL;
return -1;
}
ast_cli_register_multiple(cli_local, ARRAY_LEN(cli_local));
ast_manager_register_xml_core("LocalOptimizeAway", EVENT_FLAG_SYSTEM|EVENT_FLAG_CALL, manager_optimize_away);
ast_register_cleanup(local_shutdown);
return 0;
}
/*!
* \brief Initializes the resolver.
*
* \retval 0 on success
* \retval -1 on failure
*/
int ast_dns_system_resolver_init(void)
{
/* Register the base resolver */
int res = ast_dns_resolver_register(&dns_system_resolver_base);
if (res) {
return DNS_SYSTEM_RESOLVER_FAILURE;
}
/* Instantiate the task processor */
dns_system_resolver_tp = ast_taskprocessor_get("dns_system_resolver_tp",
TPS_REF_DEFAULT);
/* Return error if the task processor failed to instantiate */
if (!dns_system_resolver_tp) {
dns_system_resolver_destroy();
return DNS_SYSTEM_RESOLVER_FAILURE;
}
/* Register the cleanup function */
ast_register_cleanup(dns_system_resolver_destroy);
return DNS_SYSTEM_RESOLVER_SUCCESS;
}
