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