diff --git a/doc/CHANGES-staging/func_json.txt b/doc/CHANGES-staging/func_json.txt new file mode 100644 index 0000000000..79bb2da87d --- /dev/null +++ b/doc/CHANGES-staging/func_json.txt @@ -0,0 +1,5 @@ +Subject: func_json + +The JSON_DECODE dialplan function can now be used +to parse JSON strings, such as in conjunction with +CURL for using API responses. diff --git a/funcs/func_json.c b/funcs/func_json.c new file mode 100644 index 0000000000..a48b85c663 --- /dev/null +++ b/funcs/func_json.c @@ -0,0 +1,228 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2021, Naveen Albert + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief JSON parsing function + * + * \author Naveen Albert + * + * \ingroup functions + */ + +/*** MODULEINFO + extended + ***/ + +#include "asterisk.h" + +#include "asterisk/module.h" +#include "asterisk/channel.h" +#include "asterisk/pbx.h" +#include "asterisk/utils.h" +#include "asterisk/test.h" +#include "asterisk/app.h" +#include "asterisk/conversions.h" + +/*** DOCUMENTATION + + + Returns the string value of a JSON object key from a string containing a + JSON array. + + + + The name of the variable containing the JSON string to parse. + + + The name of the key whose value to return. + + + + The JSON_DECODE function retrieves the value of the given variable name + and parses it as JSON, returning the value at a specified key. If the key cannot + be found, an empty string is returned. + + + CURL + + + ***/ + +AST_THREADSTORAGE(result_buf); + +static int json_decode_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) +{ + struct ast_json *json, *jsonval; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(varname); + AST_APP_ARG(key); + ); + char *varsubst, *result2; + const char *result = NULL; + struct ast_str *str = ast_str_thread_get(&result_buf, 16); + + AST_STANDARD_APP_ARGS(args, data); + + if (ast_strlen_zero(args.varname)) { + ast_log(LOG_WARNING, "%s requires a variable name\n", cmd); + return -1; + } + if (ast_strlen_zero(args.key)) { + ast_log(LOG_WARNING, "%s requires a key\n", cmd); + return -1; + } + + varsubst = ast_alloca(strlen(args.varname) + 4); /* +4 for ${} and null terminator */ + if (!varsubst) { + ast_log(LOG_ERROR, "Failed to allocate string\n"); + return -1; + } + sprintf(varsubst, "${%s}", args.varname); /* safe, because of the above allocation */ + ast_str_substitute_variables(&str, 0, chan, varsubst); + if (ast_str_strlen(str) == 0) { + ast_debug(1, "Variable '%s' contains no data, nothing to search!\n", args.varname); + return -1; /* empty json string */ + } + + ast_debug(1, "Parsing JSON: %s\n", ast_str_buffer(str)); + + json = ast_json_load_str(str, NULL); + + if (!json) { + ast_log(LOG_WARNING, "Failed to parse as JSON: %s\n", ast_str_buffer(str)); + return -1; + } + + jsonval = ast_json_object_get(json, args.key); + if (!jsonval) { /* no error or warning should be thrown */ + ast_debug(1, "Could not find key '%s' in parsed JSON\n", args.key); + ast_json_free(json); + return -1; + } + switch(ast_json_typeof(jsonval)) { + int r; + case AST_JSON_STRING: + result = ast_json_string_get(jsonval); + snprintf(buf, len, "%s", result); + break; + case AST_JSON_INTEGER: + r = ast_json_integer_get(jsonval); + snprintf(buf, len, "%d", r); /* the snprintf below is mutually exclusive with this one */ + break; + default: + result2 = ast_json_dump_string(jsonval); + snprintf(buf, len, "%s", result2); + ast_json_free(result2); + break; + } + ast_json_free(json); + + return 0; +} + +static struct ast_custom_function json_decode_function = { + .name = "JSON_DECODE", + .read = json_decode_read, +}; + +#ifdef TEST_FRAMEWORK +AST_TEST_DEFINE(test_JSON_DECODE) +{ + int i, res = AST_TEST_PASS; + struct ast_channel *chan; /* dummy channel */ + struct ast_str *str; /* fancy string for holding comparing value */ + + const char *test_strings[][5] = { + {"{\"city\": \"Anytown\", \"state\": \"USA\"}", "city", "Anytown"}, + {"{\"city\": \"Anytown\", \"state\": \"USA\"}", "state", "USA"}, + {"{\"city\": \"Anytown\", \"state\": \"USA\"}", "blah", ""}, + {"{\"key1\": \"123\", \"key2\": \"456\"}", "key1", "123"}, + {"{\"key1\": 123, \"key2\": 456}", "key1", "123"}, + }; + + switch (cmd) { + case TEST_INIT: + info->name = "func_JSON_DECODE"; + info->category = "/funcs/func_json/"; + info->summary = "Test JSON_DECODE function"; + info->description = "Verify JSON_DECODE behavior"; + return AST_TEST_NOT_RUN; + case TEST_EXECUTE: + break; + } + + if (!(chan = ast_dummy_channel_alloc())) { + ast_test_status_update(test, "Unable to allocate dummy channel\n"); + return AST_TEST_FAIL; + } + + if (!(str = ast_str_create(64))) { + ast_test_status_update(test, "Unable to allocate dynamic string buffer\n"); + ast_channel_release(chan); + return AST_TEST_FAIL; + } + + for (i = 0; i < ARRAY_LEN(test_strings); i++) { + char tmp[512], tmp2[512] = ""; + + struct ast_var_t *var = ast_var_assign("test_string", test_strings[i][0]); + if (!var) { + ast_test_status_update(test, "Unable to allocate variable\n"); + ast_free(str); + ast_channel_release(chan); + return AST_TEST_FAIL; + } + + AST_LIST_INSERT_HEAD(ast_channel_varshead(chan), var, entries); + + snprintf(tmp, sizeof(tmp), "${JSON_DECODE(%s,%s)}", "test_string", test_strings[i][1]); + + ast_str_substitute_variables(&str, 0, chan, tmp); + if (strcmp(test_strings[i][2], ast_str_buffer(str))) { + ast_test_status_update(test, "Format string '%s' substituted to '%s'. Expected '%s'.\n", test_strings[i][0], tmp2, test_strings[i][2]); + res = AST_TEST_FAIL; + } + } + + ast_free(str); + ast_channel_release(chan); + + return res; +} +#endif + +static int unload_module(void) +{ + int res; + + AST_TEST_UNREGISTER(test_JSON_DECODE); + res = ast_custom_function_unregister(&json_decode_function); + + return res; +} + +static int load_module(void) +{ + int res; + + AST_TEST_REGISTER(test_JSON_DECODE); + res = ast_custom_function_register(&json_decode_function); + + return res; +} + +AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "JSON decoding function");