Blocked revisions 53878 via svnmerge
[asterisk/asterisk.git] / funcs / func_strings.c
index 47b7806..af330e6 100644 (file)
@@ -22,6 +22,7 @@
  *
  * \author Tilghman Lesher
  * \author Anothony Minessale II 
+ * \ingroup functions
  */
 
 #include "asterisk.h"
@@ -35,6 +36,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include <regex.h>
 
 #include "asterisk/module.h"
+#include "asterisk/options.h"
 #include "asterisk/channel.h"
 #include "asterisk/pbx.h"
 #include "asterisk/logger.h"
@@ -43,10 +45,10 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/localtime.h"
 #include "asterisk/options.h"
 
-static int function_fieldqty(struct ast_channel *chan, char *cmd,
+static int function_fieldqty(struct ast_channel *chan, const char *cmd,
                             char *parse, char *buf, size_t len)
 {
-       char *varval;
+       char *varsubst, varval[8192] = "", *varval2 = varval;
        int fieldcount = 0;
        AST_DECLARE_APP_ARGS(args,
                             AST_APP_ARG(varname);
@@ -55,8 +57,21 @@ static int function_fieldqty(struct ast_channel *chan, char *cmd,
 
        AST_STANDARD_APP_ARGS(args, parse);
        if (args.delim) {
-               pbx_retrieve_variable(chan, args.varname, &varval, buf, len, NULL);
-               while (strsep(&varval, args.delim))
+               if (args.delim[0] == '\\') {
+                       if (args.delim[1] == 'n')
+                               ast_copy_string(args.delim, "\n", 2);
+                       else if (args.delim[1] == 't')
+                               ast_copy_string(args.delim, "\t", 2);
+                       else if (args.delim[1])
+                               ast_copy_string(args.delim, &args.delim[1], 2);
+                       else
+                               ast_copy_string(args.delim, "-", 2);
+               }
+               varsubst = alloca(strlen(args.varname) + 4);
+
+               sprintf(varsubst, "${%s}", args.varname);
+               pbx_substitute_variables_helper(chan, varsubst, varval, sizeof(varval) - 1);
+               while (strsep(&varval2, args.delim))
                        fieldcount++;
        } else {
                fieldcount = 1;
@@ -73,7 +88,7 @@ static struct ast_custom_function fieldqty_function = {
        .read = function_fieldqty,
 };
 
-static int filter(struct ast_channel *chan, char *cmd, char *parse, char *buf,
+static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *buf,
                  size_t len)
 {
        AST_DECLARE_APP_ARGS(args,
@@ -105,7 +120,7 @@ static struct ast_custom_function filter_function = {
        .read = filter,
 };
 
-static int regex(struct ast_channel *chan, char *cmd, char *parse, char *buf,
+static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf,
                 size_t len)
 {
        AST_DECLARE_APP_ARGS(args,
@@ -155,7 +170,38 @@ static struct ast_custom_function regex_function = {
        .read = regex,
 };
 
-static int array(struct ast_channel *chan, char *cmd, char *var,
+#define HASH_PREFIX    "~HASH~%s~"
+#define HASH_FORMAT    HASH_PREFIX "%s~"
+
+static char *app_clearhash = "ClearHash";
+static char *syn_clearhash = "Clear the keys from a specified hashname";
+static char *desc_clearhash =
+"ClearHash(<hashname>)\n"
+"  Clears all keys out of the specified hashname\n";
+
+/* This function probably should migrate to main/pbx.c, as pbx_builtin_clearvar_prefix() */
+static void clearvar_prefix(struct ast_channel *chan, const char *prefix)
+{
+       struct ast_var_t *var;
+       int len = strlen(prefix);
+       AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->varshead, var, entries) {
+               if (strncasecmp(prefix, ast_var_name(var), len) == 0) {
+                       AST_LIST_REMOVE_CURRENT(&chan->varshead, entries);
+                       free(var);
+               }
+       }
+       AST_LIST_TRAVERSE_SAFE_END
+}
+
+static int exec_clearhash(struct ast_channel *chan, void *data)
+{
+       char prefix[80];
+       snprintf(prefix, sizeof(prefix), HASH_PREFIX, data ? (char *)data : "null");
+       clearvar_prefix(chan, prefix);
+       return 0;
+}
+
+static int array(struct ast_channel *chan, const char *cmd, char *var,
                 const char *value)
 {
        AST_DECLARE_APP_ARGS(arg1,
@@ -164,13 +210,23 @@ static int array(struct ast_channel *chan, char *cmd, char *var,
        AST_DECLARE_APP_ARGS(arg2,
                             AST_APP_ARG(val)[100];
        );
-       char *value2;
-       int i;
+       char *origvar = "", *value2, varname[256];
+       int i, ishash = 0;
 
        value2 = ast_strdupa(value);
        if (!var || !value2)
                return -1;
 
+       if (!strcmp(cmd, "HASH")) {
+               const char *var2 = pbx_builtin_getvar_helper(chan, "~ODBCFIELDS~");
+               origvar = var;
+               if (var2)
+                       var = ast_strdupa(var2);
+               else
+                       return -1;
+               ishash = 1;
+       }
+
        /* The functions this will generally be used with are SORT and ODBC_*, which
         * both return comma-delimited lists.  However, if somebody uses literal lists,
         * their commas will be translated to vertical bars by the load, and I don't
@@ -194,17 +250,139 @@ static int array(struct ast_channel *chan, char *cmd, char *var,
                        ast_log(LOG_DEBUG, "array set value (%s=%s)\n", arg1.var[i],
                                arg2.val[i]);
                if (i < arg2.argc) {
-                       pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
+                       if (ishash) {
+                               snprintf(varname, sizeof(varname), HASH_FORMAT, origvar, arg1.var[i]);
+                               pbx_builtin_setvar_helper(chan, varname, arg2.val[i]);
+                       } else {
+                               pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
+                       }
                } else {
                        /* We could unset the variable, by passing a NULL, but due to
                         * pushvar semantics, that could create some undesired behavior. */
-                       pbx_builtin_setvar_helper(chan, arg1.var[i], "");
+                       if (ishash) {
+                               snprintf(varname, sizeof(varname), HASH_FORMAT, origvar, arg1.var[i]);
+                               pbx_builtin_setvar_helper(chan, varname, "");
+                       } else {
+                               pbx_builtin_setvar_helper(chan, arg1.var[i], "");
+                       }
+               }
+       }
+
+       return 0;
+}
+
+static int hashkeys_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+{
+       struct ast_var_t *newvar;
+       int plen;
+       char prefix[80];
+       snprintf(prefix, sizeof(prefix), HASH_PREFIX, data);
+       plen = strlen(prefix);
+
+       memset(buf, 0, len);
+       AST_LIST_TRAVERSE(&chan->varshead, newvar, entries) {
+               if (strncasecmp(prefix, ast_var_name(newvar), plen) == 0) {
+                       /* Copy everything after the prefix */
+                       strncat(buf, ast_var_name(newvar) + plen, len);
+                       /* Trim the trailing ~ */
+                       buf[strlen(buf) - 1] = ',';
+               }
+       }
+       /* Trim the trailing comma */
+       buf[strlen(buf) - 1] = '\0';
+       return 0;
+}
+
+static int hash_write(struct ast_channel *chan, const char *cmd, char *var, const char *value)
+{
+       char varname[256];
+       AST_DECLARE_APP_ARGS(arg,
+               AST_APP_ARG(hashname);
+               AST_APP_ARG(hashkey);
+       );
+
+       if (!strchr(var, '|')) {
+               /* Single argument version */
+               return array(chan, "HASH", var, value);
+       }
+
+       AST_STANDARD_APP_ARGS(arg, var);
+       snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg.hashkey);
+       pbx_builtin_setvar_helper(chan, varname, value);
+
+       return 0;
+}
+
+static int hash_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+{
+       char varname[256];
+       const char *varvalue;
+       AST_DECLARE_APP_ARGS(arg,
+               AST_APP_ARG(hashname);
+               AST_APP_ARG(hashkey);
+       );
+
+       AST_STANDARD_APP_ARGS(arg, data);
+       if (arg.argc == 2) {
+               snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg.hashkey);
+               varvalue = pbx_builtin_getvar_helper(chan, varname);
+               if (varvalue)
+                       ast_copy_string(buf, varvalue, len);
+               else
+                       *buf = '\0';
+       } else if (arg.argc == 1) {
+               char colnames[4096];
+               int i;
+               AST_DECLARE_APP_ARGS(arg2,
+                       AST_APP_ARG(col)[100];
+               );
+
+               /* Get column names, in no particular order */
+               hashkeys_read(chan, "HASHKEYS", arg.hashname, colnames, sizeof(colnames));
+               pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", colnames);
+
+               AST_NONSTANDARD_APP_ARGS(arg2, colnames, ',');
+               *buf = '\0';
+
+               /* Now get the corresponding column values, in exactly the same order */
+               for (i = 0; i < arg2.argc; i++) {
+                       snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg2.col[i]);
+                       varvalue = pbx_builtin_getvar_helper(chan, varname);
+                       strncat(buf, varvalue, len);
+                       strncat(buf, ",", len);
                }
+
+               /* Strip trailing comma */
+               buf[strlen(buf) - 1] = '\0';
        }
 
        return 0;
 }
 
+static struct ast_custom_function hash_function = {
+       .name = "HASH",
+       .synopsis = "Implementation of a dialplan associative array",
+       .syntax = "HASH(hashname[|hashkey])",
+       .write = hash_write,
+       .read = hash_read,
+       .desc =
+               "In two argument mode, gets and sets values to corresponding keys within a named\n"
+               "associative array.  The single-argument mode will only work when assigned to from\n"
+               "a function defined by func_odbc.so.\n",
+};
+
+static struct ast_custom_function hashkeys_function = {
+       .name = "HASHKEYS",
+       .synopsis = "Retrieve the keys of a HASH()",
+       .syntax = "HASHKEYS(<hashname>)",
+       .read = hashkeys_read,
+       .desc =
+               "Returns a comma-delimited list of the current keys of an associative array\n"
+               "defined by the HASH() function.  Note that if you iterate over the keys of\n"
+               "the result, adding keys during iteration will cause the result of the HASHKEYS\n"
+               "function to change.\n",
+};
+
 static struct ast_custom_function array_function = {
        .name = "ARRAY",
        .synopsis = "Allows setting multiple variables at once",
@@ -219,7 +397,7 @@ static struct ast_custom_function array_function = {
                "entire argument, since Set can take multiple arguments itself.\n",
 };
 
-static int acf_sprintf(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
+static int acf_sprintf(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 {
 #define SPRINTF_FLAG   0
 #define SPRINTF_WIDTH  1
@@ -362,7 +540,7 @@ static struct ast_custom_function sprintf_function = {
 "a format specifier is not recognized.\n",
 };
 
-static int quote(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
+static int quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 {
        char *bufptr = buf, *dataptr = data;
        *bufptr++ = '"';
@@ -392,7 +570,7 @@ static struct ast_custom_function quote_function = {
 };
 
 
-static int len(struct ast_channel *chan, char *cmd, char *data, char *buf,
+static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf,
               size_t len)
 {
        int length = 0;
@@ -412,7 +590,7 @@ static struct ast_custom_function len_function = {
        .read = len,
 };
 
-static int acf_strftime(struct ast_channel *chan, char *cmd, char *parse,
+static int acf_strftime(struct ast_channel *chan, const char *cmd, char *parse,
                        char *buf, size_t len)
 {
        AST_DECLARE_APP_ARGS(args,
@@ -448,7 +626,7 @@ static struct ast_custom_function strftime_function = {
        .read = acf_strftime,
 };
 
-static int acf_strptime(struct ast_channel *chan, char *cmd, char *data,
+static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data,
                        char *buf, size_t len)
 {
        AST_DECLARE_APP_ARGS(args,
@@ -500,7 +678,7 @@ static struct ast_custom_function strptime_function = {
        .read = acf_strptime,
 };
 
-static int function_eval(struct ast_channel *chan, char *cmd, char *data,
+static int function_eval(struct ast_channel *chan, const char *cmd, char *data,
                         char *buf, size_t len)
 {
        buf[0] = '\0';
@@ -531,7 +709,7 @@ static struct ast_custom_function eval_function = {
        .read = function_eval,
 };
 
-static int keypadhash(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
+static int keypadhash(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 {
        char *bufptr, *dataptr;
 
@@ -589,6 +767,9 @@ static int unload_module(void)
        res |= ast_custom_function_unregister(&eval_function);
        res |= ast_custom_function_unregister(&keypadhash_function);
        res |= ast_custom_function_unregister(&sprintf_function);
+       res |= ast_custom_function_unregister(&hashkeys_function);
+       res |= ast_custom_function_unregister(&hash_function);
+       res |= ast_unregister_application(app_clearhash);
 
        return res;
 }
@@ -608,6 +789,9 @@ static int load_module(void)
        res |= ast_custom_function_register(&eval_function);
        res |= ast_custom_function_register(&keypadhash_function);
        res |= ast_custom_function_register(&sprintf_function);
+       res |= ast_custom_function_register(&hashkeys_function);
+       res |= ast_custom_function_register(&hash_function);
+       res |= ast_register_application(app_clearhash, exec_clearhash, syn_clearhash, desc_clearhash);
 
        return res;
 }