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