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;
}
}
}
- 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;
}
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;
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;
}
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;
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;
}
--- /dev/null
+[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
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) {
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;
}
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);
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;
}
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;
}
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.
*
*
* \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
*/
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.
*
#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; \
})
/*!
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;
ast_assert(blob != NULL);
+ if (!message_type) {
+ return NULL;
+ }
+
obj = ao2_alloc(sizeof(*obj), mwi_blob_dtor);
if (!obj) {
return NULL;
{
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);
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);
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
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)) {
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);
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);
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) {
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}",
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;
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);
ast_assert(endpoint != NULL);
ast_assert(endpoint->topics != NULL);
+ if (!ast_endpoint_snapshot_type()) {
+ return;
+ }
+
snapshot = ast_endpoint_snapshot_create(endpoint);
if (!snapshot) {
return;
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;
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, "|"));
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"),
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;
}
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;
}
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;
}
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;
}
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;
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;
}
#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">
</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>
***/
/*!
/* 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;
/* 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;
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;
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).
{
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)
/* 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;
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);
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);
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;
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;
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;
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;
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;
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;
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) {
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;
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);
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) {
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, ""),
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);
}
{
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
+ if (!type) {
+ return NULL;
+ }
+
if (chan) {
snapshot = ast_channel_snapshot_create(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;
}
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;
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();
}
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! */
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)
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,
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;
}
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.
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;
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;
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;
return STASIS_APP_USER_APP_NOT_FOUND;
}
+ if (!ast_multi_user_event_type()) {
+ return res;
+ }
+
blob = json_variables;
if (!blob) {
blob = ast_json_pack("{}");
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;
}
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;
}
{
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) {
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;
}
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;
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));
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);
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);
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);
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);
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);
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);
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);
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);
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");
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);
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(
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);
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);
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);
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);
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}",
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}",
projects / thirdparty / asterisk.git / commitdiff
