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