static void mwi_update_cb(void *data, struct stasis_subscription *sub,
struct stasis_message *message)
{
struct ast_mwi_state *mwi_state;
RAII_VAR(struct ast_str *, channel_event_string, NULL, ast_free);
if (ast_mwi_state_type() != stasis_message_type(message)) {
return;
}
mwi_state = stasis_message_data(message);
if (!mwi_state) {
return;
}
if (mwi_state->snapshot) {
channel_event_string = ast_manager_build_channel_state_string(mwi_state->snapshot);
}
/*** DOCUMENTATION
<managerEventInstance>
<synopsis>Raised when the state of messages in a voicemail mailbox
has changed or when a channel has finished interacting with a
mailbox.</synopsis>
<syntax>
<channel_snapshot/>
<parameter name="Mailbox">
<para>The mailbox with the new message, specified as <literal>mailbox</literal>@<literal>context</literal></para>
</parameter>
<parameter name="Waiting">
<para>Whether or not the mailbox has messages waiting for it.</para>
</parameter>
<parameter name="New">
<para>The number of new messages.</para>
</parameter>
<parameter name="Old">
<para>The number of old messages.</para>
</parameter>
</syntax>
<description>
<note><para>The Channel related parameters are only present if a
channel was involved in the manipulation of a mailbox. If no
channel is involved, the parameters are not included with the
event.</para>
</note>
</description>
</managerEventInstance>
***/
manager_event(EVENT_FLAG_CALL, "MessageWaiting",
"%s"
"Mailbox: %s\r\n"
"Waiting: %d\r\n"
"New: %d\r\n"
"Old: %d\r\n",
AS_OR(channel_event_string, ""),
mwi_state->uniqueid,
ast_app_has_voicemail(mwi_state->uniqueid, NULL),
mwi_state->new_msgs,
mwi_state->old_msgs);
}
static int send_bridge_info_item_cb(void *obj, void *arg, void *data, int flags)
{
char *uniqueid = obj;
struct mansession *s = arg;
char *id_text = data;
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
struct ast_channel_snapshot *snapshot;
RAII_VAR(struct ast_str *, channel_text, NULL, ast_free);
msg = stasis_cache_get(ast_channel_cache(),
ast_channel_snapshot_type(), uniqueid);
if (!msg) {
return 0;
}
snapshot = stasis_message_data(msg);
if (snapshot->tech_properties & AST_CHAN_TP_INTERNAL) {
return 0;
}
channel_text = ast_manager_build_channel_state_string(snapshot);
if (!channel_text) {
return 0;
}
astman_append(s,
"Event: BridgeInfoChannel\r\n"
"%s"
"%s"
"\r\n",
ast_str_buffer(channel_text),
id_text);
return 0;
}
static void channel_enter_cb(void *data, struct stasis_subscription *sub,
struct stasis_message *message)
{
static const char *swap_name = "SwapUniqueid: ";
struct ast_bridge_blob *blob = stasis_message_data(message);
RAII_VAR(struct ast_str *, bridge_text, NULL, ast_free);
RAII_VAR(struct ast_str *, channel_text, NULL, ast_free);
const char *swap_id;
bridge_text = ast_manager_build_bridge_state_string(blob->bridge);
channel_text = ast_manager_build_channel_state_string(blob->channel);
if (!bridge_text || !channel_text) {
return;
}
swap_id = ast_json_string_get(ast_json_object_get(blob->blob, "swap"));
manager_event(EVENT_FLAG_CALL, "BridgeEnter",
"%s"
"%s"
"%s%s%s",
ast_str_buffer(bridge_text),
ast_str_buffer(channel_text),
swap_id ? swap_name : "",
S_OR(swap_id, ""),
swap_id ? "\r\n" : "");
}
/*! \brief Generic MWI event callback used for one-off events from voicemail modules */
static void mwi_app_event_cb(void *data, struct stasis_subscription *sub,
struct stasis_message *message)
{
struct ast_mwi_blob *payload = stasis_message_data(message);
RAII_VAR(struct ast_str *, channel_event_string, NULL, ast_free);
RAII_VAR(struct ast_str *, event_buffer, NULL, ast_free);
struct ast_json *event_json = ast_json_object_get(payload->blob, "Event");
if (!event_json) {
return;
}
if (payload->mwi_state && payload->mwi_state->snapshot) {
channel_event_string = ast_manager_build_channel_state_string(payload->mwi_state->snapshot);
}
event_buffer = ast_manager_str_from_json_object(payload->blob, exclude_event_cb);
if (!event_buffer) {
ast_log(AST_LOG_WARNING, "Failed to create payload for event %s\n", ast_json_string_get(event_json));
return;
}
manager_event(EVENT_FLAG_CALL, ast_json_string_get(event_json),
"Mailbox: %s\r\n"
"%s"
"%s",
payload->mwi_state ? payload->mwi_state->uniqueid : "Unknown",
ast_str_buffer(event_buffer),
channel_event_string ? ast_str_buffer(channel_event_string) : "");
}
static struct ast_manager_event_blob *varset_to_ami(struct stasis_message *msg)
{
RAII_VAR(struct ast_str *, channel_event_string, NULL, ast_free);
struct ast_channel_blob *obj = stasis_message_data(msg);
const char *variable =
ast_json_string_get(ast_json_object_get(obj->blob, "variable"));
const char *value =
ast_json_string_get(ast_json_object_get(obj->blob, "value"));
if (obj->snapshot) {
channel_event_string =
ast_manager_build_channel_state_string(obj->snapshot);
} else {
channel_event_string = ast_str_create(35);
ast_str_set(&channel_event_string, 0,
"Channel: none\r\n"
"Uniqueid: none\r\n");
}
if (!channel_event_string) {
return NULL;
}
return ast_manager_event_blob_create(EVENT_FLAG_DIALPLAN, "VarSet",
"%s"
"Variable: %s\r\n"
"Value: %s\r\n",
ast_str_buffer(channel_event_string), variable, value);
}
static void confbridge_publish_manager_event(
struct stasis_message *message,
const char *event,
struct ast_str *extra_text)
{
struct ast_bridge_blob *blob = stasis_message_data(message);
const char *conference_name;
RAII_VAR(struct ast_str *, bridge_text, NULL, ast_free);
RAII_VAR(struct ast_str *, channel_text, NULL, ast_free);
ast_assert(blob != NULL);
ast_assert(event != NULL);
bridge_text = ast_manager_build_bridge_state_string(blob->bridge);
if (!bridge_text) {
return;
}
conference_name = ast_json_string_get(ast_json_object_get(blob->blob, "conference"));
ast_assert(conference_name != NULL);
if (blob->channel) {
channel_text = ast_manager_build_channel_state_string(blob->channel);
}
manager_event(EVENT_FLAG_CALL, event,
"Conference: %s\r\n"
"%s"
"%s"
"%s",
conference_name,
ast_str_buffer(bridge_text),
S_COR(channel_text, ast_str_buffer(channel_text), ""),
S_COR(extra_text, ast_str_buffer(extra_text), ""));
}
static struct ast_manager_event_blob *call_pickup_to_ami(struct stasis_message *message)
{
struct ast_multi_channel_blob *contents = stasis_message_data(message);
struct ast_channel_snapshot *chan;
struct ast_channel_snapshot *target;
struct ast_manager_event_blob *res;
RAII_VAR(struct ast_str *, channel_str, NULL, ast_free);
RAII_VAR(struct ast_str *, target_str, NULL, ast_free);
chan = ast_multi_channel_blob_get_channel(contents, "channel");
target = ast_multi_channel_blob_get_channel(contents, "target");
ast_assert(chan != NULL && target != NULL);
if (!(channel_str = ast_manager_build_channel_state_string(chan))) {
return NULL;
}
if (!(target_str = ast_manager_build_channel_state_string_prefix(target, "Target"))) {
return NULL;
}
res = ast_manager_event_blob_create(EVENT_FLAG_CALL, "Pickup",
"%s"
"%s",
ast_str_buffer(channel_str),
ast_str_buffer(target_str));
return res;
}
static struct ast_manager_event_blob *agent_login_to_ami(struct stasis_message *msg)
{
RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
struct ast_channel_blob *obj = stasis_message_data(msg);
const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent"));
channel_string = ast_manager_build_channel_state_string(obj->snapshot);
if (!channel_string) {
return NULL;
}
return ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogin",
"%s"
"Agent: %s\r\n",
ast_str_buffer(channel_string), agent);
}
static void channel_leave_cb(void *data, struct stasis_subscription *sub,
struct stasis_message *message)
{
struct ast_bridge_blob *blob = stasis_message_data(message);
RAII_VAR(struct ast_str *, bridge_text, NULL, ast_free);
RAII_VAR(struct ast_str *, channel_text, NULL, ast_free);
bridge_text = ast_manager_build_bridge_state_string(blob->bridge);
channel_text = ast_manager_build_channel_state_string(blob->channel);
if (!bridge_text || !channel_text) {
return;
}
manager_event(EVENT_FLAG_CALL, "BridgeLeave",
"%s"
"%s",
ast_str_buffer(bridge_text),
ast_str_buffer(channel_text));
}
