From f1036f40dc22c4d4b30cc2ab36199cd749ead9c5 Mon Sep 17 00:00:00 2001
From: Kinsey Moore <kmoore@digium.com>
Date: Wed, 6 Aug 2014 12:55:28 +0000
Subject: [PATCH] Stasis: Allow message types to be blocked
This introduces stasis.conf and a mechanism to prevent certain message
types from being published. Internally, this works by preventing the
chosen message types from being created which ensures that those
message types can never be published. This patch also adjusts message
publishers such that message payloads are not created if the related
message type is not available.
ASTERISK-23943 #close
Review: https://reviewboard.asterisk.org/r/3823/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@420124 65c4cc65-6c06-0410-ace0-fbb531ad65f3
---
apps/app_chanspy.c | 7 +-
apps/app_forkcdr.c | 9 +-
apps/app_queue.c | 6 +-
configs/samples/stasis.conf.sample | 122 +++++++++++++
funcs/func_cdr.c | 27 ++-
include/asterisk/stasis.h | 35 +++-
main/app.c | 8 +
main/bridge.c | 4 +
main/ccss.c | 7 +
main/cdr.c | 21 ++-
main/channel.c | 5 +
main/core_local.c | 12 ++
main/devicestate.c | 8 +
main/endpoints.c | 9 +
main/file.c | 4 +
main/loader.c | 4 +
main/manager.c | 2 +-
main/named_acl.c | 2 +-
main/pickup.c | 4 +
main/presencestate.c | 7 +-
main/rtp_engine.c | 4 +
main/security_events.c | 5 +-
main/stasis.c | 269 +++++++++++++++++++++++++++++
main/stasis_bridges.c | 32 ++++
main/stasis_cache.c | 19 +-
main/stasis_channels.c | 24 ++-
main/stasis_endpoints.c | 3 +
main/stasis_message.c | 17 +-
main/stasis_system.c | 4 +
main/test.c | 11 +-
pbx/pbx_realtime.c | 8 +-
res/parking/parking_manager.c | 8 +
res/res_corosync.c | 4 +
res/res_stasis.c | 4 +
res/res_stasis_snoop.c | 7 +-
res/res_stasis_test.c | 4 +
res/res_stun_monitor.c | 7 +-
tests/test_stasis.c | 44 ++---
tests/test_stasis_channels.c | 4 +-
39 files changed, 708 insertions(+), 73 deletions(-)
create mode 100644 configs/samples/stasis.conf.sample
diff --git a/apps/app_chanspy.c b/apps/app_chanspy.c
index af69be3033..5806b997d7 100644
--- a/apps/app_chanspy.c
+++ b/apps/app_chanspy.c
@@ -557,13 +557,14 @@ static void publish_chanspy_message(struct ast_channel *spyer,
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+ struct stasis_message_type *type = start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type();
if (!spyer) {
ast_log(AST_LOG_WARNING, "Attempt to publish ChanSpy message for NULL spyer channel\n");
return;
}
blob = ast_json_null();
- if (!blob) {
+ if (!blob || !type) {
return;
}
@@ -582,9 +583,7 @@ static void publish_chanspy_message(struct ast_channel *spyer,
}
}
- message = stasis_message_create(
- start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type(),
- payload);
+ message = stasis_message_create(type, payload);
if (!message) {
return;
}
diff --git a/apps/app_forkcdr.c b/apps/app_forkcdr.c
index 932e862e1a..bbd15881a5 100644
--- a/apps/app_forkcdr.c
+++ b/apps/app_forkcdr.c
@@ -136,7 +136,7 @@ static void forkcdr_callback(void *data, struct stasis_subscription *sub, struct
static int forkcdr_exec(struct ast_channel *chan, const char *data)
{
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
- RAII_VAR(struct fork_cdr_message_payload *, payload, ao2_alloc(sizeof(*payload), NULL), ao2_cleanup);
+ RAII_VAR(struct fork_cdr_message_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message_router *, router, ast_cdr_message_router(), ao2_cleanup);
char *parse;
@@ -153,6 +153,13 @@ static int forkcdr_exec(struct ast_channel *chan, const char *data)
ast_app_parse_options(forkcdr_exec_options, &flags, NULL, args.options);
}
+ if (!forkcdr_message_type()) {
+ ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: no message type\n",
+ ast_channel_name(chan));
+ return -1;
+ }
+
+ payload = ao2_alloc(sizeof(*payload), NULL);
if (!payload) {
return -1;
}
diff --git a/apps/app_queue.c b/apps/app_queue.c
index b0c81df38a..012f04a710 100644
--- a/apps/app_queue.c
+++ b/apps/app_queue.c
@@ -2066,6 +2066,10 @@ static void queue_publish_multi_channel_snapshot_blob(struct stasis_topic *topic
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!type) {
+ return;
+ }
+
payload = ast_multi_channel_blob_create(blob);
if (!payload) {
return;
@@ -2122,7 +2126,7 @@ static void queue_publish_member_blob(struct stasis_message_type *type, struct a
RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
- if (!blob) {
+ if (!blob || !type) {
return;
}
diff --git a/configs/samples/stasis.conf.sample b/configs/samples/stasis.conf.sample
new file mode 100644
index 0000000000..3aac230cbb
--- /dev/null
+++ b/configs/samples/stasis.conf.sample
@@ -0,0 +1,122 @@
+[declined_message_types]
+; This config section contains the names of message types that should be prevented
+; from being created. By default, all message types are allowed to be created.
+;
+; Using this functionality requires knowledge of the names of internal stasis
+; message types which is generally the same as the name of the accessor function.
+;
+; Use of this functionality may break more complex functionality in Asterisk
+; such as CEL, CDR, transfers, etc. and will likely cause related messages in ARI
+; and AMI to go missing.
+; decline=stasis_app_recording_snapshot_type
+; decline=stasis_app_playback_snapshot_type
+; decline=stasis_test_message_type
+; decline=confbridge_start_type
+; decline=confbridge_end_type
+; decline=confbridge_join_type
+; decline=confbridge_leave_type
+; decline=confbridge_start_record_type
+; decline=confbridge_stop_record_type
+; decline=confbridge_mute_type
+; decline=confbridge_unmute_type
+; decline=confbridge_talking_type
+; decline=cel_generic_type
+; decline=ast_bridge_snapshot_type
+; decline=ast_bridge_merge_message_type
+; decline=ast_channel_entered_bridge_type
+; decline=ast_channel_left_bridge_type
+; decline=ast_blind_transfer_type
+; decline=ast_attended_transfer_type
+; decline=ast_endpoint_snapshot_type
+; decline=ast_endpoint_state_type
+; decline=ast_device_state_message_type
+; decline=ast_test_suite_message_type
+; decline=ast_mwi_state_type
+; decline=ast_mwi_vm_app_type
+; decline=ast_format_register_type
+; decline=ast_format_unregister_type
+; decline=ast_manager_get_generic_type
+; decline=ast_parked_call_type
+; decline=ast_channel_snapshot_type
+; decline=ast_channel_dial_type
+; decline=ast_channel_varset_type
+; decline=ast_channel_hangup_request_type
+; decline=ast_channel_dtmf_begin_type
+; decline=ast_channel_dtmf_end_type
+; decline=ast_channel_hold_type
+; decline=ast_channel_unhold_type
+; decline=ast_channel_chanspy_start_type
+; decline=ast_channel_chanspy_stop_type
+; decline=ast_channel_fax_type
+; decline=ast_channel_hangup_handler_type
+; decline=ast_channel_moh_start_type
+; decline=ast_channel_moh_stop_type
+; decline=ast_channel_monitor_start_type
+; decline=ast_channel_monitor_stop_type
+; decline=ast_channel_agent_login_type
+; decline=ast_channel_agent_logoff_type
+; decline=ast_channel_talking_start
+; decline=ast_channel_talking_stop
+; decline=ast_security_event_type
+; decline=ast_named_acl_change_type
+; decline=ast_local_bridge_type
+; decline=ast_local_optimization_begin_type
+; decline=ast_local_optimization_end_type
+; decline=stasis_subscription_change_type
+; decline=ast_multi_user_event_type
+; decline=stasis_cache_clear_type
+; decline=stasis_cache_update_type
+; decline=ast_network_change_type
+; decline=ast_system_registry_type
+; decline=ast_cc_available_type
+; decline=ast_cc_offertimerstart_type
+; decline=ast_cc_requested_type
+; decline=ast_cc_requestacknowledged_type
+; decline=ast_cc_callerstopmonitoring_type
+; decline=ast_cc_callerstartmonitoring_type
+; decline=ast_cc_callerrecalling_type
+; decline=ast_cc_recallcomplete_type
+; decline=ast_cc_failure_type
+; decline=ast_cc_monitorfailed_type
+; decline=ast_presence_state_message_type
+; decline=ast_rtp_rtcp_sent_type
+; decline=ast_rtp_rtcp_received_type
+; decline=ast_call_pickup_type
+; decline=aoc_s_type
+; decline=aoc_d_type
+; decline=aoc_e_type
+; decline=dahdichannel_type
+; decline=mcid_type
+; decline=session_timeout_type
+; decline=cdr_read_message_type
+; decline=cdr_write_message_type
+; decline=cdr_prop_write_message_type
+; decline=corosync_ping_message_type
+; decline=agi_exec_start_type
+; decline=agi_exec_end_type
+; decline=agi_async_start_type
+; decline=agi_async_exec_type
+; decline=agi_async_end_type
+; decline=queue_caller_join_type
+; decline=queue_caller_leave_type
+; decline=queue_caller_abandon_type
+; decline=queue_member_status_type
+; decline=queue_member_added_type
+; decline=queue_member_removed_type
+; decline=queue_member_pause_type
+; decline=queue_member_penalty_type
+; decline=queue_member_ringinuse_type
+; decline=queue_agent_called_type
+; decline=queue_agent_connect_type
+; decline=queue_agent_complete_type
+; decline=queue_agent_dump_type
+; decline=queue_agent_ringnoanswer_type
+; decline=meetme_join_type
+; decline=meetme_leave_type
+; decline=meetme_end_type
+; decline=meetme_mute_type
+; decline=meetme_talking_type
+; decline=meetme_talk_request_type
+; decline=appcdr_message_type
+; decline=forkcdr_message_type
+; decline=cdr_sync_message_type
diff --git a/funcs/func_cdr.c b/funcs/func_cdr.c
index 44ecf4d6b4..c9fce23d2d 100644
--- a/funcs/func_cdr.c
+++ b/funcs/func_cdr.c
@@ -437,8 +437,7 @@ static int cdr_read(struct ast_channel *chan, const char *cmd, char *parse,
char *buf, size_t len)
{
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
- RAII_VAR(struct cdr_func_payload *, payload,
- ao2_alloc(sizeof(*payload), NULL), ao2_cleanup);
+ RAII_VAR(struct cdr_func_payload *, payload, NULL, ao2_cleanup);
struct cdr_func_data output = { 0, };
if (!chan) {
@@ -446,6 +445,13 @@ static int cdr_read(struct ast_channel *chan, const char *cmd, char *parse,
return -1;
}
+ if (!cdr_read_message_type()) {
+ ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: message type not available\n",
+ ast_channel_name(chan));
+ return -1;
+ }
+
+ payload = ao2_alloc(sizeof(*payload), NULL);
if (!payload) {
return -1;
}
@@ -489,8 +495,7 @@ static int cdr_write(struct ast_channel *chan, const char *cmd, char *parse,
const char *value)
{
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
- RAII_VAR(struct cdr_func_payload *, payload,
- ao2_alloc(sizeof(*payload), NULL), ao2_cleanup);
+ RAII_VAR(struct cdr_func_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message_router *, router,
ast_cdr_message_router(), ao2_cleanup);
@@ -505,6 +510,13 @@ static int cdr_write(struct ast_channel *chan, const char *cmd, char *parse,
return -1;
}
+ if (!cdr_write_message_type()) {
+ ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: message type not available\n",
+ ast_channel_name(chan));
+ return -1;
+ }
+
+ payload = ao2_alloc(sizeof(*payload), NULL);
if (!payload) {
return -1;
}
@@ -543,6 +555,13 @@ static int cdr_prop_write(struct ast_channel *chan, const char *cmd, char *parse
return -1;
}
+ if (!cdr_write_message_type()) {
+ ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: message type not available\n",
+ ast_channel_name(chan));
+ return -1;
+ }
+
+ payload = ao2_alloc(sizeof(*payload), NULL);
if (!payload) {
return -1;
}
diff --git a/include/asterisk/stasis.h b/include/asterisk/stasis.h
index 4c4052c144..b8dc4c8457 100644
--- a/include/asterisk/stasis.h
+++ b/include/asterisk/stasis.h
@@ -273,6 +273,15 @@ struct stasis_message_vtable {
struct stasis_message *message);
};
+/*!
+ * \brief Return code for Stasis message type creation attempts
+ */
+enum stasis_message_type_result {
+ STASIS_MESSAGE_TYPE_ERROR = -1, /*!< Message type was not created due to allocation failure */
+ STASIS_MESSAGE_TYPE_SUCCESS, /*!< Message type was created successfully */
+ STASIS_MESSAGE_TYPE_DECLINED, /*!< Message type was not created due to configuration */
+};
+
/*!
* \brief Create a new message type.
*
@@ -281,12 +290,15 @@ struct stasis_message_vtable {
*
* \param name Name of the new type.
* \param vtable Virtual table of message methods. May be \c NULL.
- * \return Pointer to the new type.
- * \return \c NULL on error.
+ * \param[out] result The location where the new message type will be placed
+ *
+ * \note Stasis message type creation may be declined if the message type is disabled
+ *
+ * \returns A stasis_message_type_result enum
* \since 12
*/
-struct stasis_message_type *stasis_message_type_create(const char *name,
- struct stasis_message_vtable *vtable);
+enum stasis_message_type_result stasis_message_type_create(const char *name,
+ struct stasis_message_vtable *vtable, struct stasis_message_type **result);
/*!
* \brief Gets the name of a given message type
@@ -297,6 +309,16 @@ struct stasis_message_type *stasis_message_type_create(const char *name,
*/
const char *stasis_message_type_name(const struct stasis_message_type *type);
+/*!
+ * \brief Check whether a message type is declined
+ *
+ * \param name The name of the message type to check
+ *
+ * \retval zero The message type is not declined
+ * \retval non-zero The message type is declined
+ */
+int stasis_message_type_declined(const char *name);
+
/*!
* \brief Create a new message.
*
@@ -1184,9 +1206,8 @@ void stasis_log_bad_type_access(const char *name);
#define STASIS_MESSAGE_TYPE_INIT(name) \
({ \
ast_assert(_priv_ ## name == NULL); \
- _priv_ ## name = stasis_message_type_create(#name, \
- &_priv_ ## name ## _v); \
- _priv_ ## name ? 0 : -1; \
+ stasis_message_type_create(#name, \
+ &_priv_ ## name ## _v, &_priv_ ## name) == STASIS_MESSAGE_TYPE_ERROR ? 1 : 0; \
})
/*!
diff --git a/main/app.c b/main/app.c
index fa7c3ece13..89889c65f2 100644
--- a/main/app.c
+++ b/main/app.c
@@ -3104,6 +3104,10 @@ static struct stasis_message *mwi_state_create_message(
struct ast_mwi_state *mwi_state;
struct stasis_message *message;
+ if (!ast_mwi_state_type()) {
+ return NULL;
+ }
+
mwi_state = ast_mwi_create(mailbox, context);
if (!mwi_state) {
return NULL;
@@ -3247,6 +3251,10 @@ struct stasis_message *ast_mwi_blob_create(struct ast_mwi_state *mwi_state,
ast_assert(blob != NULL);
+ if (!message_type) {
+ return NULL;
+ }
+
obj = ao2_alloc(sizeof(*obj), mwi_blob_dtor);
if (!obj) {
return NULL;
diff --git a/main/bridge.c b/main/bridge.c
index 63086e16ee..462676ca84 100644
--- a/main/bridge.c
+++ b/main/bridge.c
@@ -615,6 +615,10 @@ static struct stasis_message *create_bridge_snapshot_message(struct ast_bridge *
{
RAII_VAR(struct ast_bridge_snapshot *, snapshot, NULL, ao2_cleanup);
+ if (!ast_bridge_snapshot_type()) {
+ return NULL;
+ }
+
ast_bridge_lock(bridge);
snapshot = ast_bridge_snapshot_create(bridge);
ast_bridge_unlock(bridge);
diff --git a/main/ccss.c b/main/ccss.c
index 9fcabfefd6..3626f3d38b 100644
--- a/main/ccss.c
+++ b/main/ccss.c
@@ -1032,8 +1032,15 @@ static int cc_publish(struct stasis_message_type *message_type, int core_id, str
RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+ if (!message_type) {
+ return -1;
+ }
+
blob = ast_json_pack("{s: i}",
"core_id", core_id);
+ if (!blob) {
+ return -1;
+ }
if (extras) {
ast_json_object_update(blob, extras);
diff --git a/main/cdr.c b/main/cdr.c
index 17fa8a25fa..2aaef88626 100644
--- a/main/cdr.c
+++ b/main/cdr.c
@@ -4198,7 +4198,7 @@ int ast_cdr_engine_init(void)
void ast_cdr_engine_term(void)
{
RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
- RAII_VAR(void *, payload, ao2_alloc(sizeof(*payload), NULL), ao2_cleanup);
+ RAII_VAR(void *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
/* Since this is called explicitly during process shutdown, we might not have ever
@@ -4208,16 +4208,19 @@ void ast_cdr_engine_term(void)
return;
}
- /* Make sure we have the needed items */
- if (!stasis_router || !payload) {
- return;
- }
+ if (cdr_sync_message_type()) {
+ /* Make sure we have the needed items */
+ payload = ao2_alloc(sizeof(*payload), NULL);
+ if (!stasis_router || !payload) {
+ return;
+ }
- ast_debug(1, "CDR Engine termination request received; waiting on messages...\n");
+ ast_debug(1, "CDR Engine termination request received; waiting on messages...\n");
- message = stasis_message_create(cdr_sync_message_type(), payload);
- if (message) {
- stasis_message_router_publish_sync(stasis_router, message);
+ message = stasis_message_create(cdr_sync_message_type(), payload);
+ if (message) {
+ stasis_message_router_publish_sync(stasis_router, message);
+ }
}
if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
diff --git a/main/channel.c b/main/channel.c
index 6a252a6991..23799d9be8 100644
--- a/main/channel.c
+++ b/main/channel.c
@@ -678,6 +678,11 @@ int ast_str2cause(const char *name)
static struct stasis_message *create_channel_snapshot_message(struct ast_channel *channel)
{
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
+
+ if (!ast_channel_snapshot_type()) {
+ return NULL;
+ }
+
ast_channel_lock(channel);
snapshot = ast_channel_snapshot_create(channel);
ast_channel_unlock(channel);
diff --git a/main/core_local.c b/main/core_local.c
index e1b66d0a73..54915ecfe2 100644
--- a/main/core_local.c
+++ b/main/core_local.c
@@ -357,6 +357,10 @@ static void local_optimization_started_cb(struct ast_unreal_pvt *base, struct as
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
struct local_pvt *p = (struct local_pvt *)base;
+ if (!ast_local_optimization_begin_type()) {
+ return;
+ }
+
json_object = ast_json_pack("{s: i, s: i}",
"dest", dest, "id", id);
@@ -395,6 +399,10 @@ static void local_optimization_finished_cb(struct ast_unreal_pvt *base, int succ
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
struct local_pvt *p = (struct local_pvt *)base;
+ if (!ast_local_optimization_end_type()) {
+ return;
+ }
+
json_object = ast_json_pack("{s: i, s: i}", "success", success, "id", id);
if (!json_object) {
@@ -501,6 +509,10 @@ static void publish_local_bridge_message(struct local_pvt *p)
struct ast_channel *owner;
struct ast_channel *chan;
+ if (!ast_local_bridge_type()) {
+ return;
+ }
+
ast_unreal_lock_all(&p->base, &chan, &owner);
blob = ast_json_pack("{s: s, s: s, s: b}",
diff --git a/main/devicestate.c b/main/devicestate.c
index c4a57dd685..7f9136da39 100644
--- a/main/devicestate.c
+++ b/main/devicestate.c
@@ -721,6 +721,10 @@ int ast_publish_device_state_full(
ast_assert(!ast_strlen_zero(device));
+ if (!ast_device_state_message_type()) {
+ return -1;
+ }
+
device_state = device_state_alloc(device, state, cachable, eid);
if (!device_state) {
return -1;
@@ -807,6 +811,10 @@ static struct stasis_message *device_state_aggregate_calc(struct stasis_cache_en
struct ast_devstate_aggregate aggregate;
int idx;
+ if (!ast_device_state_message_type()) {
+ return NULL;
+ }
+
/* Determine the new aggregate device state. */
ast_devstate_aggregate_init(&aggregate);
snapshot = stasis_cache_entry_get_local(entry);
diff --git a/main/endpoints.c b/main/endpoints.c
index 07687eecc5..cc2eccc705 100644
--- a/main/endpoints.c
+++ b/main/endpoints.c
@@ -174,6 +174,10 @@ static void endpoint_publish_snapshot(struct ast_endpoint *endpoint)
ast_assert(endpoint != NULL);
ast_assert(endpoint->topics != NULL);
+ if (!ast_endpoint_snapshot_type()) {
+ return;
+ }
+
snapshot = ast_endpoint_snapshot_create(endpoint);
if (!snapshot) {
return;
@@ -349,6 +353,11 @@ struct ast_endpoint *ast_endpoint_create(const char *tech, const char *resource)
static struct stasis_message *create_endpoint_snapshot_message(struct ast_endpoint *endpoint)
{
RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
+
+ if (!ast_endpoint_snapshot_type()) {
+ return NULL;
+ }
+
snapshot = ast_endpoint_snapshot_create(endpoint);
if (!snapshot) {
return NULL;
diff --git a/main/file.c b/main/file.c
index fa4c63bd95..59d39df8fd 100644
--- a/main/file.c
+++ b/main/file.c
@@ -97,6 +97,10 @@ static int publish_format_update(const struct ast_format_def *f, struct stasis_m
RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
+ if (!type) {
+ return -1;
+ }
+
json_object = ast_json_pack("{s: s, s: o}",
"format", f->name,
"extensions", json_array_from_list(f->exts, "|"));
diff --git a/main/loader.c b/main/loader.c
index b4eef13c28..ac17ddc9e7 100644
--- a/main/loader.c
+++ b/main/loader.c
@@ -803,6 +803,10 @@ static void publish_reload_message(const char *name, enum ast_module_reload_resu
RAII_VAR(struct ast_json *, event_object, NULL, ast_json_unref);
char res_buffer[8];
+ if (!ast_manager_get_generic_type()) {
+ return;
+ }
+
snprintf(res_buffer, sizeof(res_buffer), "%u", result);
event_object = ast_json_pack("{s: s, s: s}",
"Module", S_OR(name, "All"),
diff --git a/main/manager.c b/main/manager.c
index 7fa083ca9b..b4e927ffb8 100644
--- a/main/manager.c
+++ b/main/manager.c
@@ -1519,7 +1519,7 @@ void ast_manager_publish_event(const char *type, int class_type, struct ast_json
RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
- if (!obj) {
+ if (!obj || !ast_manager_get_generic_type()) {
return;
}
diff --git a/main/named_acl.c b/main/named_acl.c
index f0b5c28947..deda260b7d 100644
--- a/main/named_acl.c
+++ b/main/named_acl.c
@@ -380,7 +380,7 @@ static int publish_acl_change(const char *name)
RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json_object, ast_json_object_create(), ast_json_unref);
- if (!json_object) {
+ if (!json_object || !ast_named_acl_change_type()) {
goto publish_failure;
}
diff --git a/main/pickup.c b/main/pickup.c
index 5be0c03abe..125ec9359c 100644
--- a/main/pickup.c
+++ b/main/pickup.c
@@ -282,6 +282,10 @@ static int send_call_pickup_stasis_message(struct ast_channel *picking_up, struc
RAII_VAR(struct ast_multi_channel_blob *, pickup_payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_call_pickup_type()) {
+ return -1;
+ }
+
if (!(pickup_payload = ast_multi_channel_blob_create(ast_json_null()))) {
return -1;
}
diff --git a/main/presencestate.c b/main/presencestate.c
index db947df341..07df7429d9 100644
--- a/main/presencestate.c
+++ b/main/presencestate.c
@@ -263,8 +263,13 @@ static void presence_state_event(const char *provider,
const char *message)
{
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
- RAII_VAR(struct ast_presence_state_message *, presence_state, presence_state_alloc(provider, state, subtype, message), ao2_cleanup);
+ RAII_VAR(struct ast_presence_state_message *, presence_state, NULL, ao2_cleanup);
+ if (!ast_presence_state_message_type()) {
+ return;
+ }
+
+ presence_state = presence_state_alloc(provider, state, subtype, message);
if (!presence_state) {
return;
}
diff --git a/main/rtp_engine.c b/main/rtp_engine.c
index 52be8b90e2..0c624ab616 100644
--- a/main/rtp_engine.c
+++ b/main/rtp_engine.c
@@ -1996,6 +1996,10 @@ void ast_rtp_publish_rtcp_message(struct ast_rtp_instance *rtp,
RAII_VAR(struct rtcp_message_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+ if (!message_type) {
+ return;
+ }
+
payload = ao2_alloc(sizeof(*payload), rtcp_message_payload_dtor);
if (!payload || !report) {
return;
diff --git a/main/security_events.c b/main/security_events.c
index f4dc6fc6d8..00a70fbec5 100644
--- a/main/security_events.c
+++ b/main/security_events.c
@@ -1127,8 +1127,11 @@ static int handle_security_event(const struct ast_security_event_common *sec)
const struct ast_security_event_ie_type *ies;
unsigned int i;
- json_object = alloc_security_event_json_object(sec);
+ if (!ast_security_event_type()) {
+ return -1;
+ }
+ json_object = alloc_security_event_json_object(sec);
if (!json_object) {
return -1;
}
diff --git a/main/stasis.c b/main/stasis.c
index 594ec5e99c..d8e0e5afc8 100644
--- a/main/stasis.c
+++ b/main/stasis.c
@@ -41,6 +41,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_endpoints.h"
+#include "asterisk/config_options.h"
/*** DOCUMENTATION
<managerEvent language="en_US" name="UserEvent">
@@ -60,6 +61,135 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
</see-also>
</managerEventInstance>
</managerEvent>
+ <configInfo name="stasis" language="en_US">
+ <configFile name="stasis.conf">
+ <configObject name="declined_message_types">
+ <synopsis>Stasis message types for which to decline creation.</synopsis>
+ <configOption name="decline">
+ <synopsis>The message type to decline.</synopsis>
+ <description>
+ <para>This configuration option defines the name of the Stasis
+ message type that Asterisk is forbidden from creating and can be
+ specified as many times as necessary to achieve the desired result.</para>
+ <enumlist>
+ <enum name="stasis_app_recording_snapshot_type" />
+ <enum name="stasis_app_playback_snapshot_type" />
+ <enum name="stasis_test_message_type" />
+ <enum name="confbridge_start_type" />
+ <enum name="confbridge_end_type" />
+ <enum name="confbridge_join_type" />
+ <enum name="confbridge_leave_type" />
+ <enum name="confbridge_start_record_type" />
+ <enum name="confbridge_stop_record_type" />
+ <enum name="confbridge_mute_type" />
+ <enum name="confbridge_unmute_type" />
+ <enum name="confbridge_talking_type" />
+ <enum name="cel_generic_type" />
+ <enum name="ast_bridge_snapshot_type" />
+ <enum name="ast_bridge_merge_message_type" />
+ <enum name="ast_channel_entered_bridge_type" />
+ <enum name="ast_channel_left_bridge_type" />
+ <enum name="ast_blind_transfer_type" />
+ <enum name="ast_attended_transfer_type" />
+ <enum name="ast_endpoint_snapshot_type" />
+ <enum name="ast_endpoint_state_type" />
+ <enum name="ast_device_state_message_type" />
+ <enum name="ast_test_suite_message_type" />
+ <enum name="ast_mwi_state_type" />
+ <enum name="ast_mwi_vm_app_type" />
+ <enum name="ast_format_register_type" />
+ <enum name="ast_format_unregister_type" />
+ <enum name="ast_manager_get_generic_type" />
+ <enum name="ast_parked_call_type" />
+ <enum name="ast_channel_snapshot_type" />
+ <enum name="ast_channel_dial_type" />
+ <enum name="ast_channel_varset_type" />
+ <enum name="ast_channel_hangup_request_type" />
+ <enum name="ast_channel_dtmf_begin_type" />
+ <enum name="ast_channel_dtmf_end_type" />
+ <enum name="ast_channel_hold_type" />
+ <enum name="ast_channel_unhold_type" />
+ <enum name="ast_channel_chanspy_start_type" />
+ <enum name="ast_channel_chanspy_stop_type" />
+ <enum name="ast_channel_fax_type" />
+ <enum name="ast_channel_hangup_handler_type" />
+ <enum name="ast_channel_moh_start_type" />
+ <enum name="ast_channel_moh_stop_type" />
+ <enum name="ast_channel_monitor_start_type" />
+ <enum name="ast_channel_monitor_stop_type" />
+ <enum name="ast_channel_agent_login_type" />
+ <enum name="ast_channel_agent_logoff_type" />
+ <enum name="ast_channel_talking_start" />
+ <enum name="ast_channel_talking_stop" />
+ <enum name="ast_security_event_type" />
+ <enum name="ast_named_acl_change_type" />
+ <enum name="ast_local_bridge_type" />
+ <enum name="ast_local_optimization_begin_type" />
+ <enum name="ast_local_optimization_end_type" />
+ <enum name="stasis_subscription_change_type" />
+ <enum name="ast_multi_user_event_type" />
+ <enum name="stasis_cache_clear_type" />
+ <enum name="stasis_cache_update_type" />
+ <enum name="ast_network_change_type" />
+ <enum name="ast_system_registry_type" />
+ <enum name="ast_cc_available_type" />
+ <enum name="ast_cc_offertimerstart_type" />
+ <enum name="ast_cc_requested_type" />
+ <enum name="ast_cc_requestacknowledged_type" />
+ <enum name="ast_cc_callerstopmonitoring_type" />
+ <enum name="ast_cc_callerstartmonitoring_type" />
+ <enum name="ast_cc_callerrecalling_type" />
+ <enum name="ast_cc_recallcomplete_type" />
+ <enum name="ast_cc_failure_type" />
+ <enum name="ast_cc_monitorfailed_type" />
+ <enum name="ast_presence_state_message_type" />
+ <enum name="ast_rtp_rtcp_sent_type" />
+ <enum name="ast_rtp_rtcp_received_type" />
+ <enum name="ast_call_pickup_type" />
+ <enum name="aoc_s_type" />
+ <enum name="aoc_d_type" />
+ <enum name="aoc_e_type" />
+ <enum name="dahdichannel_type" />
+ <enum name="mcid_type" />
+ <enum name="session_timeout_type" />
+ <enum name="cdr_read_message_type" />
+ <enum name="cdr_write_message_type" />
+ <enum name="cdr_prop_write_message_type" />
+ <enum name="corosync_ping_message_type" />
+ <enum name="agi_exec_start_type" />
+ <enum name="agi_exec_end_type" />
+ <enum name="agi_async_start_type" />
+ <enum name="agi_async_exec_type" />
+ <enum name="agi_async_end_type" />
+ <enum name="queue_caller_join_type" />
+ <enum name="queue_caller_leave_type" />
+ <enum name="queue_caller_abandon_type" />
+ <enum name="queue_member_status_type" />
+ <enum name="queue_member_added_type" />
+ <enum name="queue_member_removed_type" />
+ <enum name="queue_member_pause_type" />
+ <enum name="queue_member_penalty_type" />
+ <enum name="queue_member_ringinuse_type" />
+ <enum name="queue_agent_called_type" />
+ <enum name="queue_agent_connect_type" />
+ <enum name="queue_agent_complete_type" />
+ <enum name="queue_agent_dump_type" />
+ <enum name="queue_agent_ringnoanswer_type" />
+ <enum name="meetme_join_type" />
+ <enum name="meetme_leave_type" />
+ <enum name="meetme_end_type" />
+ <enum name="meetme_mute_type" />
+ <enum name="meetme_talking_type" />
+ <enum name="meetme_talk_request_type" />
+ <enum name="appcdr_message_type" />
+ <enum name="forkcdr_message_type" />
+ <enum name="cdr_sync_message_type" />
+ </enumlist>
+ </description>
+ </configOption>
+ </configObject>
+ </configFile>
+ </configInfo>
***/
/*!
@@ -801,6 +931,10 @@ static void send_subscription_subscribe(struct stasis_topic *topic, struct stasi
/* This assumes that we have already unsubscribed */
ast_assert(stasis_subscription_is_subscribed(sub));
+ if (!stasis_subscription_change_type()) {
+ return;
+ }
+
change = subscription_change_alloc(topic, sub->uniqueid, "Subscribe");
if (!change) {
return;
@@ -826,6 +960,10 @@ static void send_subscription_unsubscribe(struct stasis_topic *topic,
/* This assumes that we have already unsubscribed */
ast_assert(!stasis_subscription_is_subscribed(sub));
+ if (!stasis_subscription_change_type()) {
+ return;
+ }
+
change = subscription_change_alloc(topic, sub->uniqueid, "Unsubscribe");
if (!change) {
return;
@@ -1066,6 +1204,10 @@ void ast_multi_object_blob_single_channel_publish(struct ast_channel *chan,
RAII_VAR(struct ast_channel_snapshot *, channel_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_multi_object_blob *, multi, NULL, ao2_cleanup);
+ if (!type) {
+ return;
+ }
+
multi = ast_multi_object_blob_create(blob);
if (!multi) {
return;
@@ -1215,6 +1357,113 @@ static struct ast_manager_event_blob *multi_user_event_to_ami(
ast_str_buffer(body));
}
+/*! \brief A structure to hold global configuration-related options */
+struct stasis_declined_config {
+ /*! The list of message types to decline */
+ struct ao2_container *declined;
+};
+
+
+struct stasis_config {
+ struct stasis_declined_config *declined_message_types;
+};
+
+/*! \brief An aco_type structure to link the "declined_message_types" category to the stasis_declined_config type */
+static struct aco_type declined_option = {
+ .type = ACO_GLOBAL,
+ .name = "declined_message_types",
+ .item_offset = offsetof(struct stasis_config, declined_message_types),
+ .category_match = ACO_WHITELIST,
+ .category = "^declined_message_types$",
+};
+
+struct aco_type *declined_options[] = ACO_TYPES(&declined_option);
+
+struct aco_file stasis_conf = {
+ .filename = "stasis.conf",
+ .types = ACO_TYPES(&declined_option),
+};
+
+/*! \brief A global object container that will contain the stasis_config that gets swapped out on reloads */
+static AO2_GLOBAL_OBJ_STATIC(globals);
+
+static void *stasis_config_alloc(void);
+
+/*! \brief Register information about the configs being processed by this module */
+CONFIG_INFO_CORE("stasis", cfg_info, globals, stasis_config_alloc,
+ .files = ACO_FILES(&stasis_conf),
+);
+
+static void stasis_declined_config_destructor(void *obj)
+{
+ struct stasis_declined_config *declined = obj;
+ ao2_cleanup(declined->declined);
+}
+
+static void stasis_config_destructor(void *obj)
+{
+ struct stasis_config *cfg = obj;
+ ao2_cleanup(cfg->declined_message_types);
+}
+
+static void *stasis_config_alloc(void)
+{
+ struct stasis_config *cfg;
+
+ if (!(cfg = ao2_alloc(sizeof(*cfg), stasis_config_destructor))) {
+ return NULL;
+ }
+
+ /* Allocate/initialize memory */
+ cfg->declined_message_types = ao2_alloc(sizeof(*cfg->declined_message_types), stasis_declined_config_destructor);
+ if (!cfg->declined_message_types) {
+ goto error;
+ }
+
+ cfg->declined_message_types->declined = ast_str_container_alloc(13);
+ if (!cfg->declined_message_types->declined) {
+ goto error;
+ }
+
+ return cfg;
+error:
+ ao2_ref(cfg, -1);
+ return NULL;
+}
+
+int stasis_message_type_declined(const char *name)
+{
+ RAII_VAR(struct stasis_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
+ char *name_in_declined;
+ int res;
+
+ if (!cfg || !cfg->declined_message_types) {
+ return 0;
+ }
+
+ name_in_declined = ao2_find(cfg->declined_message_types->declined, name, OBJ_SEARCH_KEY);
+ res = name_in_declined ? 1 : 0;
+ ao2_cleanup(name_in_declined);
+ if (res) {
+ ast_log(LOG_NOTICE, "Declining to allocate Stasis message type '%s' due to configuration\n", name);
+ }
+ return res;
+}
+
+static int declined_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+ struct stasis_declined_config *declined = obj;
+
+ if (ast_strlen_zero(var->value)) {
+ return 0;
+ }
+
+ if (ast_str_container_add(declined->declined, var->value)) {
+ return -1;
+ }
+
+ return 0;
+}
/*!
* @{ \brief Define multi user event message type(s).
@@ -1232,6 +1481,8 @@ static void stasis_cleanup(void)
{
STASIS_MESSAGE_TYPE_CLEANUP(stasis_subscription_change_type);
STASIS_MESSAGE_TYPE_CLEANUP(ast_multi_user_event_type);
+ aco_info_destroy(&cfg_info);
+ ao2_global_obj_release(globals);
}
int stasis_init(void)
@@ -1241,6 +1492,24 @@ int stasis_init(void)
/* Be sure the types are cleaned up after the message bus */
ast_register_cleanup(stasis_cleanup);
+ if (aco_info_init(&cfg_info)) {
+ return -1;
+ }
+
+ aco_option_register_custom(&cfg_info, "decline", ACO_EXACT, declined_options, "", declined_handler, 0);
+
+ if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
+ RAII_VAR(struct stasis_config *, stasis_cfg, stasis_config_alloc(), ao2_cleanup);
+
+ if (aco_set_defaults(&declined_option, "declined_message_types", stasis_cfg->declined_message_types)) {
+ ast_log(LOG_ERROR, "Failed to load stasis.conf and failed to initialize defaults.\n");
+ return -1;
+ }
+
+ ast_log(LOG_NOTICE, "Could not load stasis config; using defaults\n");
+ ao2_global_obj_replace_unref(globals, stasis_cfg);
+ }
+
cache_init = stasis_cache_init();
if (cache_init != 0) {
return -1;
diff --git a/main/stasis_bridges.c b/main/stasis_bridges.c
index c5df5f4f93..56f7605f75 100644
--- a/main/stasis_bridges.c
+++ b/main/stasis_bridges.c
@@ -267,6 +267,10 @@ void ast_bridge_publish_state(struct ast_bridge *bridge)
RAII_VAR(struct ast_bridge_snapshot *, snapshot, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_bridge_snapshot_type()) {
+ return;
+ }
+
ast_assert(bridge != NULL);
snapshot = ast_bridge_snapshot_create(bridge);
@@ -358,6 +362,10 @@ void ast_bridge_publish_merge(struct ast_bridge *to, struct ast_bridge *from)
RAII_VAR(struct ast_bridge_merge_message *, merge_msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_bridge_merge_message_type()) {
+ return;
+ }
+
ast_assert(to != NULL);
ast_assert(from != NULL);
@@ -394,6 +402,10 @@ struct stasis_message *ast_bridge_blob_create(
RAII_VAR(struct ast_bridge_blob *, obj, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!message_type) {
+ return NULL;
+ }
+
obj = ao2_alloc(sizeof(*obj), bridge_blob_dtor);
if (!obj) {
return NULL;
@@ -958,6 +970,10 @@ void ast_bridge_publish_attended_transfer_fail(int is_external, enum ast_transfe
RAII_VAR(struct ast_attended_transfer_message *, transfer_msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_attended_transfer_type()) {
+ return;
+ }
+
transfer_msg = attended_transfer_message_create(is_external, result, transferee, target);
if (!transfer_msg) {
return;
@@ -980,6 +996,10 @@ void ast_bridge_publish_attended_transfer_bridge_merge(int is_external, enum ast
RAII_VAR(struct ast_attended_transfer_message *, transfer_msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_attended_transfer_type()) {
+ return;
+ }
+
transfer_msg = attended_transfer_message_create(is_external, result, transferee, target);
if (!transfer_msg) {
return;
@@ -1004,6 +1024,10 @@ void ast_bridge_publish_attended_transfer_threeway(int is_external, enum ast_tra
RAII_VAR(struct ast_attended_transfer_message *, transfer_msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_attended_transfer_type()) {
+ return;
+ }
+
transfer_msg = attended_transfer_message_create(is_external, result, transferee, target);
if (!transfer_msg) {
return;
@@ -1037,6 +1061,10 @@ void ast_bridge_publish_attended_transfer_app(int is_external, enum ast_transfer
RAII_VAR(struct ast_attended_transfer_message *, transfer_msg, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_attended_transfer_type()) {
+ return;
+ }
+
transfer_msg = attended_transfer_message_create(is_external, result, transferee, target);
if (!transfer_msg) {
return;
@@ -1061,6 +1089,10 @@ void ast_bridge_publish_attended_transfer_link(int is_external, enum ast_transfe
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
int i;
+ if (!ast_attended_transfer_type()) {
+ return;
+ }
+
transfer_msg = attended_transfer_message_create(is_external, result, transferee, target);
if (!transfer_msg) {
return;
diff --git a/main/stasis_cache.c b/main/stasis_cache.c
index 8b4304e5f4..c492307d63 100644
--- a/main/stasis_cache.c
+++ b/main/stasis_cache.c
@@ -185,10 +185,13 @@ static struct stasis_cache_entry *cache_entry_create(struct stasis_message_type
struct stasis_cache_entry *entry;
int is_remote;
- ast_assert(type != NULL);
ast_assert(id != NULL);
ast_assert(snapshot != NULL);
+ if (!type) {
+ return NULL;
+ }
+
entry = ao2_alloc_options(sizeof(*entry), cache_entry_dtor,
AO2_ALLOC_OPT_LOCK_NOLOCK);
if (!entry) {
@@ -550,9 +553,12 @@ struct ao2_container *stasis_cache_get_all(struct stasis_cache *cache, struct st
ast_assert(cache != NULL);
ast_assert(cache->entries != NULL);
- ast_assert(type != NULL);
ast_assert(id != NULL);
+ if (!type) {
+ return NULL;
+ }
+
found = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL, NULL);
if (!found) {
return NULL;
@@ -619,9 +625,12 @@ struct stasis_message *stasis_cache_get_by_eid(struct stasis_cache *cache, struc
ast_assert(cache != NULL);
ast_assert(cache->entries != NULL);
- ast_assert(type != NULL);
ast_assert(id != NULL);
+ if (!type) {
+ return NULL;
+ }
+
ao2_rdlock(cache->entries);
cached_entry = cache_find(cache->entries, type, id);
@@ -752,6 +761,10 @@ static struct stasis_message *update_create(struct stasis_message *old_snapshot,
ast_assert(old_snapshot != NULL || new_snapshot != NULL);
+ if (!stasis_cache_update_type()) {
+ return NULL;
+ }
+
update = ao2_alloc_options(sizeof(*update), stasis_cache_update_dtor,
AO2_ALLOC_OPT_LOCK_NOLOCK);
if (!update) {
diff --git a/main/stasis_channels.c b/main/stasis_channels.c
index a1e7ad2094..d7fbc98ab9 100644
--- a/main/stasis_channels.c
+++ b/main/stasis_channels.c
@@ -304,6 +304,10 @@ void ast_channel_publish_dial_forward(struct ast_channel *caller, struct ast_cha
RAII_VAR(struct ast_channel_snapshot *, peer_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, forwarded_snapshot, NULL, ao2_cleanup);
+ if (!ast_channel_dial_type()) {
+ return;
+ }
+
ast_assert(peer != NULL);
blob = ast_json_pack("{s: s, s: s, s: s}",
"dialstatus", S_OR(dialstatus, ""),
@@ -405,9 +409,15 @@ struct stasis_message *ast_channel_blob_create_from_cache(const char *channel_id
struct ast_json *blob)
{
RAII_VAR(struct ast_channel_snapshot *, snapshot,
- ast_channel_snapshot_get_latest(channel_id),
+ NULL,
ao2_cleanup);
+ if (!type) {
+ return NULL;
+ }
+
+ snapshot = ast_channel_snapshot_get_latest(channel_id);
+
return create_channel_blob_message(snapshot, type, blob);
}
@@ -416,6 +426,10 @@ struct stasis_message *ast_channel_blob_create(struct ast_channel *chan,
{
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
+ if (!type) {
+ return NULL;
+ }
+
if (chan) {
snapshot = ast_channel_snapshot_create(chan);
}
@@ -644,6 +658,10 @@ void ast_channel_publish_snapshot(struct ast_channel *chan)
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+ if (!ast_channel_snapshot_type()) {
+ return;
+ }
+
if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_SNAPSHOT_STAGE)) {
return;
}
@@ -793,6 +811,10 @@ void ast_publish_channel_state(struct ast_channel *chan)
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+ if (!ast_channel_snapshot_type()) {
+ return;
+ }
+
ast_assert(chan != NULL);
if (!chan) {
return;
diff --git a/main/stasis_endpoints.c b/main/stasis_endpoints.c
index e3f5a3f15e..7374681772 100644
--- a/main/stasis_endpoints.c
+++ b/main/stasis_endpoints.c
@@ -150,6 +150,9 @@ struct stasis_message *ast_endpoint_blob_create(struct ast_endpoint *endpoint,
RAII_VAR(struct ast_endpoint_blob *, obj, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!type) {
+ return NULL;
+ }
if (!blob) {
blob = ast_json_null();
}
diff --git a/main/stasis_message.c b/main/stasis_message.c
index 70c4085390..c797cdfa05 100644
--- a/main/stasis_message.c
+++ b/main/stasis_message.c
@@ -50,14 +50,20 @@ static void message_type_dtor(void *obj)
type->name = NULL;
}
-struct stasis_message_type *stasis_message_type_create(const char *name,
- struct stasis_message_vtable *vtable)
+int stasis_message_type_create(const char *name,
+ struct stasis_message_vtable *vtable,
+ struct stasis_message_type **result)
{
struct stasis_message_type *type;
+ /* Check for declination */
+ if (name && stasis_message_type_declined(name)) {
+ return STASIS_MESSAGE_TYPE_DECLINED;
+ }
+
type = ao2_t_alloc(sizeof(*type), message_type_dtor, name);
if (!type) {
- return NULL;
+ return STASIS_MESSAGE_TYPE_ERROR;
}
if (!vtable) {
/* Null object pattern, FTW! */
@@ -67,11 +73,12 @@ struct stasis_message_type *stasis_message_type_create(const char *name,
type->name = ast_strdup(name);
if (!type->name) {
ao2_cleanup(type);
- return NULL;
+ return STASIS_MESSAGE_TYPE_ERROR;
}
type->vtable = vtable;
+ *result = type;
- return type;
+ return STASIS_MESSAGE_TYPE_SUCCESS;
}
const char *stasis_message_type_name(const struct stasis_message_type *type)
diff --git a/main/stasis_system.c b/main/stasis_system.c
index 2428a96c07..e232b8e8a3 100644
--- a/main/stasis_system.c
+++ b/main/stasis_system.c
@@ -122,6 +122,10 @@ void ast_system_publish_registry(const char *channeltype, const char *username,
RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+ if (!ast_system_registry_type()) {
+ return;
+ }
+
registry = ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: s}",
"type", "registry",
"channeltype", channeltype,
diff --git a/main/test.c b/main/test.c
index fe8fe15320..c144d3eb40 100644
--- a/main/test.c
+++ b/main/test.c
@@ -1015,15 +1015,22 @@ struct ast_json *ast_test_suite_get_blob(struct ast_test_suite_message_payload *
void __ast_test_suite_event_notify(const char *file, const char *func, int line, const char *state, const char *fmt, ...)
{
RAII_VAR(struct ast_test_suite_message_payload *, payload,
- ao2_alloc(sizeof(*payload), test_suite_message_payload_dtor),
+ NULL,
ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
- RAII_VAR(struct ast_str *, buf, ast_str_create(128), ast_free);
+ RAII_VAR(struct ast_str *, buf, NULL, ast_free);
va_list ap;
+ if (!ast_test_suite_message_type()) {
+ return;
+ }
+
+ buf = ast_str_create(128);
if (!buf) {
return;
}
+
+ payload = ao2_alloc(sizeof(*payload), test_suite_message_payload_dtor);
if (!payload) {
return;
}
diff --git a/pbx/pbx_realtime.c b/pbx/pbx_realtime.c
index 641e30d95e..de62851e0f 100644
--- a/pbx/pbx_realtime.c
+++ b/pbx/pbx_realtime.c
@@ -333,9 +333,11 @@ static int realtime_exec(struct ast_channel *chan, const char *context, const ch
term_color(tmp1, app, COLOR_BRCYAN, 0, sizeof(tmp1)),
term_color(tmp2, ast_channel_name(chan), COLOR_BRMAGENTA, 0, sizeof(tmp2)),
term_color(tmp3, S_OR(appdata, ""), COLOR_BRMAGENTA, 0, sizeof(tmp3)));
- ast_channel_lock(chan);
- snapshot = ast_channel_snapshot_create(chan);
- ast_channel_unlock(chan);
+ if (ast_channel_snapshot_type()) {
+ ast_channel_lock(chan);
+ snapshot = ast_channel_snapshot_create(chan);
+ ast_channel_unlock(chan);
+ }
if (snapshot) {
/* pbx_exec sets application name and data, but we don't want to log
* every exec. Just update the snapshot here instead.
diff --git a/res/parking/parking_manager.c b/res/parking/parking_manager.c
index 20f8c4e1c8..73b5ff4954 100644
--- a/res/parking/parking_manager.c
+++ b/res/parking/parking_manager.c
@@ -579,6 +579,10 @@ void publish_parked_call_failure(struct ast_channel *parkee)
RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_parked_call_type()) {
+ return;
+ }
+
payload = parked_call_payload_from_failure(parkee);
if (!payload) {
return;
@@ -597,6 +601,10 @@ void publish_parked_call(struct parked_user *pu, enum ast_parked_call_event_type
RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
+ if (!ast_parked_call_type()) {
+ return;
+ }
+
payload = parked_call_payload_from_parked_user(pu, event_type);
if (!payload) {
return;
diff --git a/res/res_corosync.c b/res/res_corosync.c
index 1df9ed8411..58290c7ccf 100644
--- a/res/res_corosync.c
+++ b/res/res_corosync.c
@@ -117,6 +117,10 @@ static void publish_corosync_ping_to_stasis(struct ast_event *event)
ast_assert(ast_event_get_type(event) == AST_EVENT_PING);
ast_assert(event != NULL);
+ if (!corosync_ping_message_type()) {
+ return;
+ }
+
payload = ao2_t_alloc(sizeof(*payload), corosync_ping_payload_dtor, "Create ping payload");
if (!payload) {
return;
diff --git a/res/res_stasis.c b/res/res_stasis.c
index 7d5373153f..7b5d16f1ab 100644
--- a/res/res_stasis.c
+++ b/res/res_stasis.c
@@ -1357,6 +1357,10 @@ enum stasis_app_user_event_res stasis_app_user_event(const char *app_name,
return STASIS_APP_USER_APP_NOT_FOUND;
}
+ if (!ast_multi_user_event_type()) {
+ return res;
+ }
+
blob = json_variables;
if (!blob) {
blob = ast_json_pack("{}");
diff --git a/res/res_stasis_snoop.c b/res/res_stasis_snoop.c
index af31046fca..72f8519230 100644
--- a/res/res_stasis_snoop.c
+++ b/res/res_stasis_snoop.c
@@ -111,9 +111,10 @@ static void publish_chanspy_message(struct stasis_app_snoop *snoop, int start)
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, snoop_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, spyee_snapshot, NULL, ao2_cleanup);
+ struct stasis_message_type *type = start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type();
blob = ast_json_null();
- if (!blob) {
+ if (!blob || !type) {
return;
}
@@ -133,9 +134,7 @@ static void publish_chanspy_message(struct stasis_app_snoop *snoop, int start)
ast_multi_channel_blob_add_channel(payload, "spyee_channel", spyee_snapshot);
}
- message = stasis_message_create(
- start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type(),
- payload);
+ message = stasis_message_create(type, payload);
if (!message) {
return;
}
diff --git a/res/res_stasis_test.c b/res/res_stasis_test.c
index cec8e20c63..9860b0ebd7 100644
--- a/res/res_stasis_test.c
+++ b/res/res_stasis_test.c
@@ -251,6 +251,10 @@ struct stasis_message *stasis_test_message_create(void)
{
RAII_VAR(void *, data, NULL, ao2_cleanup);
+ if (!stasis_test_message_type()) {
+ return NULL;
+ }
+
/* We just need the unique pointer; don't care what's in it */
data = ao2_alloc(1, NULL);
if (!data) {
diff --git a/res/res_stun_monitor.c b/res/res_stun_monitor.c
index 1bda4b9ff9..4cdc2fdca7 100644
--- a/res/res_stun_monitor.c
+++ b/res/res_stun_monitor.c
@@ -157,10 +157,15 @@ static int stun_monitor_request(const void *blarg)
if (args.external_addr_known) {
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
- RAII_VAR(struct ast_json *, json_object, ast_json_object_create(), ast_json_unref);
+ RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
+
+ if (!ast_network_change_type()) {
+ goto publish_failure;
+ }
/* This json_object doesn't actually contain anything yet. We have to reference something
* for stasis, and this is useful for if we want to ever add data for any reason. */
+ json_object = ast_json_object_create();
if (!json_object) {
goto publish_failure;
}
diff --git a/tests/test_stasis.c b/tests/test_stasis.c
index 4c042c05be..ba82e83adb 100644
--- a/tests/test_stasis.c
+++ b/tests/test_stasis.c
@@ -84,8 +84,8 @@ AST_TEST_DEFINE(message_type)
break;
}
- ast_test_validate(test, NULL == stasis_message_type_create(NULL, NULL));
- uut = stasis_message_type_create("SomeMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create(NULL, NULL, NULL) == STASIS_MESSAGE_TYPE_ERROR);
+ ast_test_validate(test, stasis_message_type_create("SomeMessage", NULL, &uut) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, 0 == strcmp(stasis_message_type_name(uut), "SomeMessage"));
return AST_TEST_PASS;
@@ -116,7 +116,7 @@ AST_TEST_DEFINE(message)
memset(&foreign_eid, 0xFF, sizeof(foreign_eid));
- type = stasis_message_type_create("SomeMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("SomeMessage", NULL, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL == stasis_message_create_full(NULL, NULL, NULL));
ast_test_validate(test, NULL == stasis_message_create_full(type, NULL, NULL));
@@ -395,7 +395,7 @@ AST_TEST_DEFINE(publish)
test_data = ao2_alloc(1, NULL);
ast_test_validate(test, NULL != test_data);
- test_message_type = stasis_message_type_create("TestMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage", NULL, &test_message_type) == STASIS_MESSAGE_TYPE_SUCCESS);
test_message = stasis_message_create(test_message_type, test_data);
stasis_publish(topic, test_message);
@@ -442,7 +442,7 @@ AST_TEST_DEFINE(publish_sync)
test_data = ao2_alloc(1, NULL);
ast_test_validate(test, NULL != test_data);
- test_message_type = stasis_message_type_create("TestMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage", NULL, &test_message_type) == STASIS_MESSAGE_TYPE_SUCCESS);
test_message = stasis_message_create(test_message_type, test_data);
stasis_publish_sync(uut, test_message);
@@ -490,7 +490,7 @@ AST_TEST_DEFINE(unsubscribe_stops_messages)
test_data = ao2_alloc(1, NULL);
ast_test_validate(test, NULL != test_data);
- test_message_type = stasis_message_type_create("TestMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage", NULL, &test_message_type) == STASIS_MESSAGE_TYPE_SUCCESS);
test_message = stasis_message_create(test_message_type, test_data);
stasis_publish(topic, test_message);
@@ -554,7 +554,7 @@ AST_TEST_DEFINE(forward)
test_data = ao2_alloc(1, NULL);
ast_test_validate(test, NULL != test_data);
- test_message_type = stasis_message_type_create("TestMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage", NULL, &test_message_type) == STASIS_MESSAGE_TYPE_SUCCESS);
test_message = stasis_message_create(test_message_type, test_data);
stasis_publish(topic, test_message);
@@ -604,7 +604,7 @@ AST_TEST_DEFINE(interleaving)
break;
}
- test_message_type = stasis_message_type_create("test", NULL);
+ ast_test_validate(test, stasis_message_type_create("test", NULL, &test_message_type) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type);
test_data = ao2_alloc(1, NULL);
@@ -796,7 +796,7 @@ AST_TEST_DEFINE(cache_filter)
break;
}
- non_cache_type = stasis_message_type_create("NonCacheable", NULL);
+ ast_test_validate(test, stasis_message_type_create("NonCacheable", NULL, &non_cache_type) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != non_cache_type);
topic = stasis_topic_create("SomeTopic");
ast_test_validate(test, NULL != topic);
@@ -847,7 +847,7 @@ AST_TEST_DEFINE(cache)
break;
}
- cache_type = stasis_message_type_create("Cacheable", NULL);
+ ast_test_validate(test, stasis_message_type_create("Cacheable", NULL, &cache_type) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != cache_type);
topic = stasis_topic_create("SomeTopic");
ast_test_validate(test, NULL != topic);
@@ -948,7 +948,7 @@ AST_TEST_DEFINE(cache_dump)
break;
}
- cache_type = stasis_message_type_create("Cacheable", NULL);
+ ast_test_validate(test, stasis_message_type_create("Cacheable", NULL, &cache_type) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != cache_type);
topic = stasis_topic_create("SomeTopic");
ast_test_validate(test, NULL != topic);
@@ -1071,7 +1071,7 @@ AST_TEST_DEFINE(cache_eid_aggregate)
memset(&foreign_eid1, 0xAA, sizeof(foreign_eid1));
memset(&foreign_eid2, 0xBB, sizeof(foreign_eid2));
- cache_type = stasis_message_type_create("Cacheable", NULL);
+ ast_test_validate(test, stasis_message_type_create("Cacheable", NULL, &cache_type) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != cache_type);
topic = stasis_topic_create("SomeTopic");
@@ -1331,11 +1331,11 @@ AST_TEST_DEFINE(router)
consumer3 = consumer_create(1);
ast_test_validate(test, NULL != consumer3);
- test_message_type1 = stasis_message_type_create("TestMessage1", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage1", NULL, &test_message_type1) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type1);
- test_message_type2 = stasis_message_type_create("TestMessage2", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage2", NULL, &test_message_type2) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type2);
- test_message_type3 = stasis_message_type_create("TestMessage3", NULL);
+ ast_test_validate(test, stasis_message_type_create("TestMessage3", NULL, &test_message_type3) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type3);
uut = stasis_message_router_create(topic);
@@ -1448,11 +1448,11 @@ AST_TEST_DEFINE(router_cache_updates)
consumer3 = consumer_create(1);
ast_test_validate(test, NULL != consumer3);
- test_message_type1 = stasis_message_type_create("Cache1", NULL);
+ ast_test_validate(test, stasis_message_type_create("Cache1", NULL, &test_message_type1) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type1);
- test_message_type2 = stasis_message_type_create("Cache2", NULL);
+ ast_test_validate(test, stasis_message_type_create("Cache2", NULL, &test_message_type2) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type2);
- test_message_type3 = stasis_message_type_create("NonCache", NULL);
+ ast_test_validate(test, stasis_message_type_create("NonCache", NULL, &test_message_type3) == STASIS_MESSAGE_TYPE_SUCCESS);
ast_test_validate(test, NULL != test_message_type3);
uut = stasis_message_router_create(
@@ -1535,7 +1535,7 @@ AST_TEST_DEFINE(no_to_json)
ast_test_validate(test, NULL == actual);
/* Test message with NULL to_json function */
- type = stasis_message_type_create("SomeMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("SomeMessage", NULL, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
data = ao2_alloc(strlen(expected) + 1, NULL);
strcpy(data, expected);
@@ -1568,7 +1568,7 @@ AST_TEST_DEFINE(to_json)
break;
}
- type = stasis_message_type_create("SomeMessage", &fake_vtable);
+ ast_test_validate(test, stasis_message_type_create("SomeMessage", &fake_vtable, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
data = ao2_alloc(strlen(expected_text) + 1, NULL);
strcpy(data, expected_text);
@@ -1606,7 +1606,7 @@ AST_TEST_DEFINE(no_to_ami)
ast_test_validate(test, NULL == actual);
/* Test message with NULL to_ami function */
- type = stasis_message_type_create("SomeMessage", NULL);
+ ast_test_validate(test, stasis_message_type_create("SomeMessage", NULL, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
data = ao2_alloc(strlen(expected) + 1, NULL);
strcpy(data, expected);
@@ -1639,7 +1639,7 @@ AST_TEST_DEFINE(to_ami)
break;
}
- type = stasis_message_type_create("SomeMessage", &fake_vtable);
+ ast_test_validate(test, stasis_message_type_create("SomeMessage", &fake_vtable, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
data = ao2_alloc(strlen(expected_text) + 1, NULL);
strcpy(data, expected_text);
diff --git a/tests/test_stasis_channels.c b/tests/test_stasis_channels.c
index 89240130ce..4c4bc665e2 100644
--- a/tests/test_stasis_channels.c
+++ b/tests/test_stasis_channels.c
@@ -71,7 +71,7 @@ AST_TEST_DEFINE(channel_blob_create)
break;
}
- type = stasis_message_type_create("test-type", NULL);
+ ast_test_validate(test, stasis_message_type_create("test-type", NULL, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
chan = ast_channel_alloc(0, AST_STATE_DOWN, "100", "Alice", "100", "100", "default", NULL, NULL, 0, "TEST/Alice");
ast_channel_unlock(chan);
json = ast_json_pack("{s: s}",
@@ -126,7 +126,7 @@ AST_TEST_DEFINE(null_blob)
break;
}
- type = stasis_message_type_create("test-type", NULL);
+ ast_test_validate(test, stasis_message_type_create("test-type", NULL, &type) == STASIS_MESSAGE_TYPE_SUCCESS);
chan = ast_channel_alloc(0, AST_STATE_DOWN, "100", "Alice", "100", "100", "default", NULL, NULL, 0, "TEST/Alice");
ast_channel_unlock(chan);
json = ast_json_pack("{s: s}",
--
GitLab