Merge "contrib/sip_to_pjsip: handle setvar in conversion"
[asterisk/asterisk.git] / funcs / func_strings.c
index f50ea24..cb25385 100644 (file)
  * \brief String manipulation dialplan functions
  *
  * \author Tilghman Lesher
- * \author Anothony Minessale II 
+ * \author Anothony Minessale II
  * \ingroup functions
  */
 
-#include "asterisk.h"
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+#include "asterisk.h"
 
 #include <regex.h>
 #include <ctype.h>
@@ -38,11 +40,408 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/utils.h"
 #include "asterisk/app.h"
 #include "asterisk/localtime.h"
-
-static int function_fieldqty(struct ast_channel *chan, const char *cmd,
-                            char *parse, char *buf, size_t len)
+#include "asterisk/test.h"
+
+AST_THREADSTORAGE(result_buf);
+AST_THREADSTORAGE(tmp_buf);
+
+/*** DOCUMENTATION
+       <function name="FIELDQTY" language="en_US">
+               <synopsis>
+                       Count the fields with an arbitrary delimiter
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delim" required="true" />
+               </syntax>
+               <description>
+                       <para>The delimiter may be specified as a special or extended ASCII character, by encoding it.  The characters
+                       <literal>\n</literal>, <literal>\r</literal>, and <literal>\t</literal> are all recognized as the newline,
+                       carriage return, and tab characters, respectively.  Also, octal and hexadecimal specifications are recognized
+                       by the patterns <literal>\0nnn</literal> and <literal>\xHH</literal>, respectively.  For example, if you wanted
+                       to encode a comma as the delimiter, you could use either <literal>\054</literal> or <literal>\x2C</literal>.</para>
+                       <para>Example: If ${example} contains <literal>ex-amp-le</literal>, then ${FIELDQTY(example,-)} returns 3.</para>
+               </description>
+       </function>
+       <function name="FIELDNUM" language="en_US">
+               <synopsis>
+                       Return the 1-based offset of a field in a list
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delim" required="true" />
+                       <parameter name="value" required="true" />
+               </syntax>
+               <description>
+                       <para>Search the variable named <replaceable>varname</replaceable> for the string <replaceable>value</replaceable>
+                       delimited by <replaceable>delim</replaceable> and return a 1-based offset as to its location. If not found
+                       or an error occured, return <literal>0</literal>.</para>
+                       <para>The delimiter may be specified as a special or extended ASCII character, by encoding it.  The characters
+                       <literal>\n</literal>, <literal>\r</literal>, and <literal>\t</literal> are all recognized as the newline,
+                       carriage return, and tab characters, respectively.  Also, octal and hexadecimal specifications are recognized
+                       by the patterns <literal>\0nnn</literal> and <literal>\xHH</literal>, respectively.  For example, if you wanted
+                       to encode a comma as the delimiter, you could use either <literal>\054</literal> or <literal>\x2C</literal>.</para>
+                       <para>Example: If ${example} contains <literal>ex-amp-le</literal>, then ${FIELDNUM(example,-,amp)} returns 2.</para>
+               </description>
+       </function>
+       <function name="LISTFILTER" language="en_US">
+               <synopsis>Remove an item from a list, by name.</synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delim" required="true" default="," />
+                       <parameter name="value" required="true" />
+               </syntax>
+               <description>
+                       <para>Remove <replaceable>value</replaceable> from the list contained in the <replaceable>varname</replaceable>
+                       variable, where the list delimiter is specified by the <replaceable>delim</replaceable> parameter.  This is
+                       very useful for removing a single channel name from a list of channels, for example.</para>
+               </description>
+       </function>
+       <function name="FILTER" language="en_US">
+               <synopsis>
+                       Filter the string to include only the allowed characters
+               </synopsis>
+               <syntax>
+                       <parameter name="allowed-chars" required="true" />
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Permits all characters listed in <replaceable>allowed-chars</replaceable>,
+                       filtering all others outs. In addition to literally listing the characters,
+                       you may also use ranges of characters (delimited by a <literal>-</literal></para>
+                       <para>Hexadecimal characters started with a <literal>\x</literal>(i.e. \x20)</para>
+                       <para>Octal characters started with a <literal>\0</literal> (i.e. \040)</para>
+                       <para>Also <literal>\t</literal>,<literal>\n</literal> and <literal>\r</literal> are recognized.</para>
+                       <note><para>If you want the <literal>-</literal> character it needs to be prefixed with a
+                       <literal>\</literal></para></note>
+               </description>
+       </function>
+       <function name="REPLACE" language="en_US">
+               <synopsis>
+                       Replace a set of characters in a given string with another character.
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="find-chars" required="true" />
+                       <parameter name="replace-char" required="false" />
+               </syntax>
+               <description>
+                       <para>Iterates through a string replacing all the <replaceable>find-chars</replaceable> with
+                       <replaceable>replace-char</replaceable>.  <replaceable>replace-char</replaceable> may be either
+                       empty or contain one character.  If empty, all <replaceable>find-chars</replaceable> will be
+                       deleted from the output.</para>
+                       <note><para>The replacement only occurs in the output.  The original variable is not
+                       altered.</para></note>
+               </description>
+       </function>
+       <function name="STRREPLACE" language="en_US">
+               <synopsis>
+                       Replace instances of a substring within a string with another string.
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="find-string" required="true" />
+                       <parameter name="replace-string" required="false" />
+                       <parameter name="max-replacements" required="false" />
+               </syntax>
+               <description>
+                       <para>Searches for all instances of the <replaceable>find-string</replaceable> in provided variable and
+                       replaces them with <replaceable>replace-string</replaceable>.  If <replaceable>replace-string</replaceable>
+                       is an empty string, this will effecively delete that substring.  If <replaceable>max-replacements</replaceable>
+                       is specified, this function will stop after performing replacements <replaceable>max-replacements</replaceable> times.</para>
+                       <note><para>The replacement only occurs in the output.  The original variable is not altered.</para></note>
+               </description>
+       </function>
+       <function name="PASSTHRU" language="en_US">
+               <synopsis>
+                       Pass the given argument back as a value.
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="false" />
+               </syntax>
+               <description>
+                       <para>Literally returns the given <replaceable>string</replaceable>.  The intent is to permit
+                       other dialplan functions which take a variable name as an argument to be able to take a literal
+                       string, instead.</para>
+                       <note><para>The functions which take a variable name need to be passed var and not
+                       ${var}.  Similarly, use PASSTHRU() and not ${PASSTHRU()}.</para></note>
+                       <para>Example: ${CHANNEL} contains SIP/321-1</para>
+                       <para>         ${CUT(PASSTHRU(${CUT(CHANNEL,-,1)}),/,2)}) will return 321</para>
+               </description>
+       </function>
+       <function name="REGEX" language="en_US">
+               <synopsis>
+                       Check string against a regular expression.
+               </synopsis>
+               <syntax argsep=" ">
+                       <parameter name="&quot;regular expression&quot;" required="true" />
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Return <literal>1</literal> on regular expression match or <literal>0</literal> otherwise</para>
+                       <para>Please note that the space following the double quotes separating the
+                       regex from the data is optional and if present, is skipped. If a space is
+                       desired at the beginning of the data, then put two spaces there; the second
+                       will not be skipped.</para>
+               </description>
+       </function>
+       <application name="ClearHash" language="en_US">
+               <synopsis>
+                       Clear the keys from a specified hashname.
+               </synopsis>
+               <syntax>
+                       <parameter name="hashname" required="true" />
+               </syntax>
+               <description>
+                       <para>Clears all keys out of the specified <replaceable>hashname</replaceable>.</para>
+               </description>
+       </application>
+       <function name="HASH" language="en_US">
+               <synopsis>
+                       Implementation of a dialplan associative array
+               </synopsis>
+               <syntax>
+                       <parameter name="hashname" required="true" />
+                       <parameter name="hashkey" />
+               </syntax>
+               <description>
+                       <para>In two arguments mode, gets and sets values to corresponding keys within
+                       a named associative array. The single-argument mode will only work when assigned
+                       to from a function defined by func_odbc</para>
+               </description>
+       </function>
+       <function name="HASHKEYS" language="en_US">
+               <synopsis>
+                       Retrieve the keys of the HASH() function.
+               </synopsis>
+               <syntax>
+                       <parameter name="hashname" required="true" />
+               </syntax>
+               <description>
+                       <para>Returns a comma-delimited list of the current keys of the associative array
+                       defined by the HASH() function. Note that if you iterate over the keys of
+                       the result, adding keys during iteration will cause the result of the HASHKEYS()
+                       function to change.</para>
+               </description>
+       </function>
+       <function name="KEYPADHASH" language="en_US">
+               <synopsis>
+                       Hash the letters in string into equivalent keypad numbers.
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Example: ${KEYPADHASH(Les)} returns "537"</para>
+               </description>
+       </function>
+       <function name="ARRAY" language="en_US">
+               <synopsis>
+                       Allows setting multiple variables at once.
+               </synopsis>
+               <syntax>
+                       <parameter name="var1" required="true" />
+                       <parameter name="var2" required="false" multiple="true" />
+                       <parameter name="varN" required="false" />
+               </syntax>
+               <description>
+                       <para>The comma-delimited list passed as a value to which the function is set will
+                       be interpreted as a set of values to which the comma-delimited list of
+                       variable names in the argument should be set.</para>
+                       <para>Example: Set(ARRAY(var1,var2)=1,2) will set var1 to 1 and var2 to 2</para>
+               </description>
+       </function>
+       <function name="STRPTIME" language="en_US">
+               <synopsis>
+                       Returns the epoch of the arbitrary date/time string structured as described by the format.
+               </synopsis>
+               <syntax>
+                       <parameter name="datetime" required="true" />
+                       <parameter name="timezone" required="true" />
+                       <parameter name="format" required="true" />
+               </syntax>
+               <description>
+                       <para>This is useful for converting a date into <literal>EPOCH</literal> time,
+                       possibly to pass to an application like SayUnixTime or to calculate the difference
+                       between the two date strings</para>
+                       <para>Example: ${STRPTIME(2006-03-01 07:30:35,America/Chicago,%Y-%m-%d %H:%M:%S)} returns 1141219835</para>
+               </description>
+       </function>
+       <function name="STRFTIME" language="en_US">
+               <synopsis>
+                       Returns the current date/time in the specified format.
+               </synopsis>
+               <syntax>
+                       <parameter name="epoch" />
+                       <parameter name="timezone" />
+                       <parameter name="format" />
+               </syntax>
+               <description>
+                       <para>STRFTIME supports all of the same formats as the underlying C function
+                       <emphasis>strftime(3)</emphasis>.
+                       It also supports the following format: <literal>%[n]q</literal> - fractions of a second,
+                       with leading zeros.</para>
+                       <para>Example: <literal>%3q</literal> will give milliseconds and <literal>%1q</literal>
+                       will give tenths of a second. The default is set at milliseconds (n=3).
+                       The common case is to use it in combination with %S, as in <literal>%S.%3q</literal>.</para>
+               </description>
+               <see-also>
+                       <ref type="manpage">strftime(3)</ref>
+               </see-also>
+       </function>
+       <function name="EVAL" language="en_US">
+               <synopsis>
+                       Evaluate stored variables
+               </synopsis>
+               <syntax>
+                       <parameter name="variable" required="true" />
+               </syntax>
+               <description>
+                       <para>Using EVAL basically causes a string to be evaluated twice.
+                       When a variable or expression is in the dialplan, it will be
+                       evaluated at runtime. However, if the results of the evaluation
+                       is in fact another variable or expression, using EVAL will have it
+                       evaluated a second time.</para>
+                       <para>Example: If the <variable>MYVAR</variable> contains
+                       <variable>OTHERVAR</variable>, then the result of ${EVAL(
+                       <variable>MYVAR</variable>)} in the dialplan will be the
+                       contents of <variable>OTHERVAR</variable>. Normally just
+                       putting <variable>MYVAR</variable> in the dialplan the result
+                       would be <variable>OTHERVAR</variable>.</para>
+               </description>
+       </function>
+       <function name="TOUPPER" language="en_US">
+               <synopsis>
+                       Convert string to all uppercase letters.
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Example: ${TOUPPER(Example)} returns "EXAMPLE"</para>
+               </description>
+       </function>
+       <function name="TOLOWER" language="en_US">
+               <synopsis>
+                       Convert string to all lowercase letters.
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Example: ${TOLOWER(Example)} returns "example"</para>
+               </description>
+       </function>
+       <function name="LEN" language="en_US">
+               <synopsis>
+                       Return the length of the string given.
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Example: ${LEN(example)} returns 7</para>
+               </description>
+       </function>
+       <function name="QUOTE" language="en_US">
+               <synopsis>
+                       Quotes a given string, escaping embedded quotes as necessary
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Example: ${QUOTE(ab"c"de)} will return ""ab\"c\"de""</para>
+               </description>
+       </function>
+       <function name="CSV_QUOTE" language="en_US">
+               <synopsis>
+                       Quotes a given string for use in a CSV file, escaping embedded quotes as necessary
+               </synopsis>
+               <syntax>
+                       <parameter name="string" required="true" />
+               </syntax>
+               <description>
+                       <para>Example: ${CSV_QUOTE("a,b" 123)} will return """a,b"" 123"</para>
+               </description>
+       </function>
+       <function name="SHIFT" language="en_US">
+               <synopsis>
+                       Removes and returns the first item off of a variable containing delimited text
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delimiter" required="false" default="," />
+               </syntax>
+               <description>
+                       <para>Example:</para>
+                       <para>exten => s,1,Set(array=one,two,three)</para>
+                       <para>exten => s,n,While($["${SET(var=${SHIFT(array)})}" != ""])</para>
+                       <para>exten => s,n,NoOp(var is ${var})</para>
+                       <para>exten => s,n,EndWhile</para>
+                       <para>This would iterate over each value in array, left to right, and
+                               would result in NoOp(var is one), NoOp(var is two), and
+                               NoOp(var is three) being executed.
+                       </para>
+               </description>
+       </function>
+       <function name="POP" language="en_US">
+               <synopsis>
+                       Removes and returns the last item off of a variable containing delimited text
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delimiter" required="false" default="," />
+               </syntax>
+               <description>
+                       <para>Example:</para>
+                       <para>exten => s,1,Set(array=one,two,three)</para>
+                       <para>exten => s,n,While($["${SET(var=${POP(array)})}" != ""])</para>
+                       <para>exten => s,n,NoOp(var is ${var})</para>
+                       <para>exten => s,n,EndWhile</para>
+                       <para>This would iterate over each value in array, right to left, and
+                               would result in NoOp(var is three), NoOp(var is two), and
+                               NoOp(var is one) being executed.
+                       </para>
+               </description>
+       </function>
+       <function name="PUSH" language="en_US">
+               <synopsis>
+                       Appends one or more values to the end of a variable containing delimited text
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delimiter" required="false" default="," />
+               </syntax>
+               <description>
+                       <para>Example: Set(PUSH(array)=one,two,three) would append one,
+                               two, and three to the end of the values stored in the variable
+                               "array".
+                       </para>
+               </description>
+       </function>
+       <function name="UNSHIFT" language="en_US">
+               <synopsis>
+                       Inserts one or more values to the beginning of a variable containing delimited text
+               </synopsis>
+               <syntax>
+                       <parameter name="varname" required="true" />
+                       <parameter name="delimiter" required="false" default="," />
+               </syntax>
+               <description>
+                       <para>Example: Set(UNSHIFT(array)=one,two,three) would insert one,
+                               two, and three before the values stored in the variable
+                               "array".
+                       </para>
+               </description>
+       </function>
+ ***/
+
+static int function_fieldqty_helper(struct ast_channel *chan, const char *cmd,
+                            char *parse, char *buf, struct ast_str **sbuf, ssize_t len)
 {
-       char *varsubst, varval[8192], *varval2 = varval;
+       char *varsubst;
+       struct ast_str *str = ast_str_thread_get(&result_buf, 16);
        int fieldcount = 0;
        AST_DECLARE_APP_ARGS(args,
                             AST_APP_ARG(varname);
@@ -51,39 +450,260 @@ static int function_fieldqty(struct ast_channel *chan, const char *cmd,
        char delim[2] = "";
        size_t delim_used;
 
-       if (chan)
-               ast_autoservice_start(chan);
+       if (!str) {
+               return -1;
+       }
 
        AST_STANDARD_APP_ARGS(args, parse);
        if (args.delim) {
                ast_get_encoded_char(args.delim, delim, &delim_used);
 
-               varsubst = alloca(strlen(args.varname) + 4);
+               varsubst = ast_alloca(strlen(args.varname) + 4);
 
                sprintf(varsubst, "${%s}", args.varname);
-               pbx_substitute_variables_helper(chan, varsubst, varval, sizeof(varval) - 1);
-               if (ast_strlen_zero(varval2))
+               ast_str_substitute_variables(&str, 0, chan, varsubst);
+               if (ast_str_strlen(str) == 0) {
                        fieldcount = 0;
-               else {
-                       while (strsep(&varval2, delim))
+               } else {
+                       char *varval = ast_str_buffer(str);
+                       while (strsep(&varval, delim)) {
                                fieldcount++;
+                       }
                }
        } else {
                fieldcount = 1;
        }
-       snprintf(buf, len, "%d", fieldcount);
-
-       if (chan)
-               ast_autoservice_stop(chan);
+       if (sbuf) {
+               ast_str_set(sbuf, len, "%d", fieldcount);
+       } else {
+               snprintf(buf, len, "%d", fieldcount);
+       }
 
        return 0;
 }
 
+static int function_fieldqty(struct ast_channel *chan, const char *cmd,
+                            char *parse, char *buf, size_t len)
+{
+       return function_fieldqty_helper(chan, cmd, parse, buf, NULL, len);
+}
+
+static int function_fieldqty_str(struct ast_channel *chan, const char *cmd,
+                                char *parse, struct ast_str **buf, ssize_t len)
+{
+       return function_fieldqty_helper(chan, cmd, parse, NULL, buf, len);
+}
+
 static struct ast_custom_function fieldqty_function = {
        .name = "FIELDQTY",
-       .synopsis = "Count the fields, with an arbitrary delimiter",
-       .syntax = "FIELDQTY(<varname>,<delim>)",
        .read = function_fieldqty,
+       .read2 = function_fieldqty_str,
+};
+
+static int function_fieldnum_helper(struct ast_channel *chan, const char *cmd,
+                               char *parse, char *buf, struct ast_str **sbuf, ssize_t len)
+{
+       char *varsubst, *field;
+       struct ast_str *str = ast_str_thread_get(&result_buf, 16);
+       int fieldindex = 0, res = 0;
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(varname);
+               AST_APP_ARG(delim);
+               AST_APP_ARG(field);
+       );
+       char delim[2] = "";
+       size_t delim_used;
+
+       if (!str) {
+               return -1;
+       }
+
+       AST_STANDARD_APP_ARGS(args, parse);
+
+       if (args.argc < 3) {
+               ast_log(LOG_ERROR, "Usage: FIELDNUM(<listname>,<delimiter>,<fieldvalue>)\n");
+               res = -1;
+       } else {
+               varsubst = ast_alloca(strlen(args.varname) + 4);
+               sprintf(varsubst, "${%s}", args.varname);
+
+               ast_str_substitute_variables(&str, 0, chan, varsubst);
+
+               if (ast_str_strlen(str) == 0 || ast_strlen_zero(args.delim)) {
+                       fieldindex = 0;
+               } else if (ast_get_encoded_char(args.delim, delim, &delim_used) == -1) {
+                       res = -1;
+               } else {
+                       char *varval = ast_str_buffer(str);
+
+                       while ((field = strsep(&varval, delim)) != NULL) {
+                               fieldindex++;
+
+                               if (!strcasecmp(field, args.field)) {
+                                       break;
+                               }
+                       }
+
+                       if (!field) {
+                               fieldindex = 0;
+                       }
+
+                       res = 0;
+               }
+       }
+
+       if (sbuf) {
+               ast_str_set(sbuf, len, "%d", fieldindex);
+       } else {
+               snprintf(buf, len, "%d", fieldindex);
+       }
+
+       return res;
+}
+
+static int function_fieldnum(struct ast_channel *chan, const char *cmd,
+                            char *parse, char *buf, size_t len)
+{
+       return function_fieldnum_helper(chan, cmd, parse, buf, NULL, len);
+}
+
+static int function_fieldnum_str(struct ast_channel *chan, const char *cmd,
+                                char *parse, struct ast_str **buf, ssize_t len)
+{
+       return function_fieldnum_helper(chan, cmd, parse, NULL, buf, len);
+}
+
+static struct ast_custom_function fieldnum_function = {
+       .name = "FIELDNUM",
+       .read = function_fieldnum,
+       .read2 = function_fieldnum_str,
+};
+
+static int listfilter(struct ast_channel *chan, const char *cmd, char *parse, char *buf, struct ast_str **bufstr, ssize_t len)
+{
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(listname);
+               AST_APP_ARG(delimiter);
+               AST_APP_ARG(fieldvalue);
+       );
+       struct ast_str *orig_list = ast_str_thread_get(&tmp_buf, 16);
+       const char *begin, *cur, *next;
+       int dlen, flen, first = 1;
+       struct ast_str *result, **result_ptr = &result;
+       char *delim, *varsubst;
+
+       AST_STANDARD_APP_ARGS(args, parse);
+
+       if (buf) {
+               if (!(result = ast_str_thread_get(&result_buf, 16))) {
+                       return -1;
+               }
+       } else {
+               /* Place the result directly into the output buffer */
+               result_ptr = bufstr;
+       }
+
+       if (args.argc < 3) {
+               ast_log(LOG_ERROR, "Usage: LISTFILTER(<listname>,<delimiter>,<fieldvalue>)\n");
+               return -1;
+       }
+
+       varsubst = ast_alloca(strlen(args.listname) + 4);
+       sprintf(varsubst, "${%s}", args.listname);
+
+       /* If we don't lock the channel, the variable could disappear out from underneath us. */
+       if (chan) {
+               ast_channel_lock(chan);
+       }
+       ast_str_substitute_variables(&orig_list, 0, chan, varsubst);
+       if (!ast_str_strlen(orig_list)) {
+               if (chan) {
+                       ast_channel_unlock(chan);
+               }
+               return -1;
+       }
+
+       /* If the string isn't there, just copy out the string and be done with it. */
+       if (!strstr(ast_str_buffer(orig_list), args.fieldvalue)) {
+               if (buf) {
+                       ast_copy_string(buf, ast_str_buffer(orig_list), len);
+               } else {
+                       ast_str_set(result_ptr, len, "%s", ast_str_buffer(orig_list));
+               }
+               if (chan) {
+                       ast_channel_unlock(chan);
+               }
+               return 0;
+       }
+
+       dlen = strlen(args.delimiter);
+       delim = ast_alloca(dlen + 1);
+       ast_get_encoded_str(args.delimiter, delim, dlen + 1);
+
+       if ((dlen = strlen(delim)) == 0) {
+               delim = ",";
+               dlen = 1;
+       }
+
+       flen = strlen(args.fieldvalue);
+
+       ast_str_reset(*result_ptr);
+       /* Enough space for any result */
+       if (len > -1) {
+               ast_str_make_space(result_ptr, len ? len : ast_str_strlen(orig_list) + 1);
+       }
+
+       begin = ast_str_buffer(orig_list);
+       next = strstr(begin, delim);
+
+       do {
+               /* Find next boundary */
+               if (next) {
+                       cur = next;
+                       next = strstr(cur + dlen, delim);
+               } else {
+                       cur = strchr(begin + dlen, '\0');
+               }
+
+               if (flen == cur - begin && !strncmp(begin, args.fieldvalue, flen)) {
+                       /* Skip field */
+                       begin += flen + dlen;
+               } else {
+                       /* Copy field to output */
+                       if (!first) {
+                               ast_str_append(result_ptr, len, "%s", delim);
+                       }
+
+                       ast_str_append_substr(result_ptr, len, begin, cur - begin);
+                       first = 0;
+                       begin = cur + dlen;
+               }
+       } while (*cur != '\0');
+       if (chan) {
+               ast_channel_unlock(chan);
+       }
+
+       if (buf) {
+               ast_copy_string(buf, ast_str_buffer(result), len);
+       }
+
+       return 0;
+}
+
+static int listfilter_read(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
+{
+       return listfilter(chan, cmd, parse, buf, NULL, len);
+}
+
+static int listfilter_read2(struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
+{
+       return listfilter(chan, cmd, parse, NULL, buf, len);
+}
+
+static struct ast_custom_function listfilter_function = {
+       .name = "LISTFILTER",
+       .read = listfilter_read,
+       .read2 = listfilter_read2,
 };
 
 static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *buf,
@@ -93,19 +713,25 @@ static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *
                             AST_APP_ARG(allowed);
                             AST_APP_ARG(string);
        );
-       char *outbuf = buf, ac;
+       char *outbuf = buf;
+       unsigned char ac;
        char allowed[256] = "";
        size_t allowedlen = 0;
+       int32_t bitfield[8] = { 0, }; /* 256 bits */
 
-       AST_STANDARD_APP_ARGS(args, parse);
+       AST_STANDARD_RAW_ARGS(args, parse);
 
        if (!args.string) {
                ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>,<string>)\n");
                return -1;
        }
 
+       if (args.allowed[0] == '"' && !ast_opt_dont_warn) {
+               ast_log(LOG_WARNING, "FILTER allowed characters includes the quote (\") character.  This may not be what you want.\n");
+       }
+
        /* Expand ranges */
-       for (; *(args.allowed) && allowedlen < sizeof(allowed); (args.allowed)++) {
+       for (; *(args.allowed);) {
                char c1 = 0, c2 = 0;
                size_t consumed = 0;
 
@@ -115,23 +741,34 @@ static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *
 
                if (*(args.allowed) == '-') {
                        if (ast_get_encoded_char(args.allowed + 1, &c2, &consumed))
-                               c2 = -1;
+                               c2 = c1;
                        args.allowed += consumed + 1;
 
+                       if ((unsigned char) c2 < (unsigned char) c1 && !ast_opt_dont_warn) {
+                               ast_log(LOG_WARNING, "Range wrapping in FILTER(%s,%s).  This may not be what you want.\n", parse, args.string);
+                       }
+
                        /*!\note
                         * Looks a little strange, until you realize that we can overflow
                         * the size of a char.
                         */
-                       for (ac = c1; ac != c2 && allowedlen < sizeof(allowed) - 1; ac++)
-                               allowed[allowedlen++] = ac;
-                       allowed[allowedlen++] = ac;
+                       for (ac = (unsigned char) c1; ac != (unsigned char) c2; ac++) {
+                               bitfield[ac / 32] |= 1 << (ac % 32);
+                       }
+                       bitfield[ac / 32] |= 1 << (ac % 32);
 
                        ast_debug(4, "c1=%d, c2=%d\n", c1, c2);
+               } else {
+                       ac = (unsigned char) c1;
+                       ast_debug(4, "c1=%d, consumed=%d, args.allowed=%s\n", c1, (int) consumed, args.allowed - consumed);
+                       bitfield[ac / 32] |= 1 << (ac % 32);
+               }
+       }
 
-                       /* Decrement before the loop increment */
-                       (args.allowed)--;
-               } else
-                       allowed[allowedlen++] = c1;
+       for (ac = 1; ac != 0; ac++) {
+               if (bitfield[ac / 32] & (1 << (ac % 32))) {
+                       allowed[allowedlen++] = ac;
+               }
        }
 
        ast_debug(1, "Allowed: %s\n", allowed);
@@ -147,16 +784,165 @@ static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *
 
 static struct ast_custom_function filter_function = {
        .name = "FILTER",
-       .synopsis = "Filter the string to include only the allowed characters",
-       .syntax = "FILTER(<allowed-chars>,<string>)",
        .read = filter,
-       .desc =
-"Permits all characters listed in <allowed-chars>, filtering all others out.\n"
-"In addition to literally listing the characters, you may also use ranges of\n"
-"characters (delimited by a '-'), as well as hexadecimal characters started\n"
-"with a \\x (i.e. \\x20) and octal characters started with \\0 (i.e. \\040).\n"
-"Also, \\t, \\n, and \\r are recognized.  If you want a literal '-' character,\n"
-"simply prefix it with a '\\'\n",
+};
+
+static int replace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(varname);
+               AST_APP_ARG(find);
+               AST_APP_ARG(replace);
+       );
+       char *strptr, *varsubst;
+       RAII_VAR(struct ast_str *, str, ast_str_create(16), ast_free);
+       char find[256]; /* Only 256 characters possible */
+       char replace[2] = "";
+       size_t unused;
+
+       AST_STANDARD_APP_ARGS(args, data);
+
+       if (!str) {
+               return -1;
+       }
+
+       if (args.argc < 2) {
+               ast_log(LOG_ERROR, "Usage: %s(<varname>,<search-chars>[,<replace-char>])\n", cmd);
+               return -1;
+       }
+
+       /* Decode escapes */
+       ast_get_encoded_str(args.find, find, sizeof(find));
+       ast_get_encoded_char(args.replace, replace, &unused);
+
+       if (ast_strlen_zero(find) || ast_strlen_zero(args.varname)) {
+               ast_log(LOG_ERROR, "The characters to search for and the variable name must not be empty.\n");
+               return -1;
+       }
+
+       varsubst = ast_alloca(strlen(args.varname) + 4);
+       sprintf(varsubst, "${%s}", args.varname);
+       ast_str_substitute_variables(&str, 0, chan, varsubst);
+
+       if (!ast_str_strlen(str)) {
+               /* Blank, nothing to replace */
+               return -1;
+       }
+
+       ast_debug(3, "String to search: (%s)\n", ast_str_buffer(str));
+       ast_debug(3, "Characters to find: (%s)\n", find);
+       ast_debug(3, "Character to replace with: (%s)\n", replace);
+
+       for (strptr = ast_str_buffer(str); *strptr; strptr++) {
+               /* buf is already a mutable buffer, so we construct the result
+                * directly there */
+               if (strchr(find, *strptr)) {
+                       if (ast_strlen_zero(replace)) {
+                               memmove(strptr, strptr + 1, strlen(strptr + 1) + 1);
+                               strptr--;
+                       } else {
+                               /* Replace character */
+                               *strptr = *replace;
+                       }
+               }
+       }
+
+       ast_str_set(buf, len, "%s", ast_str_buffer(str));
+       return 0;
+}
+
+static struct ast_custom_function replace_function = {
+       .name = "REPLACE",
+       .read2 = replace,
+};
+
+static int strreplace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+       char *varsubstr; /* substring for input var */
+       char *start; /* Starting pos of substring search. */
+       char *end; /* Ending pos of substring search. */
+       int find_size; /* length of given find-string */
+       unsigned max_matches; /* number of matches we find before terminating search */
+       unsigned count; /* loop counter */
+       struct ast_str *str = ast_str_thread_get(&result_buf, 16); /* Holds the data obtained from varname */
+
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(varname);
+               AST_APP_ARG(find_string);
+               AST_APP_ARG(replace_string);
+               AST_APP_ARG(max_replacements);
+               AST_APP_ARG(other);     /* Any remining unused arguments */
+       );
+
+       /* Guarantee output string is empty to start with. */
+       ast_str_reset(*buf);
+
+       if (!str) {
+               /* We failed to allocate str, forget it.  We failed. */
+               return -1;
+       }
+
+       /* Parse the arguments. */
+       AST_STANDARD_APP_ARGS(args, data);
+
+       if (args.argc < 2) {
+               /* Didn't receive enough arguments to do anything */
+               ast_log(LOG_ERROR,
+                       "Usage: %s(<varname>,<find-string>[,<replace-string>,[<max-replacements>]])\n",
+                       cmd);
+               return -1;
+       }
+
+       /* No var name specified. Return failure, string is already empty. */
+       if (ast_strlen_zero(args.varname)) {
+               return -1;
+       }
+
+       /* Zero length find strings are a no-no. Kill the function if we run into one. */
+       if (ast_strlen_zero(args.find_string)) {
+               ast_log(LOG_ERROR, "No <find-string> specified\n");
+               return -1;
+       }
+       find_size = strlen(args.find_string);
+
+       /* set varsubstr to the matching variable */
+       varsubstr = ast_alloca(strlen(args.varname) + 4);
+       sprintf(varsubstr, "${%s}", args.varname);
+       ast_str_substitute_variables(&str, 0, chan, varsubstr);
+
+       /* Determine how many replacements are allowed. */
+       if (!args.max_replacements
+               || (max_matches = atoi(args.max_replacements)) <= 0) {
+               /* Unlimited replacements are allowed. */
+               max_matches = -1;
+       }
+
+       /* Generate the search and replaced string. */
+       start = ast_str_buffer(str);
+       for (count = 0; count < max_matches; ++count) {
+               end = strstr(start, args.find_string);
+               if (!end) {
+                       /* Did not find a matching substring in the remainder. */
+                       break;
+               }
+
+               /* Replace the found substring. */
+               *end = '\0';
+               ast_str_append(buf, len, "%s", start);
+               if (args.replace_string) {
+                       /* Append the replacement string */
+                       ast_str_append(buf, len, "%s", args.replace_string);
+               }
+               start = end + find_size;
+       }
+       ast_str_append(buf, len, "%s", start);
+
+       return 0;
+}
+
+static struct ast_custom_function strreplace_function = {
+       .name = "STRREPLACE",
+       .read2 = strreplace,
 };
 
 static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf,
@@ -188,7 +974,7 @@ static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *b
                ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, parse, buf);
                return -1;
        }
-       
+
        strcpy(buf, regexec(&regexbuf, args.str, 0, NULL, 0) ? "0" : "1");
 
        regfree(&regexbuf);
@@ -198,13 +984,6 @@ static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *b
 
 static struct ast_custom_function regex_function = {
        .name = "REGEX",
-       .synopsis = "Regular Expression",
-       .desc =  
-               "Returns 1 if data matches regular expression, or 0 otherwise.\n"
-               "Please note that the space following the double quotes separating the regex from the data\n"
-               "is optional and if present, is skipped. If a space is desired at the beginning of the data,\n"
-               "then put two spaces there; the second will not be skipped.\n",
-       .syntax = "REGEX(\"<regular expression>\" <data>)",
        .read = regex,
 };
 
@@ -212,18 +991,14 @@ static struct ast_custom_function regex_function = {
 #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_TRAVERSE_SAFE_BEGIN(ast_channel_varshead(chan), var, entries) {
+               if (strncmp(prefix, ast_var_name(var), len) == 0) {
                        AST_LIST_REMOVE_CURRENT(entries);
                        ast_free(var);
                }
@@ -231,7 +1006,7 @@ static void clearvar_prefix(struct ast_channel *chan, const char *prefix)
        AST_LIST_TRAVERSE_SAFE_END
 }
 
-static int exec_clearhash(struct ast_channel *chan, void *data)
+static int exec_clearhash(struct ast_channel *chan, const char *data)
 {
        char prefix[80];
        snprintf(prefix, sizeof(prefix), HASH_PREFIX, data ? (char *)data : "null");
@@ -251,12 +1026,10 @@ static int array(struct ast_channel *chan, const char *cmd, char *var,
        char *origvar = "", *value2, varname[256];
        int i, ishash = 0;
 
-       value2 = ast_strdupa(value);
-       if (!var || !value2)
+       if (!var) {
                return -1;
-
-       if (chan)
-               ast_autoservice_start(chan);
+       }
+       value2 = ast_strdupa(value);
 
        if (!strcmp(cmd, "HASH")) {
                const char *var2 = pbx_builtin_getvar_helper(chan, "~ODBCFIELDS~");
@@ -277,17 +1050,26 @@ static int array(struct ast_channel *chan, const char *cmd, char *var,
         * want them to be surprised by the result.  Hence, we prefer commas as the
         * delimiter, but we'll fall back to vertical bars if commas aren't found.
         */
-       ast_debug(1, "array (%s=%s)\n", var, value2);
+       ast_debug(1, "array (%s=%s)\n", var, S_OR(value2, ""));
        AST_STANDARD_APP_ARGS(arg1, var);
 
        AST_STANDARD_APP_ARGS(arg2, value2);
 
        for (i = 0; i < arg1.argc; i++) {
                ast_debug(1, "array set value (%s=%s)\n", arg1.var[i],
-                               arg2.val[i]);
+                               S_OR(arg2.val[i], ""));
                if (i < arg2.argc) {
                        if (ishash) {
-                               snprintf(varname, sizeof(varname), HASH_FORMAT, origvar, arg1.var[i]);
+                               if (origvar[0] == '_') {
+                                       if (origvar[1] == '_') {
+                                               snprintf(varname, sizeof(varname), "__" HASH_FORMAT, origvar + 2, arg1.var[i]);
+                                       } else {
+                                               snprintf(varname, sizeof(varname), "_" HASH_FORMAT, origvar + 1, arg1.var[i]);
+                                       }
+                               } else {
+                                       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]);
@@ -304,25 +1086,26 @@ static int array(struct ast_channel *chan, const char *cmd, char *var,
                }
        }
 
-       if (chan)
-               ast_autoservice_stop(chan);
-
        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);
+       struct ast_str *prefix = ast_str_alloca(80);
+
+       if (!chan) {
+               ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
+               return -1;
+       }
 
+       ast_str_set(&prefix, -1, HASH_PREFIX, data);
        memset(buf, 0, len);
-       AST_LIST_TRAVERSE(&chan->varshead, newvar, entries) {
-               if (strncasecmp(prefix, ast_var_name(newvar), plen) == 0) {
+
+       AST_LIST_TRAVERSE(ast_channel_varshead(chan), newvar, entries) {
+               if (strncmp(ast_str_buffer(prefix), ast_var_name(newvar), ast_str_strlen(prefix)) == 0) {
                        /* Copy everything after the prefix */
-                       strncat(buf, ast_var_name(newvar) + plen, len - strlen(buf) - 1);
+                       strncat(buf, ast_var_name(newvar) + ast_str_strlen(prefix), len - strlen(buf) - 1);
                        /* Trim the trailing ~ */
                        buf[strlen(buf) - 1] = ',';
                }
@@ -332,6 +1115,34 @@ static int hashkeys_read(struct ast_channel *chan, const char *cmd, char *data,
        return 0;
 }
 
+static int hashkeys_read2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+       struct ast_var_t *newvar;
+       struct ast_str *prefix = ast_str_alloca(80);
+       char *tmp;
+
+       if (!chan) {
+               ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
+               return -1;
+       }
+
+       ast_str_set(&prefix, -1, HASH_PREFIX, data);
+
+       AST_LIST_TRAVERSE(ast_channel_varshead(chan), newvar, entries) {
+               if (strncmp(ast_str_buffer(prefix), ast_var_name(newvar), ast_str_strlen(prefix)) == 0) {
+                       /* Copy everything after the prefix */
+                       ast_str_append(buf, len, "%s", ast_var_name(newvar) + ast_str_strlen(prefix));
+                       /* Trim the trailing ~ */
+                       tmp = ast_str_buffer(*buf);
+                       tmp[ast_str_strlen(*buf) - 1] = ',';
+               }
+       }
+       /* Trim the trailing comma */
+       tmp = ast_str_buffer(*buf);
+       tmp[ast_str_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];
@@ -346,7 +1157,15 @@ static int hash_write(struct ast_channel *chan, const char *cmd, char *var, cons
        }
 
        AST_STANDARD_APP_ARGS(arg, var);
-       snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg.hashkey);
+       if (arg.hashname[0] == '_') {
+               if (arg.hashname[1] == '_') {
+                       snprintf(varname, sizeof(varname), "__" HASH_FORMAT, arg.hashname + 2, arg.hashkey);
+               } else {
+                       snprintf(varname, sizeof(varname), "_" HASH_FORMAT, arg.hashname + 1, arg.hashkey);
+               }
+       } else {
+               snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg.hashkey);
+       }
        pbx_builtin_setvar_helper(chan, varname, value);
 
        return 0;
@@ -376,6 +1195,11 @@ static int hash_read(struct ast_channel *chan, const char *cmd, char *data, char
                        AST_APP_ARG(col)[100];
                );
 
+               if (!chan) {
+                       ast_log(LOG_WARNING, "No channel and only 1 parameter was provided to %s function.\n", cmd);
+                       return -1;
+               }
+
                /* Get column names, in no particular order */
                hashkeys_read(chan, "HASHKEYS", arg.hashname, colnames, sizeof(colnames));
                pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", colnames);
@@ -400,189 +1224,38 @@ static int hash_read(struct ast_channel *chan, const char *cmd, char *data, char
 
 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",
+       .read2 = hashkeys_read2,
 };
 
 static struct ast_custom_function array_function = {
        .name = "ARRAY",
-       .synopsis = "Allows setting multiple variables at once",
-       .syntax = "ARRAY(var1[,var2[...][,varN]])",
        .write = array,
-       .desc =
-               "The comma-separated list passed as a value to which the function is set will\n"
-               "be interpreted as a set of values to which the comma-separated list of\n"
-               "variable names in the argument should be set.\n"
-               "Hence, Set(ARRAY(var1,var2)=1,2) will set var1 to 1 and var2 to 2.\n",
 };
 
-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
-#define SPRINTF_PRECISION      2
-#define SPRINTF_LENGTH 3
-#define SPRINTF_CONVERSION     4
-       int i, state = -1, argcount = 0;
-       char *formatstart = NULL, *bufptr = buf;
-       char formatbuf[256] = "";
-       int tmpi;
-       double tmpd;
-       AST_DECLARE_APP_ARGS(arg,
-                               AST_APP_ARG(format);
-                               AST_APP_ARG(var)[100];
-       );
-
-       AST_STANDARD_APP_ARGS(arg, data);
-
-       /* Scan the format, converting each argument into the requisite format type. */
-       for (i = 0; arg.format[i]; i++) {
-               switch (state) {
-               case SPRINTF_FLAG:
-                       if (strchr("#0- +'I", arg.format[i]))
-                               break;
-                       state = SPRINTF_WIDTH;
-               case SPRINTF_WIDTH:
-                       if (arg.format[i] >= '0' && arg.format[i] <= '9')
-                               break;
-
-                       /* Next character must be a period to go into a precision */
-                       if (arg.format[i] == '.') {
-                               state = SPRINTF_PRECISION;
-                       } else {
-                               state = SPRINTF_LENGTH;
-                               i--;
-                       }
-                       break;
-               case SPRINTF_PRECISION:
-                       if (arg.format[i] >= '0' && arg.format[i] <= '9')
-                               break;
-                       state = SPRINTF_LENGTH;
-               case SPRINTF_LENGTH:
-                       if (strchr("hl", arg.format[i])) {
-                               if (arg.format[i + 1] == arg.format[i])
-                                       i++;
-                               state = SPRINTF_CONVERSION;
-                               break;
-                       } else if (strchr("Lqjzt", arg.format[i])) {
-                               state = SPRINTF_CONVERSION;
-                               break;
-                       }
-                       state = SPRINTF_CONVERSION;
-               case SPRINTF_CONVERSION:
-                       if (strchr("diouxXc", arg.format[i])) {
-                               /* Integer */
-
-                               /* Isolate this format alone */
-                               ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
-                               formatbuf[&arg.format[i] - formatstart + 1] = '\0';
-
-                               /* Convert the argument into the required type */
-                               if (sscanf(arg.var[argcount++], "%d", &tmpi) != 1) {
-                                       ast_log(LOG_ERROR, "Argument '%s' is not an integer number for format '%s'\n", arg.var[argcount - 1], formatbuf);
-                                       goto sprintf_fail;
-                               }
-
-                               /* Format the argument */
-                               snprintf(bufptr, buf + len - bufptr, formatbuf, tmpi);
-
-                               /* Update the position of the next parameter to print */
-                               bufptr = strchr(buf, '\0');
-                       } else if (strchr("eEfFgGaA", arg.format[i])) {
-                               /* Double */
-
-                               /* Isolate this format alone */
-                               ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
-                               formatbuf[&arg.format[i] - formatstart + 1] = '\0';
-
-                               /* Convert the argument into the required type */
-                               if (sscanf(arg.var[argcount++], "%lf", &tmpd) != 1) {
-                                       ast_log(LOG_ERROR, "Argument '%s' is not a floating point number for format '%s'\n", arg.var[argcount - 1], formatbuf);
-                                       goto sprintf_fail;
-                               }
-
-                               /* Format the argument */
-                               snprintf(bufptr, buf + len - bufptr, formatbuf, tmpd);
-
-                               /* Update the position of the next parameter to print */
-                               bufptr = strchr(buf, '\0');
-                       } else if (arg.format[i] == 's') {
-                               /* String */
-
-                               /* Isolate this format alone */
-                               ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
-                               formatbuf[&arg.format[i] - formatstart + 1] = '\0';
-
-                               /* Format the argument */
-                               snprintf(bufptr, buf + len - bufptr, formatbuf, arg.var[argcount++]);
-
-                               /* Update the position of the next parameter to print */
-                               bufptr = strchr(buf, '\0');
-                       } else if (arg.format[i] == '%') {
-                               /* Literal data to copy */
-                               *bufptr++ = arg.format[i];
-                       } else {
-                               /* Not supported */
+static int quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+{
+       char *bufptr = buf, *dataptr = data;
 
-                               /* Isolate this format alone */
-                               ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
-                               formatbuf[&arg.format[i] - formatstart + 1] = '\0';
+       if (len < 3){ /* at least two for quotes and one for binary zero */
+               ast_log(LOG_ERROR, "Not enough buffer\n");
+               return -1;
+       }
 
-                               ast_log(LOG_ERROR, "Format type not supported: '%s' with argument '%s'\n", formatbuf, arg.var[argcount++]);
-                               goto sprintf_fail;
-                       }
-                       state = -1;
-                       break;
-               default:
-                       if (arg.format[i] == '%') {
-                               state = SPRINTF_FLAG;
-                               formatstart = &arg.format[i];
-                               break;
-                       } else {
-                               /* Literal data to copy */
-                               *bufptr++ = arg.format[i];
-                       }
-               }
+       if (ast_strlen_zero(data)) {
+               ast_log(LOG_WARNING, "No argument specified!\n");
+               ast_copy_string(buf, "\"\"", len);
+               return 0;
        }
-       return 0;
-sprintf_fail:
-       return -1;
-}
-
-static struct ast_custom_function sprintf_function = {
-       .name = "SPRINTF",
-       .synopsis = "Format a variable according to a format string",
-       .syntax = "SPRINTF(<format>,<arg1>[,...<argN>])",
-       .read = acf_sprintf,
-       .desc =
-"Parses the format string specified and returns a string matching that format.\n"
-"Supports most options supported by sprintf(3).  Returns a shortened string if\n"
-"a format specifier is not recognized.\n",
-};
 
-static int quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
-{
-       char *bufptr = buf, *dataptr = data;
        *bufptr++ = '"';
-       for (; bufptr < buf + len - 1; dataptr++) {
+       for (; bufptr < buf + len - 3; dataptr++) {
                if (*dataptr == '\\') {
                        *bufptr++ = '\\';
                        *bufptr++ = '\\';
@@ -602,88 +1275,105 @@ static int quote(struct ast_channel *chan, const char *cmd, char *data, char *bu
 
 static struct ast_custom_function quote_function = {
        .name = "QUOTE",
-       .synopsis = "Quotes a given string, escaping embedded quotes as necessary",
-       .syntax = "QUOTE(<string>)",
        .read = quote,
 };
 
+static int csv_quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+{
+       char *bufptr = buf, *dataptr = data;
+
+       if (len < 3) { /* at least two for quotes and one for binary zero */
+               ast_log(LOG_ERROR, "Not enough buffer\n");
+               return -1;
+       }
+
+       if (ast_strlen_zero(data)) {
+               ast_copy_string(buf, "\"\"", len);
+               return 0;
+       }
+
+       *bufptr++ = '"';
+       for (; bufptr < buf + len - 3; dataptr++){
+               if (*dataptr == '"') {
+                       *bufptr++ = '"';
+                       *bufptr++ = '"';
+               } else if (*dataptr == '\0') {
+                       break;
+               } else {
+                       *bufptr++ = *dataptr;
+               }
+       }
+       *bufptr++ = '"';
+       *bufptr='\0';
+       return 0;
+}
+
+static struct ast_custom_function csv_quote_function = {
+       .name = "CSV_QUOTE",
+       .read = csv_quote,
+};
 
-static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf,
-              size_t len)
+static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
 {
        int length = 0;
 
        if (data)
                length = strlen(data);
 
-       snprintf(buf, len, "%d", length);
+       snprintf(buf, buflen, "%d", length);
 
        return 0;
 }
 
 static struct ast_custom_function len_function = {
        .name = "LEN",
-       .synopsis = "Returns the length of the argument given",
-       .syntax = "LEN(<string>)",
        .read = len,
+       .read_max = 12,
 };
 
 static int acf_strftime(struct ast_channel *chan, const char *cmd, char *parse,
-                       char *buf, size_t len)
+                       char *buf, size_t buflen)
 {
        AST_DECLARE_APP_ARGS(args,
                             AST_APP_ARG(epoch);
                             AST_APP_ARG(timezone);
                             AST_APP_ARG(format);
        );
-       struct timeval tv;
+       struct timeval when;
        struct ast_tm tm;
 
        buf[0] = '\0';
 
        AST_STANDARD_APP_ARGS(args, parse);
 
-       ast_get_timeval(args.epoch, &tv, ast_tvnow(), NULL);
-       ast_localtime(&tv, &tm, args.timezone);
+       ast_get_timeval(args.epoch, &when, ast_tvnow(), NULL);
+       ast_localtime(&when, &tm, args.timezone);
 
        if (!args.format)
                args.format = "%c";
 
-       if (ast_strftime(buf, len, args.format, &tm) <= 0)
+       if (ast_strftime(buf, buflen, args.format, &tm) <= 0)
                ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
 
-       buf[len - 1] = '\0';
+       buf[buflen - 1] = '\0';
 
        return 0;
 }
 
 static struct ast_custom_function strftime_function = {
        .name = "STRFTIME",
-       .synopsis = "Returns the current date/time in a specified format.",
-       .syntax = "STRFTIME([<epoch>][,[timezone][,format]])",
-       .desc =
-"STRFTIME sports all of the same formats as the underlying C function\n"
-"strftime(3) - see the man page for details.  It also supports the\n"
-"following format:\n"
-" %[n]q - fractions of a second, with leading zeroes.  For example, %3q will\n"
-"         give milliseconds and %1q will give tenths of a second.  The default\n"
-"         is to output milliseconds (n=3).  The common case is to use it in\n"
-"         combination with %S, as in \"%S.%3q\".\n",
        .read = acf_strftime,
 };
 
 static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data,
-                       char *buf, size_t len)
+                       char *buf, size_t buflen)
 {
        AST_DECLARE_APP_ARGS(args,
                             AST_APP_ARG(timestring);
                             AST_APP_ARG(timezone);
                             AST_APP_ARG(format);
        );
-       union {
-               struct ast_tm atm;
-               struct tm time;
-       } t = { { 0, }, };
+       struct ast_tm tm;
 
        buf[0] = '\0';
 
@@ -701,14 +1391,12 @@ static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data,
                return -1;
        }
 
-       if (!strptime(args.timestring, args.format, &t.time)) {
-               ast_log(LOG_WARNING, "C function strptime() output nothing?!!\n");
+       if (!ast_strptime(args.timestring, args.format, &tm)) {
+               ast_log(LOG_WARNING, "STRPTIME() found no time specified within the string\n");
        } else {
-               struct timeval tv;
-               /* Since strptime(3) does not check DST, force ast_mktime() to calculate it. */
-               t.atm.tm_isdst = -1;
-               tv = ast_mktime(&t.atm, args.timezone);
-               snprintf(buf, len, "%d", (int) tv.tv_sec);
+               struct timeval when;
+               when = ast_mktime(&tm, args.timezone);
+               snprintf(buf, buflen, "%d", (int) when.tv_sec);
        }
 
        return 0;
@@ -716,58 +1404,50 @@ static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data,
 
 static struct ast_custom_function strptime_function = {
        .name = "STRPTIME",
-       .synopsis =
-               "Returns the epoch of the arbitrary date/time string structured as described in the format.",
-       .syntax = "STRPTIME(<datetime>,<timezone>,<format>)",
-       .desc =
-               "This is useful for converting a date into an EPOCH time, possibly to pass to\n"
-               "an application like SayUnixTime or to calculate the difference between two\n"
-               "date strings.\n"
-               "\n"
-               "Example:\n"
-               "  ${STRPTIME(2006-03-01 07:30:35,America/Chicago,%Y-%m-%d %H:%M:%S)} returns 1141219835\n",
        .read = acf_strptime,
 };
 
 static int function_eval(struct ast_channel *chan, const char *cmd, char *data,
-                        char *buf, size_t len)
+                        char *buf, size_t buflen)
+{
+       if (ast_strlen_zero(data)) {
+               ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
+               return -1;
+       }
+
+       pbx_substitute_variables_helper(chan, data, buf, buflen - 1);
+
+       return 0;
+}
+
+static int function_eval2(struct ast_channel *chan, const char *cmd, char *data,
+                        struct ast_str **buf, ssize_t buflen)
 {
        if (ast_strlen_zero(data)) {
                ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
                return -1;
        }
 
-       if (chan)
-               ast_autoservice_start(chan);
-       pbx_substitute_variables_helper(chan, data, buf, len - 1);
-       if (chan)
-               ast_autoservice_stop(chan);
+       ast_str_substitute_variables(buf, buflen, chan, data);
 
        return 0;
 }
 
 static struct ast_custom_function eval_function = {
        .name = "EVAL",
-       .synopsis = "Evaluate stored variables.",
-       .syntax = "EVAL(<variable>)",
-       .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
-               "When a variable or expression is in the dialplan, it will be\n"
-               "evaluated at runtime. However, if the result of the evaluation\n"
-               "is in fact a variable or expression, using EVAL will have it\n"
-               "evaluated a second time. For example, if the variable ${MYVAR}\n"
-               "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
-               "in the dialplan will be the contents of the variable, OTHERVAR.\n"
-               "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
-               "left with \"${OTHERVAR}\".\n",
        .read = function_eval,
+       .read2 = function_eval2,
 };
 
-static int keypadhash(struct ast_channel *chan, const 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 buflen)
 {
        char *bufptr, *dataptr;
 
-       for (bufptr = buf, dataptr = data; bufptr < buf + len - 1; dataptr++) {
-               if (*dataptr == '1') {
+       for (bufptr = buf, dataptr = data; bufptr < buf + buflen - 1; dataptr++) {
+               if (*dataptr == '\0') {
+                       *bufptr++ = '\0';
+                       break;
+               } else if (*dataptr == '1') {
                        *bufptr++ = '1';
                } else if (strchr("AaBbCc2", *dataptr)) {
                        *bufptr++ = '2';
@@ -787,78 +1467,499 @@ static int keypadhash(struct ast_channel *chan, const char *cmd, char *data, cha
                        *bufptr++ = '9';
                } else if (*dataptr == '0') {
                        *bufptr++ = '0';
-               } else if (*dataptr == '\0') {
-                       *bufptr++ = '\0';
-                       break;
                }
        }
-       buf[len - 1] = '\0';
+       buf[buflen - 1] = '\0';
 
        return 0;
 }
 
 static struct ast_custom_function keypadhash_function = {
        .name = "KEYPADHASH",
-       .synopsis = "Hash the letters in the string into the equivalent keypad numbers.",
-       .syntax = "KEYPADHASH(<string>)",
        .read = keypadhash,
-       .desc = "Example:  ${KEYPADHASH(Les)} returns \"537\"\n",
 };
 
-static int string_toupper(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+static int string_toupper(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
 {
        char *bufptr = buf, *dataptr = data;
 
-       while ((bufptr < buf + len - 1) && (*bufptr++ = toupper(*dataptr++)));
+       while ((bufptr < buf + buflen - 1) && (*bufptr++ = toupper(*dataptr++)));
+
+       return 0;
+}
+
+static int string_toupper2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
+{
+       char *bufptr, *dataptr = data;
+
+       if (buflen > -1) {
+               ast_str_make_space(buf, buflen > 0 ? buflen : strlen(data) + 1);
+       }
+       bufptr = ast_str_buffer(*buf);
+       while ((bufptr < ast_str_buffer(*buf) + ast_str_size(*buf) - 1) && (*bufptr++ = toupper(*dataptr++)));
+       ast_str_update(*buf);
 
        return 0;
 }
 
 static struct ast_custom_function toupper_function = {
        .name = "TOUPPER",
-       .synopsis = "Convert the string to upper case.",
-       .syntax = "TOUPPER(<string>)",
        .read = string_toupper,
-       .desc = "Example: ${TOUPPER(Example)} returns \"EXAMPLE\"\n",
+       .read2 = string_toupper2,
 };
 
-static int string_tolower(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+static int string_tolower(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
 {
        char *bufptr = buf, *dataptr = data;
 
-       while ((bufptr < buf + len - 1) && (*bufptr++ = tolower(*dataptr++)));
+       while ((bufptr < buf + buflen - 1) && (*bufptr++ = tolower(*dataptr++)));
+
+       return 0;
+}
+
+static int string_tolower2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
+{
+       char *bufptr, *dataptr = data;
+
+       if (buflen > -1) {
+               ast_str_make_space(buf, buflen > 0 ? buflen : strlen(data) + 1);
+       }
+       bufptr = ast_str_buffer(*buf);
+       while ((bufptr < ast_str_buffer(*buf) + ast_str_size(*buf) - 1) && (*bufptr++ = tolower(*dataptr++)));
+       ast_str_update(*buf);
 
        return 0;
 }
 
 static struct ast_custom_function tolower_function = {
        .name = "TOLOWER",
-       .synopsis = "Convert the string to lower case.",
-       .syntax = "TOLOWER(<string>)",
        .read = string_tolower,
-       .desc = "Example: ${TOLOWER(Example)} returns \"example\"\n",
+       .read2 = string_tolower2,
+};
+
+static int shift_pop(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+#define beginning      (cmd[0] == 'S') /* SHIFT */
+       char *after, delimiter[2] = ",", *varsubst;
+       size_t unused;
+       struct ast_str *before = ast_str_thread_get(&result_buf, 16);
+       char *(*search_func)(const char *s, int c) = (beginning ? strchr : strrchr);
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(var);
+               AST_APP_ARG(delimiter);
+       );
+
+       if (!before) {
+               return -1;
+       }
+
+       AST_STANDARD_APP_ARGS(args, data);
+
+       if (ast_strlen_zero(args.var)) {
+               ast_log(LOG_WARNING, "%s requires a variable name\n", cmd);
+               return -1;
+       }
+
+       varsubst = ast_alloca(strlen(args.var) + 4);
+       sprintf(varsubst, "${%s}", args.var);
+       ast_str_substitute_variables(&before, 0, chan, varsubst);
+
+       if (args.argc > 1 && !ast_strlen_zero(args.delimiter)) {
+               ast_get_encoded_char(args.delimiter, delimiter, &unused);
+       }
+
+       if (!ast_str_strlen(before)) {
+               /* Nothing to pop */
+               return -1;
+       }
+
+       if (!(after = search_func(ast_str_buffer(before), delimiter[0]))) {
+               /* Only one entry in array */
+               ast_str_set(buf, len, "%s", ast_str_buffer(before));
+               pbx_builtin_setvar_helper(chan, args.var, "");
+       } else {
+               *after++ = '\0';
+               ast_str_set(buf, len, "%s", beginning ? ast_str_buffer(before) : after);
+               pbx_builtin_setvar_helper(chan, args.var, beginning ? after : ast_str_buffer(before));
+       }
+
+       return 0;
+#undef beginning
+}
+
+static struct ast_custom_function shift_function = {
+       .name = "SHIFT",
+       .read2 = shift_pop,
+};
+
+static struct ast_custom_function pop_function = {
+       .name = "POP",
+       .read2 = shift_pop,
+};
+
+static int unshift_push(struct ast_channel *chan, const char *cmd, char *data, const char *new_value)
+{
+#define beginning      (cmd[0] == 'U') /* UNSHIFT */
+       char delimiter[2] = ",", *varsubst;
+       size_t unused;
+       struct ast_str *buf, *previous_value;
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(var);
+               AST_APP_ARG(delimiter);
+       );
+       const char *stripped_var;
+
+       if (!(buf = ast_str_thread_get(&result_buf, 16)) ||
+               !(previous_value = ast_str_thread_get(&tmp_buf, 16))) {
+               return -1;
+       }
+
+       AST_STANDARD_APP_ARGS(args, data);
+
+       if (ast_strlen_zero(args.var)) {
+               ast_log(LOG_WARNING, "%s requires a variable name\n", cmd);
+               return -1;
+       }
+
+       if (args.argc > 1 && !ast_strlen_zero(args.delimiter)) {
+               ast_get_encoded_char(args.delimiter, delimiter, &unused);
+       }
+
+       /* UNSHIFT and PUSH act as ways of setting a variable, so we need to be
+        * sure to skip leading underscores if they appear. However, we only want
+        * to skip up to two since that is the maximum number that can be used to
+        * indicate variable inheritance. Any further underscores are part of the
+        * variable name.
+        */
+       stripped_var = args.var + MIN(strspn(args.var, "_"), 2);
+       varsubst = ast_alloca(strlen(stripped_var) + 4);
+       sprintf(varsubst, "${%s}", stripped_var);
+       ast_str_substitute_variables(&previous_value, 0, chan, varsubst);
+
+       if (!ast_str_strlen(previous_value)) {
+               ast_str_set(&buf, 0, "%s", new_value);
+       } else {
+               ast_str_set(&buf, 0, "%s%c%s",
+                       beginning ? new_value : ast_str_buffer(previous_value),
+                       delimiter[0],
+                       beginning ? ast_str_buffer(previous_value) : new_value);
+       }
+
+       pbx_builtin_setvar_helper(chan, args.var, ast_str_buffer(buf));
+
+       return 0;
+#undef beginning
+}
+
+static struct ast_custom_function push_function = {
+       .name = "PUSH",
+       .write = unshift_push,
+};
+
+static struct ast_custom_function unshift_function = {
+       .name = "UNSHIFT",
+       .write = unshift_push,
+};
+
+static int passthru(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+       ast_str_set(buf, len, "%s", data);
+       return 0;
+}
+
+static struct ast_custom_function passthru_function = {
+       .name = "PASSTHRU",
+       .read2 = passthru,
 };
 
+#ifdef TEST_FRAMEWORK
+AST_TEST_DEFINE(test_FIELDNUM)
+{
+       int i, res = AST_TEST_PASS;
+       struct ast_channel *chan;
+       struct ast_str *str;
+       char expression[256];
+       struct {
+               const char *fields;
+               const char *delim;
+               const char *field;
+               const char *expected;
+       } test_args[] = {
+               {"abc,def,ghi,jkl", "\\,",     "ghi", "3"},
+               {"abc def ghi jkl", " ",       "abc", "1"},
+               {"abc/def/ghi/jkl", "\\\\x2f", "def", "2"},
+               {"abc$def$ghi$jkl", "",        "ghi", "0"},
+               {"abc,def,ghi,jkl", "-",       "",    "0"},
+               {"abc-def-ghi-jkl", "-",       "mno", "0"}
+       };
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "func_FIELDNUM_test";
+               info->category = "/funcs/func_strings/";
+               info->summary = "Test FIELDNUM function";
+               info->description = "Verify FIELDNUM 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(16))) {
+               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_args); i++) {
+               struct ast_var_t *var = ast_var_assign("FIELDS", test_args[i].fields);
+               if (!var) {
+                       ast_test_status_update(test, "Out of memory\n");
+                       res = AST_TEST_FAIL;
+                       break;
+               }
+
+               AST_LIST_INSERT_HEAD(ast_channel_varshead(chan), var, entries);
+
+               snprintf(expression, sizeof(expression), "${FIELDNUM(%s,%s,%s)}", var->name, test_args[i].delim, test_args[i].field);
+               ast_str_substitute_variables(&str, 0, chan, expression);
+
+               AST_LIST_REMOVE(ast_channel_varshead(chan), var, entries);
+               ast_var_delete(var);
+
+               if (strcasecmp(ast_str_buffer(str), test_args[i].expected)) {
+                       ast_test_status_update(test, "Evaluation of '%s' returned '%s' instead of the expected value '%s'\n",
+                               expression, ast_str_buffer(str), test_args[i].expected);
+                       res = AST_TEST_FAIL;
+                       break;
+               }
+       }
+
+       ast_free(str);
+       ast_channel_release(chan);
+
+       return res;
+}
+
+AST_TEST_DEFINE(test_REPLACE)
+{
+       int i, res = AST_TEST_PASS;
+       struct ast_channel *chan;
+       struct ast_str *str;
+       char expression[256];
+       struct {
+               const char *test_string;
+               const char *find_chars;
+               const char *replace_char;
+               const char *expected;
+       } test_args[] = {
+               {"abc,def", "\\,", "-", "abc-def"},
+               {"abc,abc", "bc",  "a", "aaa,aaa"},
+               {"abc,def", "x",   "?", "abc,def"},
+               {"abc,def", "\\,", "",  "abcdef"}
+       };
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "func_REPLACE_test";
+               info->category = "/funcs/func_strings/";
+               info->summary = "Test REPLACE function";
+               info->description = "Verify REPLACE 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(16))) {
+               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_args); i++) {
+               struct ast_var_t *var = ast_var_assign("TEST_STRING", test_args[i].test_string);
+               if (!var) {
+                       ast_test_status_update(test, "Out of memory\n");
+                       res = AST_TEST_FAIL;
+                       break;
+               }
+
+               AST_LIST_INSERT_HEAD(ast_channel_varshead(chan), var, entries);
+
+               snprintf(expression, sizeof(expression), "${REPLACE(%s,%s,%s)}", var->name, test_args[i].find_chars, test_args[i].replace_char);
+               ast_str_substitute_variables(&str, 0, chan, expression);
+
+               AST_LIST_REMOVE(ast_channel_varshead(chan), var, entries);
+               ast_var_delete(var);
+
+               if (strcasecmp(ast_str_buffer(str), test_args[i].expected)) {
+                       ast_test_status_update(test, "Evaluation of '%s' returned '%s' instead of the expected value '%s'\n",
+                               expression, ast_str_buffer(str), test_args[i].expected);
+                       res = AST_TEST_FAIL;
+                       break;
+               }
+       }
+
+       ast_free(str);
+       ast_channel_release(chan);
+
+       return res;
+}
+
+AST_TEST_DEFINE(test_FILTER)
+{
+       int i, res = AST_TEST_PASS;
+       const char *test_strings[][2] = {
+               {"A-R",            "DAHDI"},
+               {"A\\-R",          "A"},
+               {"\\x41-R",        "DAHDI"},
+               {"0-9A-Ca-c",      "0042133333A12212"},
+               {"0-9a-cA-C_+\\-", "0042133333A12212"},
+               {NULL,             NULL},
+       };
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "func_FILTER_test";
+               info->category = "/funcs/func_strings/";
+               info->summary = "Test FILTER function";
+               info->description = "Verify FILTER behavior";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       for (i = 0; test_strings[i][0]; i++) {
+               char tmp[256], tmp2[256] = "";
+               snprintf(tmp, sizeof(tmp), "${FILTER(%s,0042133333&DAHDI/g1/2212)}", test_strings[i][0]);
+               pbx_substitute_variables_helper(NULL, tmp, tmp2, sizeof(tmp2) - 1);
+               if (strcmp(test_strings[i][1], tmp2)) {
+                       ast_test_status_update(test, "Format string '%s' substituted to '%s'.  Expected '%s'.\n", test_strings[i][0], tmp2, test_strings[i][1]);
+                       res = AST_TEST_FAIL;
+               }
+       }
+       return res;
+}
+
+AST_TEST_DEFINE(test_STRREPLACE)
+{
+       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] = {
+               {"Weasels have eaten my telephone system", "have eaten my", "are eating our", "", "Weasels are eating our telephone system"}, /*Test normal conditions */
+               {"Did you know twenty plus two is twenty-two?", "twenty", "thirty", NULL, "Did you know thirty plus two is thirty-two?"}, /* Test no third comma */
+               {"foofoofoofoofoofoofoo", "foofoo", "bar", NULL, "barbarbarfoo"}, /* Found string within previous match */
+               {"My pet dog once ate a dog who sat on a dog while eating a corndog.", "dog", "cat", "3", "My pet cat once ate a cat who sat on a cat while eating a corndog."},
+               {"One and one and one is three", "and", "plus", "1", "One plus one and one is three"}, /* Test <max-replacements> = 1*/
+               {"", "fhqwagads", "spelunker", NULL, ""}, /* Empty primary string */
+               {"Part of this string is missing.", "missing", NULL, NULL, "Part of this string is ."}, /* Empty replace string */
+               {"'Accidentally' left off a bunch of stuff.", NULL, NULL, NULL, ""}, /* Deliberate error test from too few args */
+               {"This test will also error.", "", "", "", ""}, /* Deliberate error test from blank find string */
+               {"This is an \"escape character\" test.", "\\\"escape character\\\"", "evil", NULL, "This is an evil test."}
+       };
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "func_STRREPLACE_test";
+               info->category = "/funcs/func_strings/";
+               info->summary = "Test STRREPLACE function";
+               info->description = "Verify STRREPLACE 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);
+
+               if (test_strings[i][3]) {
+                       snprintf(tmp, sizeof(tmp), "${STRREPLACE(%s,%s,%s,%s)}", "test_string", test_strings[i][1], test_strings[i][2], test_strings[i][3]);
+               } else if (test_strings[i][2]) {
+                       snprintf(tmp, sizeof(tmp), "${STRREPLACE(%s,%s,%s)}", "test_string", test_strings[i][1], test_strings[i][2]);
+               } else if (test_strings[i][1]) {
+                       snprintf(tmp, sizeof(tmp), "${STRREPLACE(%s,%s)}", "test_string", test_strings[i][1]);
+               } else {
+                       snprintf(tmp, sizeof(tmp), "${STRREPLACE(%s)}", "test_string");
+               }
+               ast_str_substitute_variables(&str, 0, chan, tmp);
+               if (strcmp(test_strings[i][4], 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][4]);
+                       res = AST_TEST_FAIL;
+               }
+       }
+
+       ast_free(str);
+       ast_channel_release(chan);
+
+       return res;
+}
+#endif
+
 static int unload_module(void)
 {
        int res = 0;
 
+       AST_TEST_UNREGISTER(test_FIELDNUM);
+       AST_TEST_UNREGISTER(test_REPLACE);
+       AST_TEST_UNREGISTER(test_FILTER);
+       AST_TEST_UNREGISTER(test_STRREPLACE);
        res |= ast_custom_function_unregister(&fieldqty_function);
+       res |= ast_custom_function_unregister(&fieldnum_function);
        res |= ast_custom_function_unregister(&filter_function);
+       res |= ast_custom_function_unregister(&replace_function);
+       res |= ast_custom_function_unregister(&strreplace_function);
+       res |= ast_custom_function_unregister(&listfilter_function);
        res |= ast_custom_function_unregister(&regex_function);
        res |= ast_custom_function_unregister(&array_function);
        res |= ast_custom_function_unregister(&quote_function);
+       res |= ast_custom_function_unregister(&csv_quote_function);
        res |= ast_custom_function_unregister(&len_function);
        res |= ast_custom_function_unregister(&strftime_function);
        res |= ast_custom_function_unregister(&strptime_function);
        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);
        res |= ast_custom_function_unregister(&toupper_function);
        res |= ast_custom_function_unregister(&tolower_function);
+       res |= ast_custom_function_unregister(&shift_function);
+       res |= ast_custom_function_unregister(&pop_function);
+       res |= ast_custom_function_unregister(&push_function);
+       res |= ast_custom_function_unregister(&unshift_function);
+       res |= ast_custom_function_unregister(&passthru_function);
 
        return res;
 }
@@ -867,22 +1968,35 @@ static int load_module(void)
 {
        int res = 0;
 
+       AST_TEST_REGISTER(test_FIELDNUM);
+       AST_TEST_REGISTER(test_REPLACE);
+       AST_TEST_REGISTER(test_FILTER);
+       AST_TEST_REGISTER(test_STRREPLACE);
        res |= ast_custom_function_register(&fieldqty_function);
+       res |= ast_custom_function_register(&fieldnum_function);
        res |= ast_custom_function_register(&filter_function);
+       res |= ast_custom_function_register(&replace_function);
+       res |= ast_custom_function_register(&strreplace_function);
+       res |= ast_custom_function_register(&listfilter_function);
        res |= ast_custom_function_register(&regex_function);
        res |= ast_custom_function_register(&array_function);
        res |= ast_custom_function_register(&quote_function);
+       res |= ast_custom_function_register(&csv_quote_function);
        res |= ast_custom_function_register(&len_function);
        res |= ast_custom_function_register(&strftime_function);
        res |= ast_custom_function_register(&strptime_function);
        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);
+       res |= ast_register_application_xml(app_clearhash, exec_clearhash);
        res |= ast_custom_function_register(&toupper_function);
        res |= ast_custom_function_register(&tolower_function);
+       res |= ast_custom_function_register(&shift_function);
+       res |= ast_custom_function_register(&pop_function);
+       res |= ast_custom_function_register(&push_function);
+       res |= ast_custom_function_register(&unshift_function);
+       res |= ast_custom_function_register(&passthru_function);
 
        return res;
 }