Sat Aug 6 00:39:29 2011

Asterisk developer's documentation


func_strings.c

Go to the documentation of this file.
00001 /*
00002  * Asterisk -- An open source telephony toolkit.
00003  *
00004  * Copyright (C) 2005-2006, Digium, Inc.
00005  * Portions Copyright (C) 2005, Tilghman Lesher.  All rights reserved.
00006  * Portions Copyright (C) 2005, Anthony Minessale II
00007  *
00008  * See http://www.asterisk.org for more information about
00009  * the Asterisk project. Please do not directly contact
00010  * any of the maintainers of this project for assistance;
00011  * the project provides a web site, mailing lists and IRC
00012  * channels for your use.
00013  *
00014  * This program is free software, distributed under the terms of
00015  * the GNU General Public License Version 2. See the LICENSE file
00016  * at the top of the source tree.
00017  */
00018 
00019 /*! \file
00020  *
00021  * \brief String manipulation dialplan functions
00022  *
00023  * \author Tilghman Lesher
00024  * \author Anothony Minessale II 
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(&regexbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
00141       regerror(errcode, &regexbuf, 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(&regexbuf, args.str, 0, NULL, 0) ? "0" : "1");
00147 
00148    regfree(&regexbuf);
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    /* The functions this will generally be used with are SORT and ODBC_*, which
00182     * both return comma-delimited lists.  However, if somebody uses literal lists,
00183     * their commas will be translated to vertical bars by the load, and I don't
00184     * want them to be surprised by the result.  Hence, we prefer commas as the
00185     * delimiter, but we'll fall back to vertical bars if commas aren't found.
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          /* We could unset the variable, by passing a NULL, but due to
00207           * pushvar semantics, that could create some undesired behavior. */
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    /* Scan the format, converting each argument into the requisite format type. */
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          /* Next character must be a period to go into a precision */
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             /* Integer */
00285 
00286             /* Isolate this format alone */
00287             ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00288             formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00289 
00290             /* Convert the argument into the required type */
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             /* Format the argument */
00302             snprintf(bufptr, buf + len - bufptr, formatbuf, tmpi);
00303 
00304             /* Update the position of the next parameter to print */
00305             bufptr = strchr(buf, '\0');
00306          } else if (strchr("eEfFgGaA", arg.format[i])) {
00307             /* Double */
00308 
00309             /* Isolate this format alone */
00310             ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00311             formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00312 
00313             /* Convert the argument into the required type */
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             /* Format the argument */
00325             snprintf(bufptr, buf + len - bufptr, formatbuf, tmpd);
00326 
00327             /* Update the position of the next parameter to print */
00328             bufptr = strchr(buf, '\0');
00329          } else if (arg.format[i] == 's') {
00330             /* String */
00331 
00332             /* Isolate this format alone */
00333             ast_copy_string(formatbuf, formatstart, sizeof(formatbuf));
00334             formatbuf[&arg.format[i] - formatstart + 1] = '\0';
00335 
00336             /* Format the argument */
00337             snprintf(bufptr, buf + len - bufptr, formatbuf, arg.var[argcount++]);
00338 
00339             /* Update the position of the next parameter to print */
00340             bufptr = strchr(buf, '\0');
00341          } else if (arg.format[i] == '%') {
00342             /* Literal data to copy */
00343             *bufptr++ = arg.format[i];
00344          } else {
00345             /* Not supported */
00346 
00347             /* Isolate this format alone */
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             /* Literal data to copy */
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){ /* at least two for quotes and one for binary zero */
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){ /* at least two for quotes and one for binary zero */
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       /* Since strptime(3) does not check DST, force ast_mktime() to calculate it. */
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(&regex_function);
00654    res |= ast_custom_function_unregister(&array_function);
00655    res |= ast_custom_function_unregister(&quote_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(&regex_function);
00674    res |= ast_custom_function_register(&array_function);
00675    res |= ast_custom_function_register(&quote_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");

Generated on Sat Aug 6 00:39:29 2011 for Asterisk - the Open Source PBX by  doxygen 1.4.7