struct ast_json *stasis_app_event_filter_to_json(struct stasis_app *app, struct ast_json *json)
{
if (!app || !json) {
return json;
}
ast_json_object_set(json, "events_allowed", app->events_allowed ?
ast_json_ref(app->events_allowed) : ast_json_array_create());
ast_json_object_set(json, "events_disallowed", app->events_disallowed ?
ast_json_ref(app->events_disallowed) : ast_json_array_create());
return json;
}
struct ast_json *stasis_app_mailboxes_to_json()
{
struct ast_json *array = ast_json_array_create();
struct ao2_container *mailboxes;
struct ao2_iterator iter;
const struct ast_mwi_mailbox_object *mailbox;
if (!array) {
return NULL;
}
mailboxes = ast_mwi_mailbox_get_all();
if (!mailboxes) {
ast_json_unref(array);
return NULL;
}
iter = ao2_iterator_init(mailboxes, 0);
for (; (mailbox = ao2_iterator_next(&iter)); ast_mwi_mailbox_unref(mailbox)) {
struct ast_json *appending = mailbox_to_json(mailbox);
if (!appending || ast_json_array_append(array, appending)) {
/* Failed to append individual mailbox to the array. Abort. */
ast_json_unref(array);
array = NULL;
break;
}
}
ao2_iterator_destroy(&iter);
return array;
}
void ast_ari_sounds_list(struct ast_variable *headers,
struct ast_ari_sounds_list_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct ao2_container *, sound_files, NULL, ao2_cleanup);
struct ast_json *sounds_blob;
RAII_VAR(struct ast_media_index *, sounds_index, ast_sounds_get_index(), ao2_cleanup);
if (!sounds_index) {
ast_ari_response_error(response, 500, "Internal Error", "Sounds index not available");
return;
}
sound_files = ast_media_get_media(sounds_index);
if (!sound_files) {
ast_ari_response_error(response, 500, "Internal Error", "Allocation Error");
return;
}
sounds_blob = ast_json_array_create();
if (!sounds_blob) {
ast_ari_response_error(response, 500, "Internal Error", "Allocation Error");
return;
}
ao2_callback_data(sound_files, OBJ_NODATA, append_sound_cb, sounds_blob, args);
if (!ast_json_array_size(sounds_blob)) {
ast_ari_response_error(response, 404, "Not Found", "No sounds found that matched the query");
return;
}
ast_ari_response_ok(response, sounds_blob);
}
/**
* Get all plan info.
* @return
*/
struct ast_json* get_plans_all(void)
{
char* sql;
struct ast_json* j_res;
struct ast_json* j_tmp;
db_res_t* db_res;
ast_asprintf(&sql, "select * from plan where in_use=%d;", E_DL_USE_OK);
db_res = db_query(sql);
ast_free(sql);
if(db_res == NULL) {
ast_log(LOG_ERROR, "Could not get plan all info.\n");
return NULL;
}
j_res = ast_json_array_create();
while(1) {
j_tmp = db_get_record(db_res);
if(j_tmp == NULL) {
break;
}
ast_json_array_append(j_res, j_tmp);
}
db_free(db_res);
return j_res;
}
void ast_ari_channels_list(struct ast_variable *headers,
struct ast_ari_channels_list_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
struct ao2_iterator i;
void *obj;
struct stasis_message_sanitizer *sanitize = stasis_app_get_sanitizer();
cache = ast_channel_cache();
if (!cache) {
ast_ari_response_error(
response, 500, "Internal Server Error",
"Message bus not initialized");
return;
}
ao2_ref(cache, +1);
snapshots = stasis_cache_dump(cache, ast_channel_snapshot_type());
if (!snapshots) {
ast_ari_response_alloc_failed(response);
return;
}
json = ast_json_array_create();
if (!json) {
ast_ari_response_alloc_failed(response);
return;
}
for (i = ao2_iterator_init(snapshots, 0);
(obj = ao2_iterator_next(&i)); ao2_cleanup(obj)) {
RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
struct ast_channel_snapshot *snapshot = stasis_message_data(msg);
int r;
if (sanitize && sanitize->channel_snapshot
&& sanitize->channel_snapshot(snapshot)) {
continue;
}
r = ast_json_array_append(
json, ast_channel_snapshot_to_json(snapshot, NULL));
if (r != 0) {
ast_ari_response_alloc_failed(response);
ao2_cleanup(obj);
ao2_iterator_destroy(&i);
return;
}
}
ao2_iterator_destroy(&i);
ast_ari_response_ok(response, ast_json_ref(json));
}
static struct app_data *app_data_create(void)
{
struct app_data *res = ao2_alloc(sizeof(struct app_data), app_data_dtor);
if (!res) {
return NULL;
}
res->messages = ast_json_array_create();
return res;
}
void ast_ari_asterisk_list_modules(struct ast_variable *headers,
struct ast_ari_asterisk_list_modules_args *args,
struct ast_ari_response *response)
{
struct ast_json *json;
json = ast_json_array_create();
ast_update_module_list_data(&process_module_list, NULL, json);
ast_ari_response_ok(response, json);
}
void ast_ari_bridges_list(struct ast_variable *headers,
struct ast_ari_bridges_list_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
struct ao2_iterator i;
void *obj;
cache = ast_bridge_cache();
if (!cache) {
ast_ari_response_error(
response, 500, "Internal Server Error",
"Message bus not initialized");
return;
}
ao2_ref(cache, +1);
snapshots = stasis_cache_dump(cache, ast_bridge_snapshot_type());
if (!snapshots) {
ast_ari_response_alloc_failed(response);
return;
}
json = ast_json_array_create();
if (!json) {
ast_ari_response_alloc_failed(response);
return;
}
i = ao2_iterator_init(snapshots, 0);
while ((obj = ao2_iterator_next(&i))) {
RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
struct ast_bridge_snapshot *snapshot = stasis_message_data(msg);
struct ast_json *json_bridge = ast_bridge_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
if (!json_bridge || ast_json_array_append(json, json_bridge)) {
ao2_iterator_destroy(&i);
ast_ari_response_alloc_failed(response);
return;
}
}
ao2_iterator_destroy(&i);
ast_ari_response_ok(response, ast_json_ref(json));
}
static void return_sorcery_object(struct ast_sorcery *sorcery, void *sorcery_obj,
struct ast_ari_response *response)
{
RAII_VAR(struct ast_json *, return_set, NULL, ast_json_unref);
struct ast_variable *change_set;
struct ast_variable *it_change_set;
return_set = ast_json_array_create();
if (!return_set) {
ast_ari_response_alloc_failed(response);
return;
}
/* Note that we can't use the sorcery JSON change set directly,
* as it will hand us back an Object (with fields), and we need
* a more generic representation of whatever the API call asked
* for, i.e., a list of tuples.
*/
change_set = ast_sorcery_objectset_create(sorcery, sorcery_obj);
if (!change_set) {
ast_ari_response_alloc_failed(response);
return;
}
for (it_change_set = change_set; it_change_set; it_change_set = it_change_set->next) {
struct ast_json *tuple;
tuple = ast_json_pack("{s: s, s: s}",
"attribute", it_change_set->name,
"value", it_change_set->value);
if (!tuple) {
ast_variables_destroy(change_set);
ast_ari_response_alloc_failed(response);
return;
}
if (ast_json_array_append(return_set, tuple)) {
ast_json_unref(tuple);
ast_variables_destroy(change_set);
ast_ari_response_alloc_failed(response);
return;
}
}
ast_variables_destroy(change_set);
ast_ari_response_ok(response, ast_json_ref(return_set));
}
void ast_ari_asterisk_list_log_channels(struct ast_variable *headers,
struct ast_ari_asterisk_list_log_channels_args *args,
struct ast_ari_response *response)
{
struct ast_json *json;
int res;
json = ast_json_array_create();
res = ast_logger_get_channels(&process_log_list, json);
if (res == AST_LOGGER_FAILURE) {
ast_ari_response_error(response, 500, "Internal Server Error",
"Response body is not valid");
return;
} else if (res == AST_LOGGER_ALLOC_ERROR) {
ast_ari_response_error(response, 500, "Internal Server Error",
"Allocation Failed");
return;
}
ast_ari_response_ok(response, json);
}
void ast_ari_recordings_list_stored(struct ast_variable *headers,
struct ast_ari_recordings_list_stored_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct ao2_container *, recordings, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
struct ao2_iterator i;
void *obj;
recordings = stasis_app_stored_recording_find_all();
if (!recordings) {
ast_ari_response_alloc_failed(response);
return;
}
json = ast_json_array_create();
if (!json) {
ast_ari_response_alloc_failed(response);
return;
}
i = ao2_iterator_init(recordings, 0);
while ((obj = ao2_iterator_next(&i))) {
RAII_VAR(struct stasis_app_stored_recording *, recording, obj,
ao2_cleanup);
int r = ast_json_array_append(
json, stasis_app_stored_recording_to_json(recording));
if (r != 0) {
ast_ari_response_alloc_failed(response);
ao2_iterator_destroy(&i);
return;
}
}
ao2_iterator_destroy(&i);
ast_ari_response_ok(response, ast_json_ref(json));
}
void ast_ari_endpoints_list_by_tech(struct ast_variable *headers,
struct ast_ari_endpoints_list_by_tech_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
struct ao2_iterator i;
void *obj;
if (!ast_get_channel_tech(args->tech)) {
ast_ari_response_error(response, 404, "Not Found",
"No Endpoints found - invalid tech %s", args->tech);
return;
}
cache = ast_endpoint_cache();
if (!cache) {
ast_ari_response_error(
response, 500, "Internal Server Error",
"Message bus not initialized");
return;
}
ao2_ref(cache, +1);
snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
if (!snapshots) {
ast_ari_response_alloc_failed(response);
return;
}
json = ast_json_array_create();
if (!json) {
ast_ari_response_alloc_failed(response);
return;
}
i = ao2_iterator_init(snapshots, 0);
while ((obj = ao2_iterator_next(&i))) {
RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
struct ast_json *json_endpoint;
int r;
if (strcasecmp(args->tech, snapshot->tech) != 0) {
continue;
}
json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
if (!json_endpoint) {
continue;
}
r = ast_json_array_append(
json, json_endpoint);
if (r != 0) {
ast_ari_response_alloc_failed(response);
return;
}
}
ao2_iterator_destroy(&i);
ast_ari_response_ok(response, ast_json_ref(json));
}