Use the same delimited character as the FILTER function in FIELDQTY and CUT.
[asterisk/asterisk.git] / funcs / func_strings.c
index c7fc485..3230b67 100644 (file)
@@ -48,31 +48,29 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 static int function_fieldqty(struct ast_channel *chan, const char *cmd,
                             char *parse, char *buf, size_t len)
 {
-       const char *varval;
-       char *varval2 = NULL;
+       char *varsubst, varval[8192] = "", *varval2 = varval;
        int fieldcount = 0;
        AST_DECLARE_APP_ARGS(args,
                             AST_APP_ARG(varname);
                             AST_APP_ARG(delim);
                );
+       char delim[2] = "";
+       size_t delim_used;
 
        AST_STANDARD_APP_ARGS(args, parse);
        if (args.delim) {
-               if (args.delim[0] == '\\') {
-                       if (args.delim[1] == 'n')
-                               ast_copy_string(args.delim, "\n", 2);
-                       else if (args.delim[1] == 't')
-                               ast_copy_string(args.delim, "\t", 2);
-                       else if (args.delim[1])
-                               ast_copy_string(args.delim, &args.delim[1], 2);
-                       else
-                               ast_copy_string(args.delim, "-", 2);
+               ast_get_encoded_char(args.delim, delim, &delim_used);
+
+               varsubst = 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))
+                       fieldcount = 0;
+               else {
+                       while (strsep(&varval2, delim))
+                               fieldcount++;
                }
-               varval = pbx_builtin_getvar_helper(chan, args.varname);
-               if (varval)
-                       varval2 = ast_strdupa(varval);
-               while (strsep(&varval2, args.delim))
-                       fieldcount++;
        } else {
                fieldcount = 1;
        }
@@ -84,7 +82,7 @@ static int function_fieldqty(struct ast_channel *chan, const char *cmd,
 static struct ast_custom_function fieldqty_function = {
        .name = "FIELDQTY",
        .synopsis = "Count the fields, with an arbitrary delimiter",
-       .syntax = "FIELDQTY(<varname>|<delim>)",
+       .syntax = "FIELDQTY(<varname>,<delim>)",
        .read = function_fieldqty,
 };
 
@@ -95,17 +93,51 @@ static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *
                             AST_APP_ARG(allowed);
                             AST_APP_ARG(string);
        );
-       char *outbuf = buf;
+       char *outbuf = buf, ac;
+       char allowed[256] = "";
+       size_t allowedlen = 0;
 
        AST_STANDARD_APP_ARGS(args, parse);
 
        if (!args.string) {
-               ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>|<string>)\n");
+               ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>,<string>)\n");
                return -1;
        }
 
+       /* Expand ranges */
+       for (; *(args.allowed) && allowedlen < sizeof(allowed); (args.allowed)++) {
+               char c1 = 0, c2 = 0;
+               size_t consumed = 0;
+
+               if (ast_get_encoded_char(args.allowed, &c1, &consumed))
+                       return -1;
+               args.allowed += consumed;
+
+               if (*(args.allowed) == '-') {
+                       if (ast_get_encoded_char(args.allowed + 1, &c2, &consumed))
+                               c2 = -1;
+                       args.allowed += consumed + 1;
+
+                       /*!\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;
+
+                       ast_debug(4, "c1=%d, c2=%d\n", c1, c2);
+
+                       /* Decrement before the loop increment */
+                       (args.allowed)--;
+               } else
+                       allowed[allowedlen++] = c1;
+       }
+
+       ast_debug(1, "Allowed: %s\n", allowed);
+
        for (; *(args.string) && (buf + len - 1 > outbuf); (args.string)++) {
-               if (strchr(args.allowed, *(args.string)))
+               if (strchr(allowed, *(args.string)))
                        *outbuf++ = *(args.string);
        }
        *outbuf = '\0';
@@ -116,8 +148,15 @@ 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>)",
+       .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 regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf,
@@ -142,8 +181,7 @@ static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *b
        if ((*args.str == ' ') || (*args.str == '\t'))
                args.str++;
 
-       if (option_debug)
-               ast_log(LOG_DEBUG, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);
+       ast_debug(1, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);
 
        if ((errcode = regcomp(&regexbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
                regerror(errcode, &regexbuf, buf, len);
@@ -187,7 +225,7 @@ static void clearvar_prefix(struct ast_channel *chan, const char *prefix)
        AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->varshead, var, entries) {
                if (strncasecmp(prefix, ast_var_name(var), len) == 0) {
                        AST_LIST_REMOVE_CURRENT(&chan->varshead, entries);
-                       free(var);
+                       ast_free(var);
                }
        }
        AST_LIST_TRAVERSE_SAFE_END
@@ -233,21 +271,13 @@ 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.
         */
-       if (option_debug)
-               ast_log(LOG_DEBUG, "array (%s=%s)\n", var, value2);
-       if (strchr(var, ','))
-               AST_NONSTANDARD_APP_ARGS(arg1, var, ',');
-       else
-               AST_STANDARD_APP_ARGS(arg1, var);
-
-       if (strchr(value2, ','))
-               AST_NONSTANDARD_APP_ARGS(arg2, value2, ',');
-       else
-               AST_STANDARD_APP_ARGS(arg2, value2);
+       ast_debug(1, "array (%s=%s)\n", var, value2);
+       AST_STANDARD_APP_ARGS(arg1, var);
+
+       AST_STANDARD_APP_ARGS(arg2, value2);
 
        for (i = 0; i < arg1.argc; i++) {
-               if (option_debug)
-                       ast_log(LOG_DEBUG, "array set value (%s=%s)\n", arg1.var[i],
+               ast_debug(1, "array set value (%s=%s)\n", arg1.var[i],
                                arg2.val[i]);
                if (i < arg2.argc) {
                        if (ishash) {
@@ -301,7 +331,7 @@ static int hash_write(struct ast_channel *chan, const char *cmd, char *var, cons
                AST_APP_ARG(hashkey);
        );
 
-       if (!strchr(var, '|')) {
+       if (!strchr(var, ',')) {
                /* Single argument version */
                return array(chan, "HASH", var, value);
        }
@@ -362,7 +392,7 @@ 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])",
+       .syntax = "HASH(hashname[,hashkey])",
        .write = hash_write,
        .read = hash_read,
        .desc =
@@ -386,15 +416,13 @@ static struct ast_custom_function hashkeys_function = {
 static struct ast_custom_function array_function = {
        .name = "ARRAY",
        .synopsis = "Allows setting multiple variables at once",
-       .syntax = "ARRAY(var1[|var2[...][|varN]])",
+       .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"
-               "Note: remember to either backslash your commas in extensions.conf or quote the\n"
-               "entire argument, since Set can take multiple arguments itself.\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)
@@ -458,7 +486,7 @@ static int acf_sprintf(struct ast_channel *chan, const char *cmd, char *data, ch
                                formatbuf[&arg.format[i] - formatstart + 1] = '\0';
 
                                /* Convert the argument into the required type */
-                               if (sscanf(arg.var[argcount++], "%i", &tmpi) != 1) {
+                               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;
                                }
@@ -532,7 +560,7 @@ sprintf_fail:
 static struct ast_custom_function sprintf_function = {
        .name = "SPRINTF",
        .synopsis = "Format a variable according to a format string",
-       .syntax = "SPRINTF(<format>|<arg1>[|...<argN>])",
+       .syntax = "SPRINTF(<format>,<arg1>[,...<argN>])",
        .read = acf_sprintf,
        .desc =
 "Parses the format string specified and returns a string matching that format.\n"
@@ -598,20 +626,20 @@ static int acf_strftime(struct ast_channel *chan, const char *cmd, char *parse,
                             AST_APP_ARG(timezone);
                             AST_APP_ARG(format);
        );
-       time_t epochi;
-       struct tm tm;
+       struct timeval tv;
+       struct ast_tm tm;
 
        buf[0] = '\0';
 
        AST_STANDARD_APP_ARGS(args, parse);
 
-       ast_get_time_t(args.epoch, &epochi, time(NULL), NULL);
-       ast_localtime(&epochi, &tm, args.timezone);
+       ast_get_timeval(args.epoch, &tv, ast_tvnow(), NULL);
+       ast_localtime(&tv, &tm, args.timezone);
 
        if (!args.format)
                args.format = "%c";
 
-       if (!strftime(buf, len, args.format, &tm))
+       if (ast_strftime(buf, len, args.format, &tm) <= 0)
                ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
 
        buf[len - 1] = '\0';
@@ -622,7 +650,15 @@ static int acf_strftime(struct ast_channel *chan, const char *cmd, char *parse,
 static struct ast_custom_function strftime_function = {
        .name = "STRFTIME",
        .synopsis = "Returns the current date/time in a specified format.",
-       .syntax = "STRFTIME([<epoch>][|[timezone][|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,
 };
 
@@ -634,9 +670,10 @@ static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data,
                             AST_APP_ARG(timezone);
                             AST_APP_ARG(format);
        );
-       struct tm time;
-
-       memset(&time, 0, sizeof(struct tm));
+       union {
+               struct ast_tm atm;
+               struct tm time;
+       } t = { { 0, }, };
 
        buf[0] = '\0';
 
@@ -650,14 +687,15 @@ static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data,
 
        if (ast_strlen_zero(args.format)) {
                ast_log(LOG_ERROR,
-                               "No format supplied to STRPTIME(<timestring>|<timezone>|<format>)");
+                               "No format supplied to STRPTIME(<timestring>,<timezone>,<format>)");
                return -1;
        }
 
-       if (!strptime(args.timestring, args.format, &time)) {
+       if (!strptime(args.timestring, args.format, &t.time)) {
                ast_log(LOG_WARNING, "C function strptime() output nothing?!!\n");
        } else {
-               snprintf(buf, len, "%d", (int) ast_mktime(&time, args.timezone));
+               struct timeval tv = ast_mktime(&t.atm, args.timezone);
+               snprintf(buf, len, "%d", (int) tv.tv_sec);
        }
 
        return 0;
@@ -667,21 +705,21 @@ 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>)",
+       .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",
+               "  ${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)
 {
-       buf[0] = '\0';
+       memset(buf, 0, len);
 
        if (ast_strlen_zero(data)) {
                ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");