static struct ast_json *channel_callerid(
struct ast_channel_snapshot *old_snapshot,
struct ast_channel_snapshot *new_snapshot,
const struct timeval *tv)
{
struct ast_json *json_channel;
/* No NewCallerid event on first channel snapshot */
if (!old_snapshot) {
return NULL;
}
if (ast_channel_snapshot_caller_id_equal(old_snapshot, new_snapshot)) {
return NULL;
}
json_channel = ast_channel_snapshot_to_json(new_snapshot, stasis_app_get_sanitizer());
if (!json_channel) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: i, s: s, s: o}",
"type", "ChannelCallerId",
"timestamp", ast_json_timeval(*tv, NULL),
"caller_presentation", new_snapshot->caller->pres,
"caller_presentation_txt", ast_describe_caller_presentation(
new_snapshot->caller->pres),
"channel", json_channel);
}
static struct ast_json *channel_connected_line(
struct ast_channel_snapshot *old_snapshot,
struct ast_channel_snapshot *new_snapshot,
const struct timeval *tv)
{
struct ast_json *json_channel;
/* No ChannelConnectedLine event on first channel snapshot */
if (!old_snapshot) {
return NULL;
}
if (ast_channel_snapshot_connected_line_equal(old_snapshot, new_snapshot)) {
return NULL;
}
json_channel = ast_channel_snapshot_to_json(new_snapshot, stasis_app_get_sanitizer());
if (!json_channel) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: o}",
"type", "ChannelConnectedLine",
"timestamp", ast_json_timeval(*tv, NULL),
"channel", json_channel);
}
static struct ast_json *peerstatus_to_json(struct stasis_message *msg, const struct stasis_message_sanitizer *sanitize)
{
struct ast_endpoint_blob *obj = stasis_message_data(msg);
struct ast_json *json_endpoint;
struct ast_json *json_peer;
struct ast_json *json_final;
const struct timeval *tv = stasis_message_timestamp(msg);
json_endpoint = ast_endpoint_snapshot_to_json(obj->snapshot, NULL);
if (!json_endpoint) {
return NULL;
}
json_peer = ast_json_object_create();
if (!json_peer) {
ast_json_unref(json_endpoint);
return NULL;
}
/* Copy all fields from the blob */
ast_json_object_update(json_peer, obj->blob);
json_final = ast_json_pack("{s: s, s: o, s: o, s: o }",
"type", "PeerStatusChange",
"timestamp", ast_json_timeval(*tv, NULL),
"endpoint", json_endpoint,
"peer", json_peer);
if (!json_final) {
ast_json_unref(json_endpoint);
ast_json_unref(json_peer);
}
return json_final;
}
static struct ast_json *channel_dialplan(
struct ast_channel_snapshot *old_snapshot,
struct ast_channel_snapshot *new_snapshot,
const struct timeval *tv)
{
struct ast_json *json_channel;
/* No Newexten event on first channel snapshot */
if (!old_snapshot) {
return NULL;
}
/* Empty application is not valid for a Newexten event */
if (ast_strlen_zero(new_snapshot->dialplan->appl)) {
return NULL;
}
if (ast_channel_snapshot_cep_equal(old_snapshot, new_snapshot)) {
return NULL;
}
json_channel = ast_channel_snapshot_to_json(new_snapshot, stasis_app_get_sanitizer());
if (!json_channel) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: s, s: s, s: o}",
"type", "ChannelDialplan",
"timestamp", ast_json_timeval(*tv, NULL),
"dialplan_app", new_snapshot->dialplan->appl,
"dialplan_app_data", AST_JSON_UTF8_VALIDATE(new_snapshot->dialplan->data),
"channel", json_channel);
}
static struct ast_json *contactstatus_to_json(struct stasis_message *msg, const struct stasis_message_sanitizer *sanitize)
{
struct ast_endpoint_blob *obj = stasis_message_data(msg);
struct ast_json *json_endpoint;
struct ast_json *json_final;
const struct timeval *tv = stasis_message_timestamp(msg);
json_endpoint = ast_endpoint_snapshot_to_json(obj->snapshot, NULL);
if (!json_endpoint) {
return NULL;
}
json_final = ast_json_pack("{s: s, s: o, s: o, s: { s: s, s: s, s: s, s: s } } ",
"type", "ContactStatusChange",
"timestamp", ast_json_timeval(*tv, NULL),
"endpoint", json_endpoint,
"contact_info",
"uri", ast_json_string_get(ast_json_object_get(obj->blob, "uri")),
"contact_status", ast_json_string_get(ast_json_object_get(obj->blob, "contact_status")),
"aor", ast_json_string_get(ast_json_object_get(obj->blob, "aor")),
"roundtrip_usec", ast_json_string_get(ast_json_object_get(obj->blob, "roundtrip_usec")));
if (!json_final) {
ast_json_unref(json_endpoint);
}
return json_final;
}
static struct ast_json *dtmf_end_to_json(
struct stasis_message *message,
const struct stasis_message_sanitizer *sanitize)
{
struct ast_channel_blob *channel_blob = stasis_message_data(message);
struct ast_json *blob = channel_blob->blob;
struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
const char *direction =
ast_json_string_get(ast_json_object_get(blob, "direction"));
const struct timeval *tv = stasis_message_timestamp(message);
struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
/* Only present received DTMF end events as JSON */
if (strcasecmp("Received", direction) != 0) {
return NULL;
}
if (!json_channel) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: O, s: O, s: o}",
"type", "ChannelDtmfReceived",
"timestamp", ast_json_timeval(*tv, NULL),
"digit", ast_json_object_get(blob, "digit"),
"duration_ms", ast_json_object_get(blob, "duration_ms"),
"channel", json_channel);
}
struct ast_json *ast_channel_snapshot_to_json(
const struct ast_channel_snapshot *snapshot,
const struct stasis_message_sanitizer *sanitize)
{
RAII_VAR(struct ast_json *, json_chan, NULL, ast_json_unref);
if (snapshot == NULL
|| (sanitize && sanitize->channel_snapshot
&& sanitize->channel_snapshot(snapshot))) {
return NULL;
}
json_chan = ast_json_pack(
/* Broken up into groups of three for readability */
"{ s: s, s: s, s: s,"
" s: o, s: o, s: s,"
" s: o, s: o }",
/* First line */
"id", snapshot->uniqueid,
"name", snapshot->name,
"state", ast_state2str(snapshot->state),
/* Second line */
"caller", ast_json_name_number(
snapshot->caller_name, snapshot->caller_number),
"connected", ast_json_name_number(
snapshot->connected_name, snapshot->connected_number),
"accountcode", snapshot->accountcode,
/* Third line */
"dialplan", ast_json_dialplan_cep(
snapshot->context, snapshot->exten, snapshot->priority),
"creationtime", ast_json_timeval(snapshot->creationtime, NULL));
return ast_json_ref(json_chan);
}
static struct ast_json *simple_bridge_event(
const char *type,
struct ast_bridge_snapshot *snapshot,
const struct timeval *tv)
{
struct ast_json *json_bridge = ast_bridge_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
if (!json_bridge) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: o}",
"type", type,
"timestamp", ast_json_timeval(*tv, NULL),
"bridge", json_bridge);
}
/*! \internal \brief convert multi object blob to ari json */
static struct ast_json *multi_user_event_to_json(
struct stasis_message *message,
const struct stasis_message_sanitizer *sanitize)
{
RAII_VAR(struct ast_json *, out, NULL, ast_json_unref);
struct ast_multi_object_blob *multi = stasis_message_data(message);
struct ast_json *blob = multi->blob;
const struct timeval *tv = stasis_message_timestamp(message);
enum stasis_user_multi_object_snapshot_type type;
int i;
out = ast_json_object_create();
if (!out) {
return NULL;
}
ast_json_object_set(out, "type", ast_json_string_create("ChannelUserevent"));
ast_json_object_set(out, "timestamp", ast_json_timeval(*tv, NULL));
ast_json_object_set(out, "eventname", ast_json_string_create(ast_json_string_get((ast_json_object_get(blob, "eventname")))));
ast_json_object_set(out, "userevent", ast_json_deep_copy(blob));
for (type = 0; type < STASIS_UMOS_MAX; ++type) {
for (i = 0; i < AST_VECTOR_SIZE(&multi->snapshots[type]); ++i) {
struct ast_json *json_object = NULL;
char *name = NULL;
void *snapshot = AST_VECTOR_GET(&multi->snapshots[type], i);
switch (type) {
case STASIS_UMOS_CHANNEL:
json_object = ast_channel_snapshot_to_json(snapshot, sanitize);
name = "channel";
break;
case STASIS_UMOS_BRIDGE:
json_object = ast_bridge_snapshot_to_json(snapshot, sanitize);
name = "bridge";
break;
case STASIS_UMOS_ENDPOINT:
json_object = ast_endpoint_snapshot_to_json(snapshot, sanitize);
name = "endpoint";
break;
}
if (json_object) {
ast_json_object_set(out, name, json_object);
}
}
}
return ast_json_ref(out);
}
static struct ast_json *channel_destroyed_event(
struct ast_channel_snapshot *snapshot,
const struct timeval *tv)
{
struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
if (!json_channel) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: i, s: s, s: o}",
"type", "ChannelDestroyed",
"timestamp", ast_json_timeval(*tv, NULL),
"cause", snapshot->hangup->cause,
"cause_txt", ast_cause2str(snapshot->hangup->cause),
"channel", json_channel);
}
static struct ast_json *channel_blob_to_json(
struct stasis_message *message,
const char *type,
const struct stasis_message_sanitizer *sanitize)
{
RAII_VAR(struct ast_json *, out, NULL, ast_json_unref);
struct ast_channel_blob *channel_blob = stasis_message_data(message);
struct ast_json *blob = channel_blob->blob;
struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
const struct timeval *tv = stasis_message_timestamp(message);
int res = 0;
if (blob == NULL || ast_json_is_null(blob)) {
out = ast_json_object_create();
} else {
/* blobs are immutable, so shallow copies are fine */
out = ast_json_copy(blob);
}
if (!out) {
return NULL;
}
res |= ast_json_object_set(out, "type", ast_json_string_create(type));
res |= ast_json_object_set(out, "timestamp",
ast_json_timeval(*tv, NULL));
/* For global channel messages, the snapshot is optional */
if (snapshot) {
struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
if (!json_channel) {
return NULL;
}
res |= ast_json_object_set(out, "channel", json_channel);
}
if (res != 0) {
return NULL;
}
return ast_json_ref(out);
}
static int message_received_handler(const char *endpoint_id, struct ast_json *json_msg, void *pvt)
{
struct ast_endpoint_snapshot *snapshot;
struct ast_json *json_endpoint;
struct ast_json *message;
struct stasis_app *app = pvt;
char *tech;
char *resource;
tech = ast_strdupa(endpoint_id);
resource = strchr(tech, '/');
if (resource) {
resource[0] = '\0';
resource++;
}
if (ast_strlen_zero(tech) || ast_strlen_zero(resource)) {
return -1;
}
snapshot = ast_endpoint_latest_snapshot(tech, resource);
if (!snapshot) {
return -1;
}
json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
ao2_ref(snapshot, -1);
if (!json_endpoint) {
return -1;
}
message = ast_json_pack("{s: s, s: o, s: o, s: o}",
"type", "TextMessageReceived",
"timestamp", ast_json_timeval(ast_tvnow(), NULL),
"endpoint", json_endpoint,
"message", ast_json_ref(json_msg));
if (message) {
app_send(app, message);
ast_json_unref(message);
}
return 0;
}
static struct ast_json *dial_to_json(
struct stasis_message *message,
const struct stasis_message_sanitizer *sanitize)
{
struct ast_multi_channel_blob *payload = stasis_message_data(message);
struct ast_json *blob = ast_multi_channel_blob_get_json(payload);
struct ast_json *caller_json = ast_channel_snapshot_to_json(ast_multi_channel_blob_get_channel(payload, "caller"), sanitize);
struct ast_json *peer_json = ast_channel_snapshot_to_json(ast_multi_channel_blob_get_channel(payload, "peer"), sanitize);
struct ast_json *forwarded_json = ast_channel_snapshot_to_json(ast_multi_channel_blob_get_channel(payload, "forwarded"), sanitize);
struct ast_json *json;
const struct timeval *tv = stasis_message_timestamp(message);
int res = 0;
json = ast_json_pack("{s: s, s: o, s: O, s: O, s: O}",
"type", "Dial",
"timestamp", ast_json_timeval(*tv, NULL),
"dialstatus", ast_json_object_get(blob, "dialstatus"),
"forward", ast_json_object_get(blob, "forward"),
"dialstring", ast_json_object_get(blob, "dialstring"));
if (!json) {
ast_json_unref(caller_json);
ast_json_unref(peer_json);
ast_json_unref(forwarded_json);
return NULL;
}
if (caller_json) {
res |= ast_json_object_set(json, "caller", caller_json);
}
if (peer_json) {
res |= ast_json_object_set(json, "peer", peer_json);
}
if (forwarded_json) {
res |= ast_json_object_set(json, "forwarded", forwarded_json);
}
if (res) {
ast_json_unref(json);
return NULL;
}
return json;
}
static struct ast_json *user_event_to_json(
struct stasis_message *message,
const struct stasis_message_sanitizer *sanitize)
{
struct ast_channel_blob *channel_blob = stasis_message_data(message);
struct ast_json *blob = channel_blob->blob;
struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
const struct timeval *tv = stasis_message_timestamp(message);
struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
if (!json_channel) {
return NULL;
}
return ast_json_pack("{s: s, s: o, s: O, s: O, s: o}",
"type", "ChannelUserevent",
"timestamp", ast_json_timeval(*tv, NULL),
"eventname", ast_json_object_get(blob, "eventname"),
"userevent", blob,
"channel", json_channel);
}
void ast_ari_asterisk_get_info(struct ast_variable *headers,
struct ast_ari_asterisk_get_info_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
int show_all = args->only_count == 0;
int show_build = show_all;
int show_system = show_all;
int show_config = show_all;
int show_status = show_all;
size_t i;
int res = 0;
for (i = 0; i < args->only_count; ++i) {
if (strcasecmp("build", args->only[i]) == 0) {
show_build = 1;
} else if (strcasecmp("system", args->only[i]) == 0) {
show_system = 1;
} else if (strcasecmp("config", args->only[i]) == 0) {
show_config = 1;
} else if (strcasecmp("status", args->only[i]) == 0) {
show_status = 1;
} else {
ast_log(LOG_WARNING, "Unrecognized info section '%s'\n",
args->only[i]);
}
}
json = ast_json_object_create();
if (show_build) {
res |= ast_json_object_set(json, "build",
ast_json_pack(
"{ s: s, s: s, s: s,"
" s: s, s: s, s: s }",
"os", ast_build_os,
"kernel", ast_build_kernel,
"machine", ast_build_machine,
"options", AST_BUILDOPTS,
"date", ast_build_date,
"user", ast_build_user));
}
if (show_system) {
char eid_str[128];
ast_eid_to_str(eid_str, sizeof(eid_str), &ast_eid_default);
res |= ast_json_object_set(json, "system",
ast_json_pack("{ s: s, s: s }",
"version", ast_get_version(),
"entity_id", eid_str));
}
if (show_config) {
struct ast_json *config = ast_json_pack(
"{ s: s, s: s,"
" s: { s: s, s: s } }",
"name", ast_config_AST_SYSTEM_NAME,
"default_language", ast_defaultlanguage,
"setid",
"user", ast_config_AST_RUN_USER,
"group", ast_config_AST_RUN_GROUP);
res |= ast_json_object_set(json, "config", config);
if (ast_option_maxcalls) {
res |= ast_json_object_set(config, "max_channels",
ast_json_integer_create(ast_option_maxcalls));
}
if (ast_option_maxfiles) {
res |= ast_json_object_set(config, "max_open_files",
ast_json_integer_create(ast_option_maxfiles));
}
if (ast_option_maxload) {
res |= ast_json_object_set(config, "max_load",
ast_json_real_create(ast_option_maxload));
}
}
if (show_status) {
res |= ast_json_object_set(json, "status",
ast_json_pack("{ s: o, s: o }",
"startup_time",
ast_json_timeval(ast_startuptime, NULL),
"last_reload_time",
ast_json_timeval(ast_lastreloadtime, NULL)));
}
if (res != 0) {
ast_ari_response_alloc_failed(response);
return;
}
ast_ari_response_ok(response, ast_json_ref(json));
}
