00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "asterisk.h"
00028
00029 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 221303 $")
00030
00031 #include <stdlib.h>
00032 #include <stdio.h>
00033 #include <string.h>
00034 #include <sys/types.h>
00035 #include <regex.h>
00036
00037 #include "asterisk/module.h"
00038 #include "asterisk/options.h"
00039 #include "asterisk/channel.h"
00040 #include "asterisk/pbx.h"
00041 #include "asterisk/logger.h"
00042 #include "asterisk/utils.h"
00043 #include "asterisk/app.h"
00044 #include "asterisk/localtime.h"
00045
00046 static int function_fieldqty(struct ast_channel *chan, char *cmd,
00047 char *parse, char *buf, size_t len)
00048 {
00049 char *varsubst, varval[8192] = "", *varval2 = varval;
00050 int fieldcount = 0;
00051 AST_DECLARE_APP_ARGS(args,
00052 AST_APP_ARG(varname);
00053 AST_APP_ARG(delim);
00054 );
00055
00056 AST_STANDARD_APP_ARGS(args, parse);
00057 if (args.delim) {
00058 varsubst = alloca(strlen(args.varname) + 4);
00059
00060 sprintf(varsubst, "${%s}", args.varname);
00061 pbx_substitute_variables_helper(chan, varsubst, varval, sizeof(varval) - 1);
00062 if (ast_strlen_zero(varval2))
00063 fieldcount = 0;
00064 else {
00065 while (strsep(&varval2, args.delim))
00066 fieldcount++;
00067 }
00068 } else {
00069 fieldcount = 1;
00070 }
00071 snprintf(buf, len, "%d", fieldcount);
00072
00073 return 0;
00074 }
00075
00076 static struct ast_custom_function fieldqty_function = {
00077 .name = "FIELDQTY",
00078 .synopsis = "Count the fields, with an arbitrary delimiter",
00079 .syntax = "FIELDQTY(<varname>|<delim>)",
00080 .read = function_fieldqty,
00081 };
00082
00083 static int filter(struct ast_channel *chan, char *cmd, char *parse, char *buf,
00084 size_t len)
00085 {
00086 AST_DECLARE_APP_ARGS(args,
00087 AST_APP_ARG(allowed);
00088 AST_APP_ARG(string);
00089 );
00090 char *outbuf = buf;
00091
00092 AST_STANDARD_APP_ARGS(args, parse);
00093
00094 if (!args.string) {
00095 ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>|<string>)\n");
00096 return -1;
00097 }
00098
00099 for (; *(args.string) && (buf + len - 1 > outbuf); (args.string)++) {
00100 if (strchr(args.allowed, *(args.string)))
00101 *outbuf++ = *(args.string);
00102 }
00103 *outbuf = '\0';
00104
00105 return 0;
00106 }
00107
00108 static struct ast_custom_function filter_function = {
00109 .name = "FILTER",
00110 .synopsis = "Filter the string to include only the allowed characters",
00111 .syntax = "FILTER(<allowed-chars>|<string>)",
00112 .read = filter,
00113 };
00114
00115 static int regex(struct ast_channel *chan, char *cmd, char *parse, char *buf,
00116 size_t len)
00117 {
00118 AST_DECLARE_APP_ARGS(args,
00119 AST_APP_ARG(null);
00120 AST_APP_ARG(reg);
00121 AST_APP_ARG(str);
00122 );
00123 int errcode;
00124 regex_t regexbuf;
00125
00126 buf[0] = '\0';
00127
00128 AST_NONSTANDARD_APP_ARGS(args, parse, '"');
00129
00130 if (args.argc != 3) {
00131 ast_log(LOG_ERROR, "Unexpected arguments: should have been in the form '\"<regex>\" <string>'\n");
00132 return -1;
00133 }
00134 if ((*args.str == ' ') || (*args.str == '\t'))
00135 args.str++;
00136
00137 if (option_debug)
00138 ast_log(LOG_DEBUG, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);
00139
00140 if ((errcode = regcomp(®exbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
00141 regerror(errcode, ®exbuf, buf, len);
00142 ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, parse, buf);
00143 return -1;
00144 }
00145
00146 strcpy(buf, regexec(®exbuf, args.str, 0, NULL, 0) ? "0" : "1");
00147
00148 regfree(®exbuf);
00149
00150 return 0;
00151 }
00152
00153 static struct ast_custom_function regex_function = {
00154 .name = "REGEX",
00155 .synopsis = "Regular Expression",
00156 .desc =
00157 "Returns 1 if data matches regular expression, or 0 otherwise.\n"
00158 "Please note that the space following the double quotes separating the regex from the data\n"
00159 "is optional and if present, is skipped. If a space is desired at the beginning of the data,\n"
00160 "then put two spaces there; the second will not be skipped.\n",
00161 .syntax = "REGEX(\"<regular expression>\" <data>)",
00162 .read = regex,
00163 };
00164
00165 static int array(struct ast_channel *chan, char *cmd, char *var,
00166 const char *value)
00167 {
00168 AST_DECLARE_APP_ARGS(arg1,
00169 AST_APP_ARG(var)[100];
00170 );
00171 AST_DECLARE_APP_ARGS(arg2,
00172 AST_APP_ARG(val)[100];
00173 );
00174 char *value2;
00175 int i;
00176
00177 value2 = ast_strdupa(value);
00178 if (!var || !value2)
00179 return -1;
00180
00181
00182
00183
00184
00185
00186
00187 if (option_debug)
00188 ast_log(LOG_DEBUG, "array (%s=%s)\n", var, value2);
00189 if (strchr(var, ','))
00190 AST_NONSTANDARD_APP_ARGS(arg1, var, ',');
00191 else
00192 AST_STANDARD_APP_ARGS(arg1, var);
00193
00194 if (strchr(value2, ','))
00195 AST_NONSTANDARD_APP_ARGS(arg2, value2, ',');
00196 else
00197 AST_STANDARD_APP_ARGS(arg2, value2);
00198
00199 for (i = 0; i < arg1.argc; i++) {
00200 if (option_debug)
00201 ast_log(LOG_DEBUG, "array set value (%s=%s)\n", arg1.var[i],
00202 arg2.val[i]);
00203 if (i < arg2.argc) {
00204 pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
00205 } else {
00206
00207
00208 pbx_builtin_setvar_helper(chan, arg1.var[i], "");
00209 }
00210 }
00211
00212 return 0;
00213 }
00214
00215 static struct ast_custom_function array_function = {
00216 .name = "ARRAY",
00217 .synopsis = "Allows setting multiple variables at once",
00218 .syntax = "ARRAY(var1[|var2[...][|varN]])",
00219 .write = array,
00220 .desc =
00221 "The comma-separated list passed as a value to which the function is set will\n"
00222 "be interpreted as a set of values to which the comma-separated list of\n"
00223 "variable names in the argument should be set.\n"
00224 "Hence, Set(ARRAY(var1|var2)=1\\,2) will set var1 to 1 and var2 to 2\n"
00225 "Note: remember to either backslash your commas in extensions.conf or quote the\n"
00226 "entire argument, since Set can take multiple arguments itself.\n",
00227 };
00228
00229 static int acf_sprintf(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00230 {
00231 #define SPRINTF_FLAG 0
00232 #define SPRINTF_WIDTH 1
00233 #define SPRINTF_PRECISION 2
00234 #define SPRINTF_LENGTH 3
00235 #define SPRINTF_CONVERSION 4
00236 int i, state = -1, argcount = 0;
00237 char *formatstart = NULL, *bufptr = buf;
00238 char formatbuf[256] = "";
00239 int tmpi;
00240 double tmpd;
00241 AST_DECLARE_APP_ARGS(arg,
00242 AST_APP_ARG(format);
00243 AST_APP_ARG(var)[100];
00244 );
00245
00246 AST_STANDARD_APP_ARGS(arg, data);
00247
00248
00249 for (i = 0; arg.format[i]; i++) {
00250 switch (state) {
00251 case SPRINTF_FLAG:
00252 if (strchr("#0- +'I", arg.format[i]))
00253 break;
00254 state = SPRINTF_WIDTH;
00255 case SPRINTF_WIDTH:
00256 if (arg.format[i] >= '0' && arg.format[i] <= '9')
00257 break;
00258
00259
00260 if (arg.format[i] == '.') {
00261 state = SPRINTF_PRECISION;
00262 } else {
00263 state = SPRINTF_LENGTH;
00264 i--;
00265 }
00266 break;
00267 case SPRINTF_PRECISION:
00268 if (arg.format[i] >= '0' && arg.format[i] <= '9')
00269 break;
00270 state = SPRINTF_LENGTH;
00271 case SPRINTF_LENGTH:
00272 if (strchr("hl", arg.format[i])) {
00273 if (arg.format[i + 1] == arg.format[i])
00274 i++;
00275 state = SPRINTF_CONVERSION;
00276 break;
00277 } else if (strchr("Lqjzt", arg.format[i])) {
00278 state = SPRINTF_CONVERSION;
00279 break;
00280 }
00281 state = SPRINTF_CONVERSION;
00282 case SPRINTF_CONVERSION:
00283 if (strchr("diouxXc", arg.format[i])) {
00284
00285
00286
00287 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00288 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00289
00290
00291 if (arg.var[argcount]) {
00292 if (sscanf(arg.var[argcount++], "%30d", &tmpi) != 1) {
00293 ast_log(LOG_ERROR, "Argument '%s' is not an integer number for format '%s'\n", arg.var[argcount - 1], formatbuf);
00294 goto sprintf_fail;
00295 }
00296 } else {
00297 ast_log(LOG_ERROR, "SPRINTF() has more format specifiers than arguments!\n");
00298 goto sprintf_fail;
00299 }
00300
00301
00302 snprintf(bufptr, buf + len - bufptr, formatbuf, tmpi);
00303
00304
00305 bufptr = strchr(buf, '\0');
00306 } else if (strchr("eEfFgGaA", arg.format[i])) {
00307
00308
00309
00310 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00311 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00312
00313
00314 if (arg.var[argcount]) {
00315 if (sscanf(arg.var[argcount++], "%30lf", &tmpd) != 1) {
00316 ast_log(LOG_ERROR, "Argument '%s' is not a floating point number for format '%s'\n", arg.var[argcount - 1], formatbuf);
00317 goto sprintf_fail;
00318 }
00319 } else {
00320 ast_log(LOG_ERROR, "SPRINTF() has more format specifiers than arguments!\n");
00321 goto sprintf_fail;
00322 }
00323
00324
00325 snprintf(bufptr, buf + len - bufptr, formatbuf, tmpd);
00326
00327
00328 bufptr = strchr(buf, '\0');
00329 } else if (arg.format[i] == 's') {
00330
00331
00332
00333 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00334 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00335
00336
00337 snprintf(bufptr, buf + len - bufptr, formatbuf, arg.var[argcount++]);
00338
00339
00340 bufptr = strchr(buf, '\0');
00341 } else if (arg.format[i] == '%') {
00342
00343 *bufptr++ = arg.format[i];
00344 } else {
00345
00346
00347
00348 ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00349 formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00350
00351 ast_log(LOG_ERROR, "Format type not supported: '%s' with argument '%s'\n", formatbuf, arg.var[argcount++]);
00352 goto sprintf_fail;
00353 }
00354 state = -1;
00355 break;
00356 default:
00357 if (arg.format[i] == '%') {
00358 state = SPRINTF_FLAG;
00359 formatstart = &arg.format[i];
00360 break;
00361 } else {
00362
00363 *bufptr++ = arg.format[i];
00364 }
00365 }
00366 }
00367 *bufptr = '\0';
00368 return 0;
00369 sprintf_fail:
00370 return -1;
00371 }
00372
00373 static struct ast_custom_function sprintf_function = {
00374 .name = "SPRINTF",
00375 .synopsis = "Format a variable according to a format string",
00376 .syntax = "SPRINTF(<format>|<arg1>[|...<argN>])",
00377 .read = acf_sprintf,
00378 .desc =
00379 "Parses the format string specified and returns a string matching that format.\n"
00380 "Supports most options supported by sprintf(3). Returns a shortened string if\n"
00381 "a format specifier is not recognized.\n",
00382 };
00383
00384 static int quote(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00385 {
00386 char *bufptr = buf, *dataptr = data;
00387
00388 if (len < 3){
00389 ast_log(LOG_ERROR, "Not enough buffer");
00390 return -1;
00391 }
00392
00393 if (ast_strlen_zero(data)) {
00394 ast_log(LOG_WARNING, "No argument specified!\n");
00395 ast_copy_string(buf, "\"\"", len);
00396 return 0;
00397 }
00398
00399 *bufptr++ = '"';
00400 for (; bufptr < buf + len - 3; dataptr++) {
00401 if (*dataptr == '\\') {
00402 *bufptr++ = '\\';
00403 *bufptr++ = '\\';
00404 } else if (*dataptr == '"') {
00405 *bufptr++ = '\\';
00406 *bufptr++ = '"';
00407 } else if (*dataptr == '\0') {
00408 break;
00409 } else {
00410 *bufptr++ = *dataptr;
00411 }
00412 }
00413 *bufptr++ = '"';
00414 *bufptr = '\0';
00415 return 0;
00416 }
00417
00418 static struct ast_custom_function quote_function = {
00419 .name = "QUOTE",
00420 .synopsis = "Quotes a given string, escaping embedded quotes as necessary",
00421 .syntax = "QUOTE(<string>)",
00422 .read = quote,
00423 };
00424
00425 static int csv_quote(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00426 {
00427 char *bufptr = buf, *dataptr = data;
00428
00429 if (len < 3){
00430 ast_log(LOG_ERROR, "Not enough buffer");
00431 return -1;
00432 }
00433
00434 if (ast_strlen_zero(data)) {
00435 ast_log(LOG_WARNING, "No argument specified!\n");
00436 ast_copy_string(buf,"\"\"",len);
00437 return 0;
00438 }
00439
00440 *bufptr++ = '"';
00441 for (; bufptr < buf + len - 3; dataptr++){
00442 if (*dataptr == '"') {
00443 *bufptr++ = '"';
00444 *bufptr++ = '"';
00445 } else if (*dataptr == '\0') {
00446 break;
00447 } else {
00448 *bufptr++ = *dataptr;
00449 }
00450 }
00451 *bufptr++ = '"';
00452 *bufptr='\0';
00453 return 0;
00454 }
00455
00456 static struct ast_custom_function csv_quote_function = {
00457 .name = "CSV_QUOTE",
00458 .synopsis = "Quotes a given string for use in a CSV file, escaping embedded quotes as necessary",
00459 .syntax = "CSV_QUOTE(<string>)",
00460 .read = csv_quote,
00461 };
00462
00463 static int len(struct ast_channel *chan, char *cmd, char *data, char *buf,
00464 size_t len)
00465 {
00466 int length = 0;
00467
00468 if (data)
00469 length = strlen(data);
00470
00471 snprintf(buf, len, "%d", length);
00472
00473 return 0;
00474 }
00475
00476 static struct ast_custom_function len_function = {
00477 .name = "LEN",
00478 .synopsis = "Returns the length of the argument given",
00479 .syntax = "LEN(<string>)",
00480 .read = len,
00481 };
00482
00483 static int acf_strftime(struct ast_channel *chan, char *cmd, char *parse,
00484 char *buf, size_t len)
00485 {
00486 AST_DECLARE_APP_ARGS(args,
00487 AST_APP_ARG(epoch);
00488 AST_APP_ARG(timezone);
00489 AST_APP_ARG(format);
00490 );
00491 time_t epochi;
00492 struct tm tm;
00493
00494 buf[0] = '\0';
00495
00496 AST_STANDARD_APP_ARGS(args, parse);
00497
00498 ast_get_time_t(args.epoch, &epochi, time(NULL), NULL);
00499 ast_localtime(&epochi, &tm, args.timezone);
00500
00501 if (!args.format)
00502 args.format = "%c";
00503
00504 if (!strftime(buf, len, args.format, &tm))
00505 ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");
00506
00507 buf[len - 1] = '\0';
00508
00509 return 0;
00510 }
00511
00512 static struct ast_custom_function strftime_function = {
00513 .name = "STRFTIME",
00514 .synopsis = "Returns the current date/time in a specified format.",
00515 .syntax = "STRFTIME([<epoch>][|[timezone][|format]])",
00516 .read = acf_strftime,
00517 };
00518
00519 static int acf_strptime(struct ast_channel *chan, char *cmd, char *data,
00520 char *buf, size_t len)
00521 {
00522 AST_DECLARE_APP_ARGS(args,
00523 AST_APP_ARG(timestring);
00524 AST_APP_ARG(timezone);
00525 AST_APP_ARG(format);
00526 );
00527 struct tm time;
00528
00529 memset(&time, 0, sizeof(struct tm));
00530
00531 buf[0] = '\0';
00532
00533 if (!data) {
00534 ast_log(LOG_ERROR,
00535 "Asterisk function STRPTIME() requires an argument.\n");
00536 return -1;
00537 }
00538
00539 AST_STANDARD_APP_ARGS(args, data);
00540
00541 if (ast_strlen_zero(args.format)) {
00542 ast_log(LOG_ERROR,
00543 "No format supplied to STRPTIME(<timestring>|<timezone>|<format>)");
00544 return -1;
00545 }
00546
00547 if (!strptime(args.timestring, args.format, &time)) {
00548 ast_log(LOG_WARNING, "C function strptime() output nothing?!!\n");
00549 } else {
00550
00551 time.tm_isdst = -1;
00552 snprintf(buf, len, "%d", (int) ast_mktime(&time, args.timezone));
00553 }
00554
00555 return 0;
00556 }
00557
00558 static struct ast_custom_function strptime_function = {
00559 .name = "STRPTIME",
00560 .synopsis =
00561 "Returns the epoch of the arbitrary date/time string structured as described in the format.",
00562 .syntax = "STRPTIME(<datetime>|<timezone>|<format>)",
00563 .desc =
00564 "This is useful for converting a date into an EPOCH time, possibly to pass to\n"
00565 "an application like SayUnixTime or to calculate the difference between two\n"
00566 "date strings.\n"
00567 "\n"
00568 "Example:\n"
00569 " ${STRPTIME(2006-03-01 07:30:35|America/Chicago|%Y-%m-%d %H:%M:%S)} returns 1141219835\n",
00570 .read = acf_strptime,
00571 };
00572
00573 static int function_eval(struct ast_channel *chan, char *cmd, char *data,
00574 char *buf, size_t len)
00575 {
00576 memset(buf, 0, len);
00577
00578 if (ast_strlen_zero(data)) {
00579 ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
00580 return -1;
00581 }
00582
00583 pbx_substitute_variables_helper(chan, data, buf, len - 1);
00584
00585 return 0;
00586 }
00587
00588 static struct ast_custom_function eval_function = {
00589 .name = "EVAL",
00590 .synopsis = "Evaluate stored variables.",
00591 .syntax = "EVAL(<variable>)",
00592 .desc = "Using EVAL basically causes a string to be evaluated twice.\n"
00593 "When a variable or expression is in the dialplan, it will be\n"
00594 "evaluated at runtime. However, if the result of the evaluation\n"
00595 "is in fact a variable or expression, using EVAL will have it\n"
00596 "evaluated a second time. For example, if the variable ${MYVAR}\n"
00597 "contains \"${OTHERVAR}\", then the result of putting ${EVAL(${MYVAR})}\n"
00598 "in the dialplan will be the contents of the variable, OTHERVAR.\n"
00599 "Normally, by just putting ${MYVAR} in the dialplan, you would be\n"
00600 "left with \"${OTHERVAR}\".\n",
00601 .read = function_eval,
00602 };
00603
00604 static int keypadhash(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00605 {
00606 char *bufptr, *dataptr;
00607
00608 for (bufptr = buf, dataptr = data; bufptr < buf + len - 1; dataptr++) {
00609 if (*dataptr == '\0') {
00610 *bufptr++ = '\0';
00611 break;
00612 } else if (*dataptr == '1') {
00613 *bufptr++ = '1';
00614 } else if (strchr("AaBbCc2", *dataptr)) {
00615 *bufptr++ = '2';
00616 } else if (strchr("DdEeFf3", *dataptr)) {
00617 *bufptr++ = '3';
00618 } else if (strchr("GgHhIi4", *dataptr)) {
00619 *bufptr++ = '4';
00620 } else if (strchr("JjKkLl5", *dataptr)) {
00621 *bufptr++ = '5';
00622 } else if (strchr("MmNnOo6", *dataptr)) {
00623 *bufptr++ = '6';
00624 } else if (strchr("PpQqRrSs7", *dataptr)) {
00625 *bufptr++ = '7';
00626 } else if (strchr("TtUuVv8", *dataptr)) {
00627 *bufptr++ = '8';
00628 } else if (strchr("WwXxYyZz9", *dataptr)) {
00629 *bufptr++ = '9';
00630 } else if (*dataptr == '0') {
00631 *bufptr++ = '0';
00632 }
00633 }
00634 buf[len - 1] = '\0';
00635
00636 return 0;
00637 }
00638
00639 static struct ast_custom_function keypadhash_function = {
00640 .name = "KEYPADHASH",
00641 .synopsis = "Hash the letters in the string into the equivalent keypad numbers.",
00642 .syntax = "KEYPADHASH(<string>)",
00643 .read = keypadhash,
00644 .desc = "Example: ${KEYPADHASH(Les)} returns \"537\"\n",
00645 };
00646
00647 static int unload_module(void)
00648 {
00649 int res = 0;
00650
00651 res |= ast_custom_function_unregister(&fieldqty_function);
00652 res |= ast_custom_function_unregister(&filter_function);
00653 res |= ast_custom_function_unregister(®ex_function);
00654 res |= ast_custom_function_unregister(&array_function);
00655 res |= ast_custom_function_unregister("e_function);
00656 res |= ast_custom_function_unregister(&csv_quote_function);
00657 res |= ast_custom_function_unregister(&len_function);
00658 res |= ast_custom_function_unregister(&strftime_function);
00659 res |= ast_custom_function_unregister(&strptime_function);
00660 res |= ast_custom_function_unregister(&eval_function);
00661 res |= ast_custom_function_unregister(&keypadhash_function);
00662 res |= ast_custom_function_unregister(&sprintf_function);
00663
00664 return res;
00665 }
00666
00667 static int load_module(void)
00668 {
00669 int res = 0;
00670
00671 res |= ast_custom_function_register(&fieldqty_function);
00672 res |= ast_custom_function_register(&filter_function);
00673 res |= ast_custom_function_register(®ex_function);
00674 res |= ast_custom_function_register(&array_function);
00675 res |= ast_custom_function_register("e_function);
00676 res |= ast_custom_function_register(&csv_quote_function);
00677 res |= ast_custom_function_register(&len_function);
00678 res |= ast_custom_function_register(&strftime_function);
00679 res |= ast_custom_function_register(&strptime_function);
00680 res |= ast_custom_function_register(&eval_function);
00681 res |= ast_custom_function_register(&keypadhash_function);
00682 res |= ast_custom_function_register(&sprintf_function);
00683
00684 return res;
00685 }
00686
00687 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "String handling dialplan functions");