add EVAL function, deprecate Eval application (bug #4277)
[asterisk/asterisk.git] / funcs / func_strings.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * String manipulation dialplan functions
5  * 
6  * Copyright (C) 2005, Digium, Inc.
7  * Portions Copyright (C) 2005, Tilghman Lesher.  All rights reserved.
8  * Portions Copyright (C) 2005, Anthony Minessale II
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #include <stdlib.h>
15 #include <string.h>
16 #include <sys/types.h>
17 #include <regex.h>
18
19 #include "asterisk/channel.h"
20 #include "asterisk/pbx.h"
21 #include "asterisk/logger.h"
22 #include "asterisk/utils.h"
23 #include "asterisk/app.h"
24 #include "asterisk/localtime.h"
25
26 static char *function_fieldqty(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
27 {
28         char *varname, *varval, workspace[256];
29         char *delim = ast_strdupa(data);
30         int fieldcount = 0;
31
32         if (delim) {
33                 varname = strsep(&delim, "|");
34                 pbx_retrieve_variable(chan, varname, &varval, workspace, sizeof(workspace), NULL);
35                 while (strsep(&varval, delim))
36                         fieldcount++;
37                 snprintf(buf, len, "%d", fieldcount);
38         } else {
39                 ast_log(LOG_ERROR, "Out of memory\n");
40                 strncpy(buf, "1", len);
41         }
42         return buf;
43 }
44
45 #ifndef BUILTIN_FUNC
46 static
47 #endif
48 struct ast_custom_function fieldqty_function = {
49         .name = "FIELDQTY",
50         .synopsis = "Count the fields, with an arbitrary delimiter",
51         .syntax = "FIELDQTY(<varname>,<delim>)",
52         .read = function_fieldqty,
53 };
54
55 static char *builtin_function_regex(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
56 {
57         char *ret_true = "1", *ret_false = "0", *ret;
58         char *arg, *earg, *tmp, errstr[256] = "";
59         int errcode;
60         regex_t regexbuf;
61
62         ret = ret_false; /* convince me otherwise */
63         tmp = ast_strdupa(data);
64         if (tmp) {
65                 /* Regex in quotes */
66                 arg = strchr(tmp, '"');
67                 if (arg) {
68                         arg++;
69                         earg = strrchr(arg, '"');
70                         if (earg) {
71                                 *earg = '\0';
72                         }
73                 } else {
74                         arg = tmp;
75                 }
76
77                 if ((errcode = regcomp(&regexbuf, arg, REG_EXTENDED | REG_NOSUB))) {
78                         regerror(errcode, &regexbuf, errstr, sizeof(errstr));
79                         ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, data, errstr);
80                         ret = NULL;
81                 } else {
82                         ret = regexec(&regexbuf, data, 0, NULL, 0) ? ret_false : ret_true;
83                 }
84                 regfree(&regexbuf);
85         } else {
86                 ast_log(LOG_ERROR, "Out of memory in %s(%s)\n", cmd, data);
87         }
88
89         return ret;
90 }
91
92 #ifndef BUILTIN_FUNC
93 static
94 #endif
95 struct ast_custom_function regex_function = {
96         .name = "REGEX",
97         .synopsis = "Regular Expression: Returns 1 if data matches regular expression.",
98         .syntax = "REGEX(\"<regular expression>\" <data>)",
99         .read = builtin_function_regex,
100 };
101
102 static char *builtin_function_len(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
103 {
104         int length = 0;
105         if (data) {
106                 length = strlen(data);
107         }
108         snprintf(buf, len, "%d", length);
109         return buf;
110 }
111
112 #ifndef BUILTIN_FUNC
113 static
114 #endif
115 struct ast_custom_function len_function = {
116         .name = "LEN",
117         .synopsis = "Returns the length of the argument given",
118         .syntax = "LEN(<string>)",
119         .read = builtin_function_len,
120 };
121
122 static char *acf_strftime(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
123 {
124         char *format, *epoch, *timezone;
125         long epochi;
126         struct timeval tv;
127         struct tm time;
128
129         if (data) {
130                 format = ast_strdupa(data);
131                 if (format) {
132                         epoch = strsep(&format, "|");
133                         timezone = strsep(&format, "|");
134
135                         if (epoch && !ast_strlen_zero(epoch) && sscanf(epoch, "%ld", &epochi) == 1) {
136                         } else if (!gettimeofday(&tv, NULL)) {
137                                 epochi = tv.tv_sec;
138                         } else {
139                                 ast_log(LOG_ERROR, "Cannot gettimeofday() ?!!\n");
140                                 return "";
141                         }
142
143                         ast_localtime(&epochi, &time, timezone);
144
145                         if (!format) {
146                                 format = "%c";
147                         }
148
149                         buf[0] = '\0';
150                         if (! strftime(buf, len, format, &time)) {
151                                 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
152                         }
153                         buf[len - 1] = '\0';
154
155                         return buf;
156                 } else {
157                         ast_log(LOG_ERROR, "Out of memory\n");
158                 }
159         } else {
160                 ast_log(LOG_ERROR, "Asterisk function STRFTIME() requires an argument.\n");
161         }
162         return "";
163 }
164
165 #ifndef BUILTIN_FUNC
166 static
167 #endif
168 struct ast_custom_function strftime_function = {
169         .name = "STRFTIME",
170         .synopsis = "Returns the current date/time in a specified format.",
171         .syntax = "STRFTIME([<epoch>][,[timezone][,format]])",
172         .read = acf_strftime,
173 };
174
175 static char *function_eval(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
176 {
177         if (!data || ast_strlen_zero(data)) {
178                 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<variable>)\n");
179                 return buf;
180         }
181         
182         pbx_substitute_variables_helper(chan, data, buf, len - 1);
183
184         return buf;
185 }
186
187 #ifndef BUILTIN_FUNC
188 static
189 #endif
190 struct ast_custom_function eval_function = {
191         .name = "EVAL",
192         .synopsis = "Evaluate stored variables.",
193         .syntax = "EVAL(<variable>)",
194         .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
195                 "When a variable or expression is in the dialplan, it will be\n"
196                 "evaluated at runtime. However, if the result of the evaluation\n"
197                 "is in fact a variable or expression, using EVAL will have it\n"
198                 "evaluated a second time. For example, if the variable ${MYVAR}\n"
199                 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
200                 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
201                 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
202                 "left with \"${OTHERVAR}\".\n", 
203         .read = function_eval,
204 };
205