447ec8fb560fff036c4273bfa521d0cc260f0882
[asterisk/asterisk.git] / 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 *varval, workspace[4096];
47         int fieldcount = 0;
48         char *parse;
49         AST_DECLARE_APP_ARGS(args,
50                 AST_APP_ARG(varname);
51                 AST_APP_ARG(delim);
52         );
53
54         parse = ast_strdupa(data);
55
56         AST_STANDARD_APP_ARGS(args, parse);
57         if (args.delim) {
58                 pbx_retrieve_variable(chan, args.varname, &varval, workspace, sizeof(workspace), NULL);
59                 while (strsep(&varval, args.delim))
60                         fieldcount++;
61         } else {
62                 fieldcount = 1;
63         }
64         snprintf(buf, len, "%d", fieldcount);
65
66         return buf;
67 }
68
69 #ifndef BUILTIN_FUNC
70 static
71 #endif
72 struct ast_custom_function fieldqty_function = {
73         .name = "FIELDQTY",
74         .synopsis = "Count the fields, with an arbitrary delimiter",
75         .syntax = "FIELDQTY(<varname>,<delim>)",
76         .read = function_fieldqty,
77 };
78
79 static char *builtin_function_filter(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
80 {
81         char *parse;
82         AST_DECLARE_APP_ARGS(args,
83                 AST_APP_ARG(allowed);
84                 AST_APP_ARG(string);
85         );
86         char *outbuf=buf;
87
88         parse = ast_strdupa(data);
89
90         AST_STANDARD_APP_ARGS(args, parse);
91
92         if (!args.string ) {
93                 ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>,<string>)\n");
94                 return "";
95         }
96
97         for ( ; *(args.string) && (buf + len - 1 > outbuf); (args.string)++) {
98                 if (strchr(args.allowed, *(args.string))) {
99                         *outbuf = *(args.string);
100                         outbuf++;
101                 }
102         }
103         *outbuf = '\0';
104         
105         return buf;
106 }
107
108 #ifndef BUILTIN_FUNC
109 static
110 #endif
111 struct ast_custom_function filter_function = {
112         .name = "FILTER",
113         .synopsis = "Filter the string to include only the allowed characters",
114         .syntax = "FILTER(<allowed-chars>,<string>)",
115         .read = builtin_function_filter,
116 };
117
118 static char *builtin_function_regex(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
119 {
120         char *parse;
121         AST_DECLARE_APP_ARGS(args,
122                 AST_APP_ARG(null);
123                 AST_APP_ARG(reg);
124                 AST_APP_ARG(str);
125         );
126                                 
127
128         char errstr[256] = "";
129         int errcode;
130         regex_t regexbuf;
131
132         ast_copy_string(buf, "0", len);
133         
134         parse = ast_strdupa(data);
135
136         AST_NONSTANDARD_APP_ARGS(args, parse, '"');
137
138         ast_log(LOG_DEBUG, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);
139
140         if ((errcode = regcomp(&regexbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
141                 regerror(errcode, &regexbuf, errstr, sizeof(errstr));
142                 ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, data, errstr);
143         } else {
144                 if (!regexec(&regexbuf, args.str, 0, NULL, 0))
145                         ast_copy_string(buf, "1", len); 
146         }
147         regfree(&regexbuf);
148
149         return buf;
150 }
151
152 #ifndef BUILTIN_FUNC
153 static
154 #endif
155 struct ast_custom_function regex_function = {
156         .name = "REGEX",
157         .synopsis = "Regular Expression: Returns 1 if data matches regular expression.",
158         .syntax = "REGEX(\"<regular expression>\" <data>)",
159         .read = builtin_function_regex,
160 };
161
162 static void builtin_function_array(struct ast_channel *chan, char *cmd, char *data, const char *value)
163 {
164         AST_DECLARE_APP_ARGS(arg1,
165                 AST_APP_ARG(var)[100];
166         );
167         AST_DECLARE_APP_ARGS(arg2,
168                 AST_APP_ARG(val)[100];
169         );
170         char *var, *value2;
171         int i;
172
173         var = ast_strdupa(data);
174         value2 = ast_strdupa(value);
175
176         /* The functions this will generally be used with are SORT and ODBC_*, which
177          * both return comma-delimited lists.  However, if somebody uses literal lists,
178          * their commas will be translated to vertical bars by the load, and I don't
179          * want them to be surprised by the result.  Hence, we prefer commas as the
180          * delimiter, but we'll fall back to vertical bars if commas aren't found.
181          */
182         ast_log(LOG_DEBUG, "array (%s=%s)\n", var, value2);
183         if (strchr(var, ',')) {
184                 AST_NONSTANDARD_APP_ARGS(arg1, var, ',');
185         } else {
186                 AST_STANDARD_APP_ARGS(arg1, var);
187         }
188
189         if (strchr(value2, ',')) {
190                 AST_NONSTANDARD_APP_ARGS(arg2, value2, ',');
191         } else {
192                 AST_STANDARD_APP_ARGS(arg2, value2);
193         }
194
195         for (i = 0; i < arg1.argc; i++) {
196                 ast_log(LOG_DEBUG, "array set value (%s=%s)\n", arg1.var[i], arg2.val[i]);
197                 if (i < arg2.argc) {
198                         pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
199                 } else {
200                         /* We could unset the variable, by passing a NULL, but due to
201                          * pushvar semantics, that could create some undesired behavior. */
202                         pbx_builtin_setvar_helper(chan, arg1.var[i], "");
203                 }
204         }
205 }
206
207 #ifndef BUILTIN_FUNC
208 static
209 #endif
210 struct ast_custom_function array_function = {
211         .name = "ARRAY",
212         .synopsis = "Allows setting multiple variables at once",
213         .syntax = "ARRAY(var1[,var2[...][,varN]])",
214         .write = builtin_function_array,
215         .desc =
216 "The comma-separated list passed as a value to which the function is set will\n"
217 "be interpreted as a set of values to which the comma-separated list of\n"
218 "variable names in the argument should be set.\n"
219 "Hence, Set(ARRAY(var1,var2)=1,2) will set var1 to 1 and var2 to 2\n"
220 "Note: remember to either backslash your commas in extensions.conf or quote the\n"
221 "entire argument, since Set can take multiple arguments itself.\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 *parse;
247         AST_DECLARE_APP_ARGS(args,
248                 AST_APP_ARG(epoch);
249                 AST_APP_ARG(timezone);
250                 AST_APP_ARG(format);
251         );
252         long epochi;
253         struct tm time;
254
255         buf[0] = '\0';
256
257         if (ast_strlen_zero(data)) {
258                 ast_log(LOG_ERROR, "Asterisk function STRFTIME() requires an argument.\n");
259                 return buf;
260         }
261         
262         parse = ast_strdupa(data);
263         
264         AST_STANDARD_APP_ARGS(args, parse);
265
266         if (ast_strlen_zero(args.epoch) || !sscanf(args.epoch, "%ld", &epochi)) {
267                 struct timeval tv = ast_tvnow();
268                 epochi = tv.tv_sec;
269         }
270
271         ast_localtime(&epochi, &time, args.timezone);
272
273         if (!strftime(buf, len, args.format?args.format:"%c", &time)) {
274                 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
275         }
276         buf[len - 1] = '\0';
277
278         return buf;
279 }
280
281 #ifndef BUILTIN_FUNC
282 static
283 #endif
284 struct ast_custom_function strftime_function = {
285         .name = "STRFTIME",
286         .synopsis = "Returns the current date/time in a specified format.",
287         .syntax = "STRFTIME([<epoch>][,[timezone][,format]])",
288         .read = acf_strftime,
289 };
290
291 static char *function_eval(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
292 {
293         memset(buf, 0, len);
294
295         if (ast_strlen_zero(data)) {
296                 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
297                 return buf;
298         }
299
300         pbx_substitute_variables_helper(chan, data, buf, len - 1);
301
302         return buf;
303 }
304
305 #ifndef BUILTIN_FUNC
306 static
307 #endif
308 struct ast_custom_function eval_function = {
309         .name = "EVAL",
310         .synopsis = "Evaluate stored variables.",
311         .syntax = "EVAL(<variable>)",
312         .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
313                 "When a variable or expression is in the dialplan, it will be\n"
314                 "evaluated at runtime. However, if the result of the evaluation\n"
315                 "is in fact a variable or expression, using EVAL will have it\n"
316                 "evaluated a second time. For example, if the variable ${MYVAR}\n"
317                 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
318                 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
319                 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
320                 "left with \"${OTHERVAR}\".\n", 
321         .read = function_eval,
322 };
323