static int app_event_filter_set(struct stasis_app *app, struct ast_json **member, struct ast_json *filter, const char *filter_type) { if (filter && ast_json_typeof(filter) == AST_JSON_OBJECT) { if (!ast_json_object_size(filter)) { /* If no filters are specified then reset this filter type */ filter = NULL; } else { /* Otherwise try to get the filter array for this type */ filter = ast_json_object_get(filter, filter_type); if (!filter) { /* A filter type exists, but not this one, so don't update */ return 0; } } } /* At this point the filter object should be an array */ if (filter && ast_json_typeof(filter) != AST_JSON_ARRAY) { ast_log(LOG_ERROR, "Invalid json type event filter - app: %s, filter: %s\n", app->name, filter_type); return -1; } if (filter) { /* Confirm that at least the type names are specified */ struct ast_json *obj; int i; for (i = 0; i < ast_json_array_size(filter) && (obj = ast_json_array_get(filter, i)); ++i) { if (ast_strlen_zero(ast_json_object_string_get(obj, "type"))) { ast_log(LOG_ERROR, "Filter event must have a type - app: %s, " "filter: %s\n", app->name, filter_type); return -1; } } } ao2_lock(app); ast_json_unref(*member); *member = filter ? ast_json_ref(filter) : NULL; ao2_unlock(app); return 0; }
static int app_event_filter_matched(struct ast_json *array, struct ast_json *event, int empty) { struct ast_json *obj; int i; if (!array || !ast_json_array_size(array)) { return empty; } for (i = 0; i < ast_json_array_size(array) && (obj = ast_json_array_get(array, i)); ++i) { if (ast_strings_equal(ast_json_object_string_get(obj, "type"), ast_json_object_string_get(event, "type"))) { return 1; } } return 0; }
int ast_ari_bridges_add_channel_parse_body( struct ast_json *body, struct ast_ari_bridges_add_channel_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "channel"); if (field) { /* If they were silly enough to both pass in a query param and a * JSON body, free up the query value. */ ast_free(args->channel); if (ast_json_typeof(field) == AST_JSON_ARRAY) { /* Multiple param passed as array */ size_t i; args->channel_count = ast_json_array_size(field); args->channel = ast_malloc(sizeof(*args->channel) * args->channel_count); if (!args->channel) { return -1; } for (i = 0; i < args->channel_count; ++i) { args->channel[i] = ast_json_string_get(ast_json_array_get(field, i)); } } else { /* Multiple param passed as single value */ args->channel_count = 1; args->channel = ast_malloc(sizeof(*args->channel) * args->channel_count); if (!args->channel) { return -1; } args->channel[0] = ast_json_string_get(field); } } field = ast_json_object_get(body, "role"); if (field) { args->role = ast_json_string_get(field); } return 0; }
int ast_ari_validate_list(struct ast_json *json, int (*fn)(struct ast_json *)) { int res = 1; size_t i; if (!check_type(json, AST_JSON_ARRAY)) { return 0; } for (i = 0; i < ast_json_array_size(json); ++i) { int member_res; member_res = fn(ast_json_array_get(json, i)); if (!member_res) { ast_log(LOG_ERROR, "Array member %zu failed validation\n", i); res = 0; } } return res; }
int ast_ari_asterisk_get_info_parse_body( struct ast_json *body, struct ast_ari_asterisk_get_info_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "only"); if (field) { /* If they were silly enough to both pass in a query param and a * JSON body, free up the query value. */ ast_free(args->only); if (ast_json_typeof(field) == AST_JSON_ARRAY) { /* Multiple param passed as array */ size_t i; args->only_count = ast_json_array_size(field); args->only = ast_malloc(sizeof(*args->only) * args->only_count); if (!args->only) { return -1; } for (i = 0; i < args->only_count; ++i) { args->only[i] = ast_json_string_get(ast_json_array_get(field, i)); } } else { /* Multiple param passed as single value */ args->only_count = 1; args->only = ast_malloc(sizeof(*args->only) * args->only_count); if (!args->only) { return -1; } args->only[0] = ast_json_string_get(field); } } return 0; }
int ast_ari_applications_unsubscribe_parse_body( struct ast_json *body, struct ast_ari_applications_unsubscribe_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "eventSource"); if (field) { /* If they were silly enough to both pass in a query param and a * JSON body, free up the query value. */ ast_free(args->event_source); if (ast_json_typeof(field) == AST_JSON_ARRAY) { /* Multiple param passed as array */ size_t i; args->event_source_count = ast_json_array_size(field); args->event_source = ast_malloc(sizeof(*args->event_source) * args->event_source_count); if (!args->event_source) { return -1; } for (i = 0; i < args->event_source_count; ++i) { args->event_source[i] = ast_json_string_get(ast_json_array_get(field, i)); } } else { /* Multiple param passed as single value */ args->event_source_count = 1; args->event_source = ast_malloc(sizeof(*args->event_source) * args->event_source_count); if (!args->event_source) { return -1; } args->event_source[0] = ast_json_string_get(field); } } return 0; }
void ast_ari_asterisk_update_object(struct ast_variable *headers, struct ast_ari_asterisk_update_object_args *args, struct ast_ari_response *response) { RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref); RAII_VAR(struct ast_sorcery_object_type *, object_type, NULL, ao2_cleanup); RAII_VAR(void *, sorcery_obj, NULL, ao2_cleanup); struct ast_json *fields; struct ast_variable *update_set = NULL; int created = 0; sorcery = ast_sorcery_retrieve_by_module_name(args->config_class); if (!sorcery) { ast_ari_response_error( response, 404, "Not Found", "configClass '%s' not found", args->config_class); return; } object_type = ast_sorcery_get_object_type(sorcery, args->object_type); if (!object_type) { ast_ari_response_error( response, 404, "Not Found", "objectType '%s' not found", args->object_type); return; } sorcery_obj = ast_sorcery_retrieve_by_id(sorcery, args->object_type, args->id); if (!sorcery_obj) { ast_debug(5, "Sorcery object '%s' does not exist; creating it\n", args->id); sorcery_obj = ast_sorcery_alloc(sorcery, args->object_type, args->id); if (!sorcery_obj) { ast_ari_response_alloc_failed(response); return; } created = 1; } else { void *copy; copy = ast_sorcery_copy(sorcery, sorcery_obj); if (!copy) { ast_ari_response_alloc_failed(response); return; } ao2_ref(sorcery_obj, -1); sorcery_obj = copy; } fields = ast_json_object_get(args->fields, "fields"); if (!fields && !created) { /* Whoops. We need data. */ ast_ari_response_error( response, 400, "Bad request", "Fields must be provided to update object '%s'", args->id); return; } else if (fields) { size_t i; for (i = 0; i < ast_json_array_size(fields); i++) { struct ast_variable *new_var; struct ast_json *json_value = ast_json_array_get(fields, i); if (!json_value) { continue; } new_var = ast_variable_new( ast_json_string_get(ast_json_object_get(json_value, "attribute")), ast_json_string_get(ast_json_object_get(json_value, "value")), ""); if (!new_var) { ast_variables_destroy(update_set); ast_ari_response_alloc_failed(response); return; } ast_variable_list_append(&update_set, new_var); } } /* APPLY! Note that a NULL update_set is fine (and necessary), as it * will force validation on a newly created object. */ if (ast_sorcery_objectset_apply(sorcery, sorcery_obj, update_set)) { ast_variables_destroy(update_set); ast_ari_response_error( response, 400, "Bad request", "%s of object '%s' failed field value validation", created ? "Creation" : "Update", args->id); return; } ast_variables_destroy(update_set); if (created) { if (ast_sorcery_create(sorcery, sorcery_obj)) { ast_ari_response_error( response, 403, "Forbidden", "Cannot create sorcery objects of type '%s'", args->object_type); return; } } else { if (ast_sorcery_update(sorcery, sorcery_obj)) { ast_ari_response_error( response, 403, "Forbidden", "Cannot update sorcery objects of type '%s'", args->object_type); return; } } return_sorcery_object(sorcery, sorcery_obj, response); }