int stasis_topic_wait(struct stasis_topic *topic)
{
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
struct caching_guarantee *guarantee;
msg = caching_guarantee_create();
if (!msg) {
return -1;
}
sub = stasis_subscribe(topic, guarantee_handler, msg);
if (!sub) {
return -1;
}
guarantee = stasis_message_data(msg);
ast_mutex_lock(&guarantee->lock);
stasis_publish(topic, msg);
while (!guarantee->done) {
ast_cond_wait(&guarantee->cond, &guarantee->lock);
}
ast_mutex_unlock(&guarantee->lock);
return 0;
}
static struct stasis_message_router *stasis_message_router_create_internal(
struct stasis_topic *topic, int use_thread_pool)
{
int res;
RAII_VAR(struct stasis_message_router *, router, NULL, ao2_cleanup);
router = ao2_t_alloc(sizeof(*router), router_dtor, stasis_topic_name(topic));
if (!router) {
return NULL;
}
res = 0;
res |= AST_VECTOR_INIT(&router->routes, 0);
res |= AST_VECTOR_INIT(&router->cache_routes, 0);
if (res) {
return NULL;
}
if (use_thread_pool) {
router->subscription = stasis_subscribe_pool(topic, router_dispatch, router);
} else {
router->subscription = stasis_subscribe(topic, router_dispatch, router);
}
if (!router->subscription) {
return NULL;
}
ao2_ref(router, +1);
return router;
}
static int load_module(void)
{
stasis_rtp_subscription = stasis_subscribe(ast_rtp_topic(),
rtp_topic_handler, NULL);
if (!stasis_rtp_subscription) {
return AST_MODULE_LOAD_FAILURE;
}
return AST_MODULE_LOAD_SUCCESS;
}
static int load_module(void)
{
if (!ast_module_check("res_hep.so") || !hepv3_is_loaded()) {
ast_log(AST_LOG_WARNING, "res_hep is not loaded or running; declining module load\n");
return AST_MODULE_LOAD_DECLINE;
}
stasis_rtp_subscription = stasis_subscribe(ast_rtp_topic(),
rtp_topic_handler, NULL);
if (!stasis_rtp_subscription) {
return AST_MODULE_LOAD_DECLINE;
}
return AST_MODULE_LOAD_SUCCESS;
}
static int load_module(void)
{
if ((LOG_SECURITY = ast_logger_register_level(LOG_SECURITY_NAME)) == -1) {
return AST_MODULE_LOAD_DECLINE;
}
if (!(security_stasis_sub = stasis_subscribe(ast_security_topic(), security_stasis_cb, NULL))) {
ast_logger_unregister_level(LOG_SECURITY_NAME);
LOG_SECURITY = -1;
return AST_MODULE_LOAD_DECLINE;
}
ast_verb(3, "Security Logging Enabled\n");
return AST_MODULE_LOAD_SUCCESS;
}
static int load_module(void)
{
/* You can create a message router to route messages by type */
router = stasis_message_router_create(
ast_channel_topic_all_cached());
if (!router) {
return AST_MODULE_LOAD_FAILURE;
}
stasis_message_router_add(router, stasis_cache_update_type(),
updates, NULL);
stasis_message_router_set_default(router, default_route, NULL);
/* Or a subscription to receive all of the messages from a topic */
sub = stasis_subscribe(ast_channel_topic_all(), statsmaker, NULL);
if (!sub) {
return AST_MODULE_LOAD_FAILURE;
}
return AST_MODULE_LOAD_SUCCESS;
}
static void parking_manager_enable_stasis(void)
{
if (!parking_sub) {
parking_sub = stasis_subscribe(ast_parking_topic(), parking_event_cb, NULL);
}
}
void ast_channel_publish_dial_forward(struct ast_channel *caller, struct ast_channel *peer,
struct ast_channel *forwarded, const char *dialstring, const char *dialstatus,
const char *forward)
{
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, peer_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, forwarded_snapshot, NULL, ao2_cleanup);
ast_assert(peer != NULL);
blob = ast_json_pack("{s: s, s: s, s: s}",
"dialstatus", S_OR(dialstatus, ""),
"forward", S_OR(forward, ""),
"dialstring", S_OR(dialstring, ""));
if (!blob) {
return;
}
payload = ast_multi_channel_blob_create(blob);
if (!payload) {
return;
}
if (caller) {
ast_channel_lock(caller);
caller_snapshot = ast_channel_snapshot_create(caller);
ast_channel_unlock(caller);
if (!caller_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
}
ast_channel_lock(peer);
peer_snapshot = ast_channel_snapshot_create(peer);
ast_channel_unlock(peer);
if (!peer_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "peer", peer_snapshot);
if (forwarded) {
ast_channel_lock(forwarded);
forwarded_snapshot = ast_channel_snapshot_create(forwarded);
ast_channel_unlock(forwarded);
if (!forwarded_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "forwarded", forwarded_snapshot);
}
msg = stasis_message_create(ast_channel_dial_type(), payload);
if (!msg) {
return;
}
if (forwarded) {
struct stasis_subscription *subscription = stasis_subscribe(ast_channel_topic(peer), dummy_event_cb, NULL);
stasis_publish(ast_channel_topic(peer), msg);
stasis_unsubscribe_and_join(subscription);
} else {
publish_message_for_channel_topics(msg, caller);
}
}