Add Masquerade manager event which trips when a masquerade happens (issue #7840 repor...
[asterisk/asterisk.git] / 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 "asterisk.h"
28
29 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <sys/types.h>
35 #include <regex.h>
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 #include "asterisk/options.h"
45
46 static int function_fieldqty(struct ast_channel *chan, char *cmd,
47                              char *parse, char *buf, size_t len)
48 {
49         char *varval;
50         int fieldcount = 0;
51         AST_DECLARE_APP_ARGS(args,
52                              AST_APP_ARG(varname);
53                              AST_APP_ARG(delim);
54                 );
55
56         AST_STANDARD_APP_ARGS(args, parse);
57         if (args.delim) {
58                 pbx_retrieve_variable(chan, args.varname, &varval, buf, len, NULL);
59                 while (strsep(&varval, args.delim))
60                         fieldcount++;
61         } else {
62                 fieldcount = 1;
63         }
64         snprintf(buf, len, "%d", fieldcount);
65
66         return 0;
67 }
68
69 static struct ast_custom_function fieldqty_function = {
70         .name = "FIELDQTY",
71         .synopsis = "Count the fields, with an arbitrary delimiter",
72         .syntax = "FIELDQTY(<varname>|<delim>)",
73         .read = function_fieldqty,
74 };
75
76 static int filter(struct ast_channel *chan, char *cmd, char *parse, char *buf,
77                   size_t len)
78 {
79         AST_DECLARE_APP_ARGS(args,
80                              AST_APP_ARG(allowed);
81                              AST_APP_ARG(string);
82         );
83         char *outbuf = buf;
84
85         AST_STANDARD_APP_ARGS(args, parse);
86
87         if (!args.string) {
88                 ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>|<string>)\n");
89                 return -1;
90         }
91
92         for (; *(args.string) && (buf + len - 1 > outbuf); (args.string)++) {
93                 if (strchr(args.allowed, *(args.string)))
94                         *outbuf++ = *(args.string);
95         }
96         *outbuf = '\0';
97
98         return 0;
99 }
100
101 static struct ast_custom_function filter_function = {
102         .name = "FILTER",
103         .synopsis = "Filter the string to include only the allowed characters",
104         .syntax = "FILTER(<allowed-chars>|<string>)",
105         .read = filter,
106 };
107
108 static int regex(struct ast_channel *chan, char *cmd, char *parse, char *buf,
109                  size_t len)
110 {
111         AST_DECLARE_APP_ARGS(args,
112                              AST_APP_ARG(null);
113                              AST_APP_ARG(reg);
114                              AST_APP_ARG(str);
115         );
116         int errcode;
117         regex_t regexbuf;
118
119         buf[0] = '\0';
120
121         AST_NONSTANDARD_APP_ARGS(args, parse, '"');
122
123         if (args.argc != 3) {
124                 ast_log(LOG_ERROR, "Unexpected arguments: should have been in the form '\"<regex>\" <string>'\n");
125                 return -1;
126         }
127         if ((*args.str == ' ') || (*args.str == '\t'))
128                 args.str++;
129
130         if (option_debug)
131                 ast_log(LOG_DEBUG, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);
132
133         if ((errcode = regcomp(&regexbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
134                 regerror(errcode, &regexbuf, buf, len);
135                 ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, parse, buf);
136                 return -1;
137         }
138         
139         strcpy(buf, regexec(&regexbuf, args.str, 0, NULL, 0) ? "0" : "1");
140
141         regfree(&regexbuf);
142
143         return 0;
144 }
145
146 static struct ast_custom_function regex_function = {
147         .name = "REGEX",
148         .synopsis = "Regular Expression",
149         .desc =  
150                 "Returns 1 if data matches regular expression, or 0 otherwise.\n"
151                 "Please note that the space following the double quotes separating the regex from the data\n"
152                 "is optional and if present, is skipped. If a space is desired at the beginning of the data,\n"
153                 "then put two spaces there; the second will not be skipped.\n",
154         .syntax = "REGEX(\"<regular expression>\" <data>)",
155         .read = regex,
156 };
157
158 static int array(struct ast_channel *chan, char *cmd, char *var,
159                  const char *value)
160 {
161         AST_DECLARE_APP_ARGS(arg1,
162                              AST_APP_ARG(var)[100];
163         );
164         AST_DECLARE_APP_ARGS(arg2,
165                              AST_APP_ARG(val)[100];
166         );
167         char *value2;
168         int i;
169
170         value2 = ast_strdupa(value);
171         if (!var || !value2)
172                 return -1;
173
174         /* The functions this will generally be used with are SORT and ODBC_*, which
175          * both return comma-delimited lists.  However, if somebody uses literal lists,
176          * their commas will be translated to vertical bars by the load, and I don't
177          * want them to be surprised by the result.  Hence, we prefer commas as the
178          * delimiter, but we'll fall back to vertical bars if commas aren't found.
179          */
180         if (option_debug)
181                 ast_log(LOG_DEBUG, "array (%s=%s)\n", var, value2);
182         if (strchr(var, ','))
183                 AST_NONSTANDARD_APP_ARGS(arg1, var, ',');
184         else
185                 AST_STANDARD_APP_ARGS(arg1, var);
186
187         if (strchr(value2, ','))
188                 AST_NONSTANDARD_APP_ARGS(arg2, value2, ',');
189         else
190                 AST_STANDARD_APP_ARGS(arg2, value2);
191
192         for (i = 0; i < arg1.argc; i++) {
193                 if (option_debug)
194                         ast_log(LOG_DEBUG, "array set value (%s=%s)\n", arg1.var[i],
195                                 arg2.val[i]);
196                 if (i < arg2.argc) {
197                         pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
198                 } else {
199                         /* We could unset the variable, by passing a NULL, but due to
200                          * pushvar semantics, that could create some undesired behavior. */
201                         pbx_builtin_setvar_helper(chan, arg1.var[i], "");
202                 }
203         }
204
205         return 0;
206 }
207
208 static struct ast_custom_function array_function = {
209         .name = "ARRAY",
210         .synopsis = "Allows setting multiple variables at once",
211         .syntax = "ARRAY(var1[|var2[...][|varN]])",
212         .write = array,
213         .desc =
214                 "The comma-separated list passed as a value to which the function is set will\n"
215                 "be interpreted as a set of values to which the comma-separated list of\n"
216                 "variable names in the argument should be set.\n"
217                 "Hence, Set(ARRAY(var1|var2)=1\\,2) will set var1 to 1 and var2 to 2\n"
218                 "Note: remember to either backslash your commas in extensions.conf or quote the\n"
219                 "entire argument, since Set can take multiple arguments itself.\n",
220 };
221
222 static int acf_sprintf(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
223 {
224 #define SPRINTF_FLAG    0
225 #define SPRINTF_WIDTH   1
226 #define SPRINTF_PRECISION       2
227 #define SPRINTF_LENGTH  3
228 #define SPRINTF_CONVERSION      4
229         int i, state = -1, argcount = 0;
230         char *formatstart = NULL, *bufptr = buf;
231         char formatbuf[256] = "";
232         int tmpi;
233         double tmpd;
234         AST_DECLARE_APP_ARGS(arg,
235                                 AST_APP_ARG(format);
236                                 AST_APP_ARG(var)[100];
237         );
238
239         AST_STANDARD_APP_ARGS(arg, data);
240
241         /* Scan the format, converting each argument into the requisite format type. */
242         for (i = 0; arg.format[i]; i++) {
243                 switch (state) {
244                 case SPRINTF_FLAG:
245                         if (strchr("#0- +'I", arg.format[i]))
246                                 break;
247                         state = SPRINTF_WIDTH;
248                 case SPRINTF_WIDTH:
249                         if (arg.format[i] >= '0' && arg.format[i] <= '9')
250                                 break;
251
252                         /* Next character must be a period to go into a precision */
253                         if (arg.format[i] == '.') {
254                                 state = SPRINTF_PRECISION;
255                         } else {
256                                 state = SPRINTF_LENGTH;
257                                 i--;
258                         }
259                         break;
260                 case SPRINTF_PRECISION:
261                         if (arg.format[i] >= '0' && arg.format[i] <= '9')
262                                 break;
263                         state = SPRINTF_LENGTH;
264                 case SPRINTF_LENGTH:
265                         if (strchr("hl", arg.format[i])) {
266                                 if (arg.format[i + 1] == arg.format[i])
267                                         i++;
268                                 state = SPRINTF_CONVERSION;
269                                 break;
270                         } else if (strchr("Lqjzt", arg.format[i]))
271                                 state = SPRINTF_CONVERSION;
272                                 break;
273                         state = SPRINTF_CONVERSION;
274                 case SPRINTF_CONVERSION:
275                         if (strchr("diouxXc", arg.format[i])) {
276                                 /* Integer */
277
278                                 /* Isolate this format alone */
279                                 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
280                                 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
281
282                                 /* Convert the argument into the required type */
283                                 if (sscanf(arg.var[argcount++], "%i", &tmpi) != 1) {
284                                         ast_log(LOG_ERROR, "Argument '%s' is not an integer number for format '%s'\n", arg.var[argcount - 1], formatbuf);
285                                         goto sprintf_fail;
286                                 }
287
288                                 /* Format the argument */
289                                 snprintf(bufptr, buf + len - bufptr, formatbuf, tmpi);
290
291                                 /* Update the position of the next parameter to print */
292                                 bufptr = strchr(buf, '\0');
293                         } else if (strchr("eEfFgGaA", arg.format[i])) {
294                                 /* Double */
295
296                                 /* Isolate this format alone */
297                                 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
298                                 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
299
300                                 /* Convert the argument into the required type */
301                                 if (sscanf(arg.var[argcount++], "%lf", &tmpd) != 1) {
302                                         ast_log(LOG_ERROR, "Argument '%s' is not a floating point number for format '%s'\n", arg.var[argcount - 1], formatbuf);
303                                         goto sprintf_fail;
304                                 }
305
306                                 /* Format the argument */
307                                 snprintf(bufptr, buf + len - bufptr, formatbuf, tmpd);
308
309                                 /* Update the position of the next parameter to print */
310                                 bufptr = strchr(buf, '\0');
311                         } else if (arg.format[i] == 's') {
312                                 /* String */
313
314                                 /* Isolate this format alone */
315                                 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
316                                 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
317
318                                 /* Format the argument */
319                                 snprintf(bufptr, buf + len - bufptr, formatbuf, arg.var[argcount++]);
320
321                                 /* Update the position of the next parameter to print */
322                                 bufptr = strchr(buf, '\0');
323                         } else if (arg.format[i] == '%') {
324                                 /* Literal data to copy */
325                                 *bufptr++ = arg.format[i];
326                         } else {
327                                 /* Not supported */
328
329                                 /* Isolate this format alone */
330                                 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
331                                 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
332
333                                 ast_log(LOG_ERROR, "Format type not supported: '%s' with argument '%s'\n", formatbuf, arg.var[argcount++]);
334                                 goto sprintf_fail;
335                         }
336                         state = -1;
337                         break;
338                 default:
339                         if (arg.format[i] == '%') {
340                                 state = SPRINTF_FLAG;
341                                 formatstart = &arg.format[i];
342                                 break;
343                         } else {
344                                 /* Literal data to copy */
345                                 *bufptr++ = arg.format[i];
346                         }
347                 }
348         }
349         return 0;
350 sprintf_fail:
351         return -1;
352 }
353
354 static struct ast_custom_function sprintf_function = {
355         .name = "SPRINTF",
356         .synopsis = "Format a variable according to a format string",
357         .syntax = "SPRINTF(<format>|<arg1>[|...<argN>])",
358         .read = acf_sprintf,
359         .desc =
360 "Parses the format string specified and returns a string matching that format.\n"
361 "Supports most options supported by sprintf(3).  Returns a shortened string if\n"
362 "a format specifier is not recognized.\n",
363 };
364
365 static int quote(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
366 {
367         char *bufptr = buf, *dataptr = data;
368         *bufptr++ = '"';
369         for (; bufptr < buf + len - 1; dataptr++) {
370                 if (*dataptr == '\\') {
371                         *bufptr++ = '\\';
372                         *bufptr++ = '\\';
373                 } else if (*dataptr == '"') {
374                         *bufptr++ = '\\';
375                         *bufptr++ = '"';
376                 } else if (*dataptr == '\0') {
377                         break;
378                 } else {
379                         *bufptr++ = *dataptr;
380                 }
381         }
382         *bufptr++ = '"';
383         *bufptr = '\0';
384         return 0;
385 }
386
387 static struct ast_custom_function quote_function = {
388         .name = "QUOTE",
389         .synopsis = "Quotes a given string, escaping embedded quotes as necessary",
390         .syntax = "QUOTE(<string>)",
391         .read = quote,
392 };
393
394
395 static int len(struct ast_channel *chan, char *cmd, char *data, char *buf,
396                size_t len)
397 {
398         int length = 0;
399
400         if (data)
401                 length = strlen(data);
402
403         snprintf(buf, len, "%d", length);
404
405         return 0;
406 }
407
408 static struct ast_custom_function len_function = {
409         .name = "LEN",
410         .synopsis = "Returns the length of the argument given",
411         .syntax = "LEN(<string>)",
412         .read = len,
413 };
414
415 static int acf_strftime(struct ast_channel *chan, char *cmd, char *parse,
416                         char *buf, size_t len)
417 {
418         AST_DECLARE_APP_ARGS(args,
419                              AST_APP_ARG(epoch);
420                              AST_APP_ARG(timezone);
421                              AST_APP_ARG(format);
422         );
423         time_t epochi;
424         struct tm tm;
425
426         buf[0] = '\0';
427
428         if (ast_strlen_zero(parse)) {
429                 ast_log(LOG_ERROR,
430                                 "Asterisk function STRFTIME() requires an argument.\n");
431                 return -1;
432         }
433
434         AST_STANDARD_APP_ARGS(args, parse);
435
436         ast_get_time_t(args.epoch, &epochi, time(NULL), NULL);
437         ast_localtime(&epochi, &tm, args.timezone);
438
439         if (!args.format)
440                 args.format = "%c";
441
442         if (!strftime(buf, len, args.format, &tm))
443                 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
444
445         buf[len - 1] = '\0';
446
447         return 0;
448 }
449
450 static struct ast_custom_function strftime_function = {
451         .name = "STRFTIME",
452         .synopsis = "Returns the current date/time in a specified format.",
453         .syntax = "STRFTIME([<epoch>][|[timezone][|format]])",
454         .read = acf_strftime,
455 };
456
457 static int acf_strptime(struct ast_channel *chan, char *cmd, char *data,
458                         char *buf, size_t len)
459 {
460         AST_DECLARE_APP_ARGS(args,
461                              AST_APP_ARG(timestring);
462                              AST_APP_ARG(timezone);
463                              AST_APP_ARG(format);
464         );
465         struct tm time;
466
467         memset(&time, 0, sizeof(struct tm));
468
469         buf[0] = '\0';
470
471         if (!data) {
472                 ast_log(LOG_ERROR,
473                                 "Asterisk function STRPTIME() requires an argument.\n");
474                 return -1;
475         }
476
477         AST_STANDARD_APP_ARGS(args, data);
478
479         if (ast_strlen_zero(args.format)) {
480                 ast_log(LOG_ERROR,
481                                 "No format supplied to STRPTIME(<timestring>|<timezone>|<format>)");
482                 return -1;
483         }
484
485         if (!strptime(args.timestring, args.format, &time)) {
486                 ast_log(LOG_WARNING, "C function strptime() output nothing?!!\n");
487         } else {
488                 snprintf(buf, len, "%d", (int) ast_mktime(&time, args.timezone));
489         }
490
491         return 0;
492 }
493
494 static struct ast_custom_function strptime_function = {
495         .name = "STRPTIME",
496         .synopsis =
497                 "Returns the epoch of the arbitrary date/time string structured as described in the format.",
498         .syntax = "STRPTIME(<datetime>|<timezone>|<format>)",
499         .desc =
500                 "This is useful for converting a date into an EPOCH time, possibly to pass to\n"
501                 "an application like SayUnixTime or to calculate the difference between two\n"
502                 "date strings.\n"
503                 "\n"
504                 "Example:\n"
505                 "  ${STRPTIME(2006-03-01 07:30:35|America/Chicago|%Y-%m-%d %H:%M:%S)} returns 1141219835\n",
506         .read = acf_strptime,
507 };
508
509 static int function_eval(struct ast_channel *chan, char *cmd, char *data,
510                          char *buf, size_t len)
511 {
512         buf[0] = '\0';
513
514         if (ast_strlen_zero(data)) {
515                 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
516                 return -1;
517         }
518
519         pbx_substitute_variables_helper(chan, data, buf, len - 1);
520
521         return 0;
522 }
523
524 static struct ast_custom_function eval_function = {
525         .name = "EVAL",
526         .synopsis = "Evaluate stored variables.",
527         .syntax = "EVAL(<variable>)",
528         .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
529                 "When a variable or expression is in the dialplan, it will be\n"
530                 "evaluated at runtime. However, if the result of the evaluation\n"
531                 "is in fact a variable or expression, using EVAL will have it\n"
532                 "evaluated a second time. For example, if the variable ${MYVAR}\n"
533                 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
534                 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
535                 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
536                 "left with \"${OTHERVAR}\".\n",
537         .read = function_eval,
538 };
539
540 static int keypadhash(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
541 {
542         char *bufptr, *dataptr;
543
544         for (bufptr = buf, dataptr = data; bufptr < buf + len - 1; dataptr++) {
545                 if (*dataptr == '1') {
546                         *bufptr++ = '1';
547                 } else if (strchr("AaBbCc2", *dataptr)) {
548                         *bufptr++ = '2';
549                 } else if (strchr("DdEeFf3", *dataptr)) {
550                         *bufptr++ = '3';
551                 } else if (strchr("GgHhIi4", *dataptr)) {
552                         *bufptr++ = '4';
553                 } else if (strchr("JjKkLl5", *dataptr)) {
554                         *bufptr++ = '5';
555                 } else if (strchr("MmNnOo6", *dataptr)) {
556                         *bufptr++ = '6';
557                 } else if (strchr("PpQqRrSs7", *dataptr)) {
558                         *bufptr++ = '7';
559                 } else if (strchr("TtUuVv8", *dataptr)) {
560                         *bufptr++ = '8';
561                 } else if (strchr("WwXxYyZz9", *dataptr)) {
562                         *bufptr++ = '9';
563                 } else if (*dataptr == '0') {
564                         *bufptr++ = '0';
565                 } else if (*dataptr == '\0') {
566                         *bufptr++ = '\0';
567                         break;
568                 }
569         }
570         buf[len - 1] = '\0';
571
572         return 0;
573 }
574
575 static struct ast_custom_function keypadhash_function = {
576         .name = "KEYPADHASH",
577         .synopsis = "Hash the letters in the string into the equivalent keypad numbers.",
578         .syntax = "KEYPADHASH(<string>)",
579         .read = keypadhash,
580         .desc = "Example:  ${KEYPADHASH(Les)} returns \"537\"\n",
581 };
582
583 static int unload_module(void)
584 {
585         int res = 0;
586
587         res |= ast_custom_function_unregister(&fieldqty_function);
588         res |= ast_custom_function_unregister(&filter_function);
589         res |= ast_custom_function_unregister(&regex_function);
590         res |= ast_custom_function_unregister(&array_function);
591         res |= ast_custom_function_unregister(&quote_function);
592         res |= ast_custom_function_unregister(&len_function);
593         res |= ast_custom_function_unregister(&strftime_function);
594         res |= ast_custom_function_unregister(&strptime_function);
595         res |= ast_custom_function_unregister(&eval_function);
596         res |= ast_custom_function_unregister(&keypadhash_function);
597         res |= ast_custom_function_unregister(&sprintf_function);
598
599         return res;
600 }
601
602 static int load_module(void)
603 {
604         int res = 0;
605
606         res |= ast_custom_function_register(&fieldqty_function);
607         res |= ast_custom_function_register(&filter_function);
608         res |= ast_custom_function_register(&regex_function);
609         res |= ast_custom_function_register(&array_function);
610         res |= ast_custom_function_register(&quote_function);
611         res |= ast_custom_function_register(&len_function);
612         res |= ast_custom_function_register(&strftime_function);
613         res |= ast_custom_function_register(&strptime_function);
614         res |= ast_custom_function_register(&eval_function);
615         res |= ast_custom_function_register(&keypadhash_function);
616         res |= ast_custom_function_register(&sprintf_function);
617
618         return res;
619 }
620
621 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "String handling dialplan functions");