funcs/func_strings.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2005, Digium, Inc.
   5  * Portions Copyright (C) 2005, Tilghman Lesher.  All rights reserved.
   6  * Portions Copyright (C) 2005, Anthony Minessale II
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief String manipulation dialplan functions
  22  *
  23  * \author Tilghman Lesher
  24  * \author Anothony Minessale II
  25  */
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <regex.h>
  32
  33 #include "asterisk.h"
  34
  35 /* ASTERISK_FILE_VERSION(__FILE__, "$Revision$") */
  36
  37 #include "asterisk/channel.h"
  38 #include "asterisk/pbx.h"
  39 #include "asterisk/logger.h"
  40 #include "asterisk/utils.h"
  41 #include "asterisk/app.h"
  42 #include "asterisk/localtime.h"
  43
  44 static char *function_fieldqty(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
  45 {
  46         char *varname, *varval, workspace[256];
  47         char *delim = ast_strdupa(data);
  48         int fieldcount = 0;
  49
  50         if (delim) {
  51                 varname = strsep(&delim, "|");
  52                 pbx_retrieve_variable(chan, varname, &varval, workspace, sizeof(workspace), NULL);
  53                 if (delim) {
  54                         while (strsep(&varval, delim))
  55                                 fieldcount++;
  56                 } else if (!ast_strlen_zero(varval)) {
  57                         fieldcount = 1;
  58                 }
  59                 snprintf(buf, len, "%d", fieldcount);
  60         } else {
  61                 ast_log(LOG_ERROR, "Out of memory\n");
  62                 strncpy(buf, "1", len);
  63         }
  64         return buf;
  65 }
  66
  67 #ifndef BUILTIN_FUNC
  68 static
  69 #endif
  70 struct ast_custom_function fieldqty_function = {
  71         .name = "FIELDQTY",
  72         .synopsis = "Count the fields, with an arbitrary delimiter",
  73         .syntax = "FIELDQTY(<varname>,<delim>)",
  74         .read = function_fieldqty,
  75 };
  76
  77 static char *builtin_function_filter(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
  78 {
  79         char *allowed, *string, *outbuf=buf;
  80
  81         string = ast_strdupa(data);
  82         if (!string) {
  83                 ast_log(LOG_ERROR, "Out of memory");
  84                 return "";
  85         }
  86
  87         allowed = strsep(&string, "|");
  88
  89         if (!string) {
  90                 ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>,<string>)\n");
  91                 return "";
  92         }
  93
  94         for ( ; *string && (buf + len - 1 > outbuf); string++) {
  95                 if (strchr(allowed, *string)) {
  96                         *outbuf = *string;
  97                         outbuf++;
  98                 }
  99         }
 100         *outbuf = '\0';
 101
 102         return buf;
 103 }
 104
 105 #ifndef BUILTIN_FUNC
 106 static
 107 #endif
 108 struct ast_custom_function filter_function = {
 109         .name = "FILTER",
 110         .synopsis = "Filter the string to include only the allowed characters",
 111         .syntax = "FILTER(<allowed-chars>,<string>)",
 112         .read = builtin_function_filter,
 113 };
 114
 115 static char *builtin_function_regex(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 116 {
 117         char *arg, *earg = NULL, *tmp, errstr[256] = "";
 118         int errcode;
 119         regex_t regexbuf;
 120
 121         ast_copy_string(buf, "0", len);
 122
 123         tmp = ast_strdupa(data);
 124         if (!tmp) {
 125                 ast_log(LOG_ERROR, "Out of memory in %s(%s)\n", cmd, data);
 126                 return buf;
 127         }
 128
 129         /* Regex in quotes */
 130         arg = strchr(tmp, '"');
 131         if (arg) {
 132                 arg++;
 133                 earg = strrchr(arg, '"');
 134                 if (earg) {
 135                         *earg++ = '\0';
 136                         /* Skip over any spaces before the data we are checking */
 137                         while (*earg == ' ')
 138                                 earg++;
 139                 }
 140         } else {
 141                 arg = tmp;
 142         }
 143
 144         if ((errcode = regcomp(&regexbuf, arg, REG_EXTENDED | REG_NOSUB))) {
 145                 regerror(errcode, &regexbuf, errstr, sizeof(errstr));
 146                 ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, data, errstr);
 147         } else {
 148                 if (!regexec(&regexbuf, earg ? earg : "", 0, NULL, 0))
 149                         ast_copy_string(buf, "1", len);
 150         }
 151         regfree(&regexbuf);
 152
 153         return buf;
 154 }
 155
 156 #ifndef BUILTIN_FUNC
 157 static
 158 #endif
 159 struct ast_custom_function regex_function = {
 160         .name = "REGEX",
 161         .synopsis = "Regular Expression: Returns 1 if data matches regular expression.",
 162         .syntax = "REGEX(\"<regular expression>\" <data>)",
 163         .read = builtin_function_regex,
 164 };
 165
 166 static void builtin_function_array(struct ast_channel *chan, char *cmd, char *data, const char *value)
 167 {
 168         char *varv[100];
 169         char *valuev[100];
 170         char *var, *value2;
 171         int varcount, valuecount, i;
 172
 173         var = ast_strdupa(data);
 174         value2 = ast_strdupa(value);
 175         if (!var || !value2) {
 176                 ast_log(LOG_ERROR, "Out of memory\n");
 177                 return;
 178         }
 179
 180         /* The functions this will generally be used with are SORT and ODBC_*, which
 181          * both return comma-delimited lists.  However, if somebody uses literal lists,
 182          * their commas will be translated to vertical bars by the load, and I don't
 183          * want them to be surprised by the result.  Hence, we prefer commas as the
 184          * delimiter, but we'll fall back to vertical bars if commas aren't found.
 185          */
 186         if (strchr(var, ',')) {
 187                 varcount = ast_app_separate_args(var, ',', varv, 100);
 188         } else {
 189                 varcount = ast_app_separate_args(var, '|', varv, 100);
 190         }
 191
 192         if (strchr(value2, ',')) {
 193                 valuecount = ast_app_separate_args(value2, ',', valuev, 100);
 194         } else {
 195                 valuecount = ast_app_separate_args(value2, '|', valuev, 100);
 196         }
 197
 198         for (i = 0; i < varcount; i++) {
 199                 if (i < valuecount) {
 200                         pbx_builtin_setvar_helper(chan, varv[i], valuev[i]);
 201                 } else {
 202                         /* We could unset the variable, by passing a NULL, but due to
 203                          * pushvar semantics, that could create some undesired behavior. */
 204                         pbx_builtin_setvar_helper(chan, varv[i], "");
 205                 }
 206         }
 207 }
 208
 209 #ifndef BUILTIN_FUNC
 210 static
 211 #endif
 212 struct ast_custom_function array_function = {
 213         .name = "ARRAY",
 214         .synopsis = "Allows setting multiple variables at once",
 215         .syntax = "ARRAY(var1[,var2[...][,varN]])",
 216         .write = builtin_function_array,
 217         .desc =
 218 "The comma-separated list passed as a value to which the function is set\n"
 219 "will be interpreted as a set of values to which the comma-separated list\n"
 220 "of variable names in the argument should be set.\n"
 221 "Hence, Set(ARRAY(var1,var2)=1,2) will set var1 to 1 and var2 to 2\n",
 222 };
 223
 224 static char *builtin_function_len(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 225 {
 226         int length = 0;
 227         if (data) {
 228                 length = strlen(data);
 229         }
 230         snprintf(buf, len, "%d", length);
 231         return buf;
 232 }
 233
 234 #ifndef BUILTIN_FUNC
 235 static
 236 #endif
 237 struct ast_custom_function len_function = {
 238         .name = "LEN",
 239         .synopsis = "Returns the length of the argument given",
 240         .syntax = "LEN(<string>)",
 241         .read = builtin_function_len,
 242 };
 243
 244 static char *acf_strftime(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 245 {
 246         char *format, *epoch, *timezone = NULL;
 247         long epochi;
 248         struct tm time;
 249
 250         buf[0] = '\0';
 251
 252         if (!data) {
 253                 ast_log(LOG_ERROR, "Asterisk function STRFTIME() requires an argument.\n");
 254                 return buf;
 255         }
 256
 257         format = ast_strdupa(data);
 258         if (!format) {
 259                 ast_log(LOG_ERROR, "Out of memory\n");
 260                 return buf;
 261         }
 262
 263         epoch = strsep(&format, "|");
 264         timezone = strsep(&format, "|");
 265
 266         if (ast_strlen_zero(epoch) || !sscanf(epoch, "%ld", &epochi)) {
 267                 struct timeval tv = ast_tvnow();
 268                 epochi = tv.tv_sec;
 269         }
 270
 271         ast_localtime(&epochi, &time, timezone);
 272
 273         if (!format) {
 274                 format = "%c";
 275         }
 276
 277         if (!strftime(buf, len, format, &time)) {
 278                 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
 279         }
 280         buf[len - 1] = '\0';
 281
 282         return buf;
 283 }
 284
 285 #ifndef BUILTIN_FUNC
 286 static
 287 #endif
 288 struct ast_custom_function strftime_function = {
 289         .name = "STRFTIME",
 290         .synopsis = "Returns the current date/time in a specified format.",
 291         .syntax = "STRFTIME([<epoch>][,[timezone][,format]])",
 292         .read = acf_strftime,
 293 };
 294
 295 static char *function_eval(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 296 {
 297         memset(buf, 0, len);
 298
 299         if (ast_strlen_zero(data)) {
 300                 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
 301                 return buf;
 302         }
 303
 304         pbx_substitute_variables_helper(chan, data, buf, len - 1);
 305
 306         return buf;
 307 }
 308
 309 #ifndef BUILTIN_FUNC
 310 static
 311 #endif
 312 struct ast_custom_function eval_function = {
 313         .name = "EVAL",
 314         .synopsis = "Evaluate stored variables.",
 315         .syntax = "EVAL(<variable>)",
 316         .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
 317                 "When a variable or expression is in the dialplan, it will be\n"
 318                 "evaluated at runtime. However, if the result of the evaluation\n"
 319                 "is in fact a variable or expression, using EVAL will have it\n"
 320                 "evaluated a second time. For example, if the variable ${MYVAR}\n"
 321                 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
 322                 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
 323                 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
 324                 "left with \"${OTHERVAR}\".\n",
 325         .read = function_eval,
 326 };
 327