From e316c2198684e801b431b62ecde4daf062eaf023 Mon Sep 17 00:00:00 2001 From: Tilghman Lesher Date: Wed, 19 Nov 2008 21:54:39 +0000 Subject: Two new functions, REALTIME_FIELD, and REALTIME_HASH, which should make querying realtime from the dialplan a little more consistent and easy to use. The original REALTIME function is preserved, for those who are already accustomed to that interface. (closes issue #13651) Reported by: Corydon76 Patches: 20081119__bug13651__2.diff.txt uploaded by Corydon76 (license 14) Tested by: blitzrage, Corydon76 git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@157870 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- funcs/func_realtime.c | 151 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 149 insertions(+), 2 deletions(-) (limited to 'funcs/func_realtime.c') diff --git a/funcs/func_realtime.c b/funcs/func_realtime.c index 31989c425..3dc25beb5 100644 --- a/funcs/func_realtime.c +++ b/funcs/func_realtime.c @@ -98,11 +98,67 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") This function acts in the same way as REALTIME(....) does, except that - it destroys matched record in RT engine. + it destroys the matched record in the RT engine. + + + + + RealTime query function. + + + + + + + + + This function retrieves a single item, fieldname + from the RT engine, where fieldmatch contains the value + value. When written to, the REALTIME_FIELD() function + performs identically to the REALTIME() function. + + + + + RealTime query function. + + + + + + + + This function retrieves a single record from the RT engine, where + fieldmatch contains the value + value and formats the output suitably, such that + it can be assigned to the HASH() function. The HASH() function then provides + a suitable method for retrieving each field value of the record. ***/ +AST_THREADSTORAGE(buf1); +AST_THREADSTORAGE(buf2); +AST_THREADSTORAGE(buf3); + +static char *hash_escape(struct ast_str **str, const char *value) +{ + int len; + ast_str_reset(*str); + + if ((*str)->len < (len = strlen(value) * 2 + 1)) { + ast_str_make_space(str, len); + } + for (; *value; value++) { + if (*value == ',' || *value == '\\') { + (*str)->str[(*str)->used++] = '\\'; + } + (*str)->str[(*str)->used++] = *value; + } + (*str)->str[(*str)->used] = '\0'; + return (*str)->str; +} + static int function_realtime_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) { struct ast_variable *var, *head; @@ -169,7 +225,7 @@ static int function_realtime_write(struct ast_channel *chan, const char *cmd, ch ); if (ast_strlen_zero(data)) { - ast_log(LOG_WARNING, "Syntax: REALTIME(family,fieldmatch,value,newcol) - missing argument!\n"); + ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,value,newcol) - missing argument!\n", cmd); return -1; } @@ -190,6 +246,82 @@ static int function_realtime_write(struct ast_channel *chan, const char *cmd, ch return 0; } +static int realtimefield_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) +{ + struct ast_variable *var, *head; + struct ast_str *escapebuf = ast_str_thread_get(&buf1, 16); + struct ast_str *fields = ast_str_thread_get(&buf2, 16); + struct ast_str *values = ast_str_thread_get(&buf3, 16); + int first; + enum { rtfield, rthash } which; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(family); + AST_APP_ARG(fieldmatch); + AST_APP_ARG(value); + AST_APP_ARG(fieldname); + ); + + if (!strcmp(cmd, "REALTIME_FIELD")) { + which = rtfield; + } else { + which = rthash; + } + + if (ast_strlen_zero(data)) { + ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,value%s) - missing argument!\n", cmd, which == rtfield ? ",fieldname" : ""); + return -1; + } + + AST_STANDARD_APP_ARGS(args, data); + + if ((which == rtfield && args.argc != 4) || (which == rthash && args.argc != 3)) { + ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,value%s) - missing argument!\n", cmd, which == rtfield ? ",fieldname" : ""); + return -1; + } + + if (chan) { + ast_autoservice_start(chan); + } + + if (!(head = ast_load_realtime_all(args.family, args.fieldmatch, args.value, SENTINEL))) { + if (chan) { + ast_autoservice_stop(chan); + } + return -1; + } + + ast_str_reset(fields); + ast_str_reset(values); + + for (var = head; var; var = var->next) { + if (which == rtfield) { + ast_debug(1, "Comparing %s to %s\n", var->name, args.fieldname); + if (!strcasecmp(var->name, args.fieldname)) { + ast_debug(1, "Match! Value is %s\n", var->value); + ast_copy_string(buf, var->value, len); + break; + } + } else if (which == rthash) { + ast_debug(1, "Setting hash key %s to value %s\n", var->name, var->value); + ast_str_append(&fields, 0, "%s%s", first ? "" : ",", hash_escape(&escapebuf, var->name)); + ast_str_append(&values, 0, "%s%s", first ? "" : ",", hash_escape(&escapebuf, var->value)); + first = 0; + } + } + ast_variables_destroy(head); + + if (which == rthash) { + pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", fields->str); + ast_copy_string(buf, values->str, len); + } + + if (chan) { + ast_autoservice_stop(chan); + } + + return 0; +} + static int function_realtime_store(struct ast_channel *chan, const char *cmd, char *data, const char *value) { int res = 0; @@ -302,6 +434,17 @@ struct ast_custom_function realtime_function = { .write = function_realtime_write, }; +struct ast_custom_function realtimefield_function = { + .name = "REALTIME_FIELD", + .read = realtimefield_read, + .write = function_realtime_write, +}; + +struct ast_custom_function realtimehash_function = { + .name = "REALTIME_HASH", + .read = realtimefield_read, +}; + struct ast_custom_function realtime_store_function = { .name = "REALTIME_STORE", .write = function_realtime_store, @@ -318,6 +461,8 @@ static int unload_module(void) res |= ast_custom_function_unregister(&realtime_function); res |= ast_custom_function_unregister(&realtime_store_function); res |= ast_custom_function_unregister(&realtime_destroy_function); + res |= ast_custom_function_unregister(&realtimefield_function); + res |= ast_custom_function_unregister(&realtimehash_function); return res; } @@ -327,6 +472,8 @@ static int load_module(void) res |= ast_custom_function_register(&realtime_function); res |= ast_custom_function_register(&realtime_store_function); res |= ast_custom_function_register(&realtime_destroy_function); + res |= ast_custom_function_register(&realtimefield_function); + res |= ast_custom_function_register(&realtimehash_function); return res; } -- cgit v1.2.3