funcs/func_strings.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2005-2006, 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/module.h"
  38 #include "asterisk/channel.h"
  39 #include "asterisk/pbx.h"
  40 #include "asterisk/logger.h"
  41 #include "asterisk/utils.h"
  42 #include "asterisk/app.h"
  43 #include "asterisk/localtime.h"
  44
  45 static int function_fieldqty(struct ast_channel *chan, char *cmd,
  46                              char *parse, char *buf, size_t len)
  47 {
  48         char *varval;
  49         int fieldcount = 0;
  50         AST_DECLARE_APP_ARGS(args,
  51                              AST_APP_ARG(varname);
  52                              AST_APP_ARG(delim);
  53                 );
  54
  55         AST_STANDARD_APP_ARGS(args, parse);
  56         if (args.delim) {
  57                 pbx_retrieve_variable(chan, args.varname, &varval, buf, len, NULL);
  58                 while (strsep(&varval, args.delim))
  59                         fieldcount++;
  60         } else {
  61                 fieldcount = 1;
  62         }
  63         snprintf(buf, len, "%d", fieldcount);
  64
  65         return 0;
  66 }
  67
  68 static struct ast_custom_function fieldqty_function = {
  69         .name = "FIELDQTY",
  70         .synopsis = "Count the fields, with an arbitrary delimiter",
  71         .syntax = "FIELDQTY(<varname>,<delim>)",
  72         .read = function_fieldqty,
  73 };
  74
  75 static int filter(struct ast_channel *chan, char *cmd, char *parse, char *buf,
  76                   size_t len)
  77 {
  78         AST_DECLARE_APP_ARGS(args,
  79                              AST_APP_ARG(allowed);
  80                              AST_APP_ARG(string);
  81         );
  82         char *outbuf = buf;
  83
  84         AST_STANDARD_APP_ARGS(args, parse);
  85
  86         if (!args.string) {
  87                 ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>,<string>)\n");
  88                 return -1;
  89         }
  90
  91         for (; *(args.string) && (buf + len - 1 > outbuf); (args.string)++) {
  92                 if (strchr(args.allowed, *(args.string)))
  93                         *outbuf++ = *(args.string);
  94         }
  95         *outbuf = '\0';
  96
  97         return 0;
  98 }
  99
 100 static struct ast_custom_function filter_function = {
 101         .name = "FILTER",
 102         .synopsis = "Filter the string to include only the allowed characters",
 103         .syntax = "FILTER(<allowed-chars>,<string>)",
 104         .read = filter,
 105 };
 106
 107 static int regex(struct ast_channel *chan, char *cmd, char *parse, char *buf,
 108                  size_t len)
 109 {
 110         AST_DECLARE_APP_ARGS(args,
 111                              AST_APP_ARG(null);
 112                              AST_APP_ARG(reg);
 113                              AST_APP_ARG(str);
 114         );
 115         int errcode;
 116         regex_t regexbuf;
 117
 118         buf[0] = '\0';
 119
 120         AST_NONSTANDARD_APP_ARGS(args, parse, '"');
 121
 122         ast_log(LOG_DEBUG, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);
 123
 124         if ((errcode = regcomp(&regexbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
 125                 regerror(errcode, &regexbuf, buf, len);
 126                 ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, parse, buf);
 127                 return -1;
 128         } else {
 129                 if (!regexec(&regexbuf, args.str, 0, NULL, 0))
 130                         strcpy(buf, "1");
 131         }
 132         regfree(&regexbuf);
 133
 134         return 0;
 135 }
 136
 137 static struct ast_custom_function regex_function = {
 138         .name = "REGEX",
 139         .synopsis =
 140                 "Regular Expression: Returns 1 if data matches regular expression.",
 141         .syntax = "REGEX(\"<regular expression>\" <data>)",
 142         .read = regex,
 143 };
 144
 145 static int array(struct ast_channel *chan, char *cmd, char *var,
 146                  const char *value)
 147 {
 148         AST_DECLARE_APP_ARGS(arg1,
 149                              AST_APP_ARG(var)[100];
 150         );
 151         AST_DECLARE_APP_ARGS(arg2,
 152                              AST_APP_ARG(val)[100];
 153         );
 154         char *value2;
 155         int i;
 156
 157         value2 = ast_strdupa(value);
 158         if (!var || !value2)
 159                 return -1;
 160
 161         /* The functions this will generally be used with are SORT and ODBC_*, which
 162          * both return comma-delimited lists.  However, if somebody uses literal lists,
 163          * their commas will be translated to vertical bars by the load, and I don't
 164          * want them to be surprised by the result.  Hence, we prefer commas as the
 165          * delimiter, but we'll fall back to vertical bars if commas aren't found.
 166          */
 167         ast_log(LOG_DEBUG, "array (%s=%s)\n", var, value2);
 168         if (strchr(var, ','))
 169                 AST_NONSTANDARD_APP_ARGS(arg1, var, ',');
 170         else
 171                 AST_STANDARD_APP_ARGS(arg1, var);
 172
 173         if (strchr(value2, ','))
 174                 AST_NONSTANDARD_APP_ARGS(arg2, value2, ',');
 175         else
 176                 AST_STANDARD_APP_ARGS(arg2, value2);
 177
 178         for (i = 0; i < arg1.argc; i++) {
 179                 ast_log(LOG_DEBUG, "array set value (%s=%s)\n", arg1.var[i],
 180                         arg2.val[i]);
 181                 if (i < arg2.argc) {
 182                         pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
 183                 } else {
 184                         /* We could unset the variable, by passing a NULL, but due to
 185                          * pushvar semantics, that could create some undesired behavior. */
 186                         pbx_builtin_setvar_helper(chan, arg1.var[i], "");
 187                 }
 188         }
 189
 190         return 0;
 191 }
 192
 193 static struct ast_custom_function array_function = {
 194         .name = "ARRAY",
 195         .synopsis = "Allows setting multiple variables at once",
 196         .syntax = "ARRAY(var1[,var2[...][,varN]])",
 197         .write = array,
 198         .desc =
 199                 "The comma-separated list passed as a value to which the function is set will\n"
 200                 "be interpreted as a set of values to which the comma-separated list of\n"
 201                 "variable names in the argument should be set.\n"
 202                 "Hence, Set(ARRAY(var1,var2)=1,2) will set var1 to 1 and var2 to 2\n"
 203                 "Note: remember to either backslash your commas in extensions.conf or quote the\n"
 204                 "entire argument, since Set can take multiple arguments itself.\n",
 205 };
 206
 207 static int quote(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 208 {
 209         char *bufptr = buf, *dataptr = data;
 210         *bufptr++ = '"';
 211         for (; bufptr < buf + len - 1; dataptr++) {
 212                 if (*dataptr == '\\') {
 213                         *bufptr++ = '\\';
 214                         *bufptr++ = '\\';
 215                 } else if (*dataptr == '"') {
 216                         *bufptr++ = '\\';
 217                         *bufptr++ = '"';
 218                 } else if (*dataptr == '\0') {
 219                         break;
 220                 } else {
 221                         *bufptr++ = *dataptr;
 222                 }
 223         }
 224         *bufptr++ = '"';
 225         *bufptr = '\0';
 226         return 0;
 227 }
 228
 229 static struct ast_custom_function quote_function = {
 230         .name = "QUOTE",
 231         .synopsis = "Quotes a given string, escaping embedded quotes as necessary",
 232         .syntax = "QUOTE(<string>)",
 233         .read = quote,
 234 };
 235
 236
 237 static int len(struct ast_channel *chan, char *cmd, char *data, char *buf,
 238                size_t len)
 239 {
 240         int length = 0;
 241
 242         if (data)
 243                 length = strlen(data);
 244
 245         snprintf(buf, len, "%d", length);
 246
 247         return 0;
 248 }
 249
 250 static struct ast_custom_function len_function = {
 251         .name = "LEN",
 252         .synopsis = "Returns the length of the argument given",
 253         .syntax = "LEN(<string>)",
 254         .read = len,
 255 };
 256
 257 static int acf_strftime(struct ast_channel *chan, char *cmd, char *parse,
 258                         char *buf, size_t len)
 259 {
 260         AST_DECLARE_APP_ARGS(args,
 261                              AST_APP_ARG(epoch);
 262                              AST_APP_ARG(timezone);
 263                              AST_APP_ARG(format);
 264         );
 265         time_t epochi;
 266         struct tm tm;
 267
 268         buf[0] = '\0';
 269
 270         if (ast_strlen_zero(parse)) {
 271                 ast_log(LOG_ERROR,
 272                                 "Asterisk function STRFTIME() requires an argument.\n");
 273                 return -1;
 274         }
 275
 276         AST_STANDARD_APP_ARGS(args, parse);
 277
 278         ast_get_time_t(args.epoch, &epochi, time(NULL), NULL);
 279         ast_localtime(&epochi, &tm, args.timezone);
 280
 281         if (!args.format)
 282                 args.format = "%c";
 283
 284         if (!strftime(buf, len, args.format, &tm))
 285                 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
 286
 287         buf[len - 1] = '\0';
 288
 289         return 0;
 290 }
 291
 292 static struct ast_custom_function strftime_function = {
 293         .name = "STRFTIME",
 294         .synopsis = "Returns the current date/time in a specified format.",
 295         .syntax = "STRFTIME([<epoch>][,[timezone][,format]])",
 296         .read = acf_strftime,
 297 };
 298
 299 static int acf_strptime(struct ast_channel *chan, char *cmd, char *data,
 300                         char *buf, size_t len)
 301 {
 302         AST_DECLARE_APP_ARGS(args,
 303                              AST_APP_ARG(timestring);
 304                              AST_APP_ARG(timezone);
 305                              AST_APP_ARG(format);
 306         );
 307         struct tm time;
 308
 309         memset(&time, 0, sizeof(struct tm));
 310
 311         buf[0] = '\0';
 312
 313         if (!data) {
 314                 ast_log(LOG_ERROR,
 315                                 "Asterisk function STRPTIME() requires an argument.\n");
 316                 return -1;
 317         }
 318
 319         AST_STANDARD_APP_ARGS(args, data);
 320
 321         if (ast_strlen_zero(args.format)) {
 322                 ast_log(LOG_ERROR,
 323                                 "No format supplied to STRPTIME(<timestring>|<timezone>|<format>)");
 324                 return -1;
 325         }
 326
 327         if (!strptime(args.timestring, args.format, &time)) {
 328                 ast_log(LOG_WARNING, "C function strptime() output nothing?!!\n");
 329         } else {
 330                 snprintf(buf, len, "%d", (int) ast_mktime(&time, args.timezone));
 331         }
 332
 333         return 0;
 334 }
 335
 336 static struct ast_custom_function strptime_function = {
 337         .name = "STRPTIME",
 338         .synopsis =
 339                 "Returns the epoch of the arbitrary date/time string structured as described in the format.",
 340         .syntax = "STRPTIME(<datetime>|<timezone>|<format>)",
 341         .desc =
 342                 "This is useful for converting a date into an EPOCH time, possibly to pass to\n"
 343                 "an application like SayUnixTime or to calculate the difference between two\n"
 344                 "date strings.\n"
 345                 "\n"
 346                 "Example:\n"
 347                 "  ${STRPTIME(2006-03-01 07:30:35|America/Chicago|%Y-%m-%d %H:%M:%S)} returns 1141219835\n",
 348         .read = acf_strptime,
 349 };
 350
 351 static int function_eval(struct ast_channel *chan, char *cmd, char *data,
 352                          char *buf, size_t len)
 353 {
 354         buf[0] = '\0';
 355
 356         if (ast_strlen_zero(data)) {
 357                 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
 358                 return -1;
 359         }
 360
 361         pbx_substitute_variables_helper(chan, data, buf, len - 1);
 362
 363         return 0;
 364 }
 365
 366 static struct ast_custom_function eval_function = {
 367         .name = "EVAL",
 368         .synopsis = "Evaluate stored variables.",
 369         .syntax = "EVAL(<variable>)",
 370         .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
 371                 "When a variable or expression is in the dialplan, it will be\n"
 372                 "evaluated at runtime. However, if the result of the evaluation\n"
 373                 "is in fact a variable or expression, using EVAL will have it\n"
 374                 "evaluated a second time. For example, if the variable ${MYVAR}\n"
 375                 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
 376                 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
 377                 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
 378                 "left with \"${OTHERVAR}\".\n",
 379         .read = function_eval,
 380 };
 381
 382 static int keypadhash(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 383 {
 384         char *bufptr, *dataptr;
 385
 386         for (bufptr = buf, dataptr = data; bufptr < buf + len - 1; dataptr++) {
 387                 if (*dataptr == '1') {
 388                         *bufptr++ = '1';
 389                 } else if (strchr("AaBbCc2", *dataptr)) {
 390                         *bufptr++ = '2';
 391                 } else if (strchr("DdEeFf3", *dataptr)) {
 392                         *bufptr++ = '3';
 393                 } else if (strchr("GgHhIi4", *dataptr)) {
 394                         *bufptr++ = '4';
 395                 } else if (strchr("JjKkLl5", *dataptr)) {
 396                         *bufptr++ = '5';
 397                 } else if (strchr("MmNnOo6", *dataptr)) {
 398                         *bufptr++ = '6';
 399                 } else if (strchr("PpQqRrSs7", *dataptr)) {
 400                         *bufptr++ = '7';
 401                 } else if (strchr("TtUuVv8", *dataptr)) {
 402                         *bufptr++ = '8';
 403                 } else if (strchr("WwXxYyZz9", *dataptr)) {
 404                         *bufptr++ = '9';
 405                 } else if (*dataptr == '0') {
 406                         *bufptr++ = '0';
 407                 } else if (*dataptr == '\0') {
 408                         *bufptr++ = '\0';
 409                         break;
 410                 }
 411         }
 412         buf[len - 1] = '\0';
 413
 414         return 0;
 415 }
 416
 417 static struct ast_custom_function keypadhash_function = {
 418         .name = "KEYPADHASH",
 419         .synopsis = "Hash the letters in the string into the equivalent keypad numbers.",
 420         .syntax = "KEYPADHASH(<string>)",
 421         .read = keypadhash,
 422         .desc = "Example:  ${KEYPADHASH(Les)} returns \"537\"\n",
 423 };
 424
 425 static char *tdesc = "String handling dialplan functions";
 426
 427 int unload_module(void)
 428 {
 429         int res = 0;
 430
 431         res |= ast_custom_function_unregister(&fieldqty_function);
 432         res |= ast_custom_function_unregister(&filter_function);
 433         res |= ast_custom_function_unregister(&regex_function);
 434         res |= ast_custom_function_unregister(&array_function);
 435         res |= ast_custom_function_unregister(&quote_function);
 436         res |= ast_custom_function_unregister(&len_function);
 437         res |= ast_custom_function_unregister(&strftime_function);
 438         res |= ast_custom_function_unregister(&strptime_function);
 439         res |= ast_custom_function_unregister(&eval_function);
 440         res |= ast_custom_function_unregister(&keypadhash_function);
 441
 442         return res;
 443 }
 444
 445 int load_module(void)
 446 {
 447         int res = 0;
 448
 449         res |= ast_custom_function_register(&fieldqty_function);
 450         res |= ast_custom_function_register(&filter_function);
 451         res |= ast_custom_function_register(&regex_function);
 452         res |= ast_custom_function_register(&array_function);
 453         res |= ast_custom_function_register(&quote_function);
 454         res |= ast_custom_function_register(&len_function);
 455         res |= ast_custom_function_register(&strftime_function);
 456         res |= ast_custom_function_register(&strptime_function);
 457         res |= ast_custom_function_register(&eval_function);
 458         res |= ast_custom_function_register(&keypadhash_function);
 459
 460         return res;
 461 }
 462
 463 const char *description(void)
 464 {
 465         return tdesc;
 466 }
 467
 468 int usecount(void)
 469 {
 470         return 0;
 471 }
 472
 473 const char *key()
 474 {
 475         return ASTERISK_GPL_KEY;
 476 }