added function QUOTE into strings, which allows
[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 <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 char *builtin_function_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 buf;
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 = builtin_function_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 char *description(void)
464 {
465         return tdesc;
466 }
467
468 int usecount(void)
469 {
470         return 0;
471 }
472
473 char *key()
474 {
475         return ASTERISK_GPL_KEY;
476 }