more file version tags
[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 timeval tv;
131         struct tm time;
132
133         if (data) {
134                 format = ast_strdupa(data);
135                 if (format) {
136                         epoch = strsep(&format, "|");
137                         timezone = strsep(&format, "|");
138
139                         if (epoch && !ast_strlen_zero(epoch) && sscanf(epoch, "%ld", &epochi) == 1) {
140                         } else if (!gettimeofday(&tv, NULL)) {
141                                 epochi = tv.tv_sec;
142                         } else {
143                                 ast_log(LOG_ERROR, "Cannot gettimeofday() ?!!\n");
144                                 return "";
145                         }
146
147                         ast_localtime(&epochi, &time, timezone);
148
149                         if (!format) {
150                                 format = "%c";
151                         }
152
153                         buf[0] = '\0';
154                         if (! strftime(buf, len, format, &time)) {
155                                 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
156                         }
157                         buf[len - 1] = '\0';
158
159                         return buf;
160                 } else {
161                         ast_log(LOG_ERROR, "Out of memory\n");
162                 }
163         } else {
164                 ast_log(LOG_ERROR, "Asterisk function STRFTIME() requires an argument.\n");
165         }
166         return "";
167 }
168
169 #ifndef BUILTIN_FUNC
170 static
171 #endif
172 struct ast_custom_function strftime_function = {
173         .name = "STRFTIME",
174         .synopsis = "Returns the current date/time in a specified format.",
175         .syntax = "STRFTIME([<epoch>][,[timezone][,format]])",
176         .read = acf_strftime,
177 };
178
179 static char *function_eval(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
180 {
181         if (!data || ast_strlen_zero(data)) {
182                 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<variable>)\n");
183                 return buf;
184         }
185         
186         pbx_substitute_variables_helper(chan, data, buf, len - 1);
187
188         return buf;
189 }
190
191 #ifndef BUILTIN_FUNC
192 static
193 #endif
194 struct ast_custom_function eval_function = {
195         .name = "EVAL",
196         .synopsis = "Evaluate stored variables.",
197         .syntax = "EVAL(<variable>)",
198         .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
199                 "When a variable or expression is in the dialplan, it will be\n"
200                 "evaluated at runtime. However, if the result of the evaluation\n"
201                 "is in fact a variable or expression, using EVAL will have it\n"
202                 "evaluated a second time. For example, if the variable ${MYVAR}\n"
203                 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
204                 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
205                 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
206                 "left with \"${OTHERVAR}\".\n", 
207         .read = function_eval,
208 };
209