447 sprintf(varsubst,
"${%s}",
args.varname);
453 while (
strsep(&varval, delim)) {
463 snprintf(buf, len,
"%d", fieldcount);
490 char *varsubst, *field;
492 int fieldindex = 0, res = 0;
508 ast_log(
LOG_ERROR,
"Usage: FIELDNUM(<listname>,<delimiter>,<fieldvalue>)\n");
512 sprintf(varsubst,
"${%s}",
args.varname);
523 while ((field =
strsep(&varval, delim)) != NULL) {
526 if (!strcasecmp(field,
args.field)) {
542 snprintf(buf, len,
"%d", fieldindex);
574 const char *begin, *cur, *next;
575 int dlen, flen,
first = 1;
576 struct ast_str *result, **result_ptr = &result;
577 char *delim, *varsubst;
591 ast_log(
LOG_ERROR,
"Usage: LISTFILTER(<listname>,<delimiter>,<fieldvalue>)\n");
596 sprintf(varsubst,
"${%s}",
args.listname);
624 dlen = strlen(
args.delimiter);
628 if ((dlen = strlen(delim)) == 0) {
633 flen = strlen(
args.fieldvalue);
642 next = strstr(begin, delim);
648 next = strstr(cur + dlen, delim);
650 cur = strchr(begin + dlen,
'\0');
653 if (flen == cur - begin && !strncmp(begin,
args.fieldvalue, flen)) {
655 begin += flen + dlen;
666 }
while (*cur !=
'\0');
680 return listfilter(chan, cmd, parse, buf, NULL, len);
685 return listfilter(chan, cmd, parse, NULL, buf, len);
689 .
name =
"LISTFILTER",
703 char allowed[256] =
"";
704 size_t allowedlen = 0;
705 int32_t bitfield[8] = { 0, };
715 ast_log(
LOG_WARNING,
"FILTER allowed characters includes the quote (\") character. This may not be what you want.\n");
719 for (; *(
args.allowed);) {
725 args.allowed += consumed;
727 if (*(
args.allowed) ==
'-') {
730 args.allowed += consumed + 1;
733 ast_log(
LOG_WARNING,
"Range wrapping in FILTER(%s,%s). This may not be what you want.\n", parse,
args.string);
740 for (ac = (
unsigned char) c1; ac != (
unsigned char) c2; ac++) {
741 bitfield[ac / 32] |= 1 << (ac % 32);
743 bitfield[ac / 32] |= 1 << (ac % 32);
747 ac = (
unsigned char) c1;
748 ast_debug(4,
"c1=%d, consumed=%d, args.allowed=%s\n", c1, (
int) consumed,
args.allowed - consumed);
749 bitfield[ac / 32] |= 1 << (ac % 32);
753 for (ac = 1; ac != 0; ac++) {
754 if (bitfield[ac / 32] & (1 << (ac % 32))) {
755 allowed[allowedlen++] = ac;
761 for (; *(
args.string) && (buf + len - 1 > outbuf); (
args.string)++) {
762 if (strchr(allowed, *(
args.string)))
763 *outbuf++ = *(
args.string);
782 char *strptr, *varsubst;
795 ast_log(
LOG_ERROR,
"Usage: %s(<varname>,<search-chars>[,<replace-char>])\n", cmd);
804 ast_log(
LOG_ERROR,
"The characters to search for and the variable name must not be empty.\n");
809 sprintf(varsubst,
"${%s}",
args.varname);
818 ast_debug(3,
"Characters to find: (%s)\n", find);
819 ast_debug(3,
"Character to replace with: (%s)\n", replace);
824 if (strchr(find, *strptr)) {
826 memmove(strptr, strptr + 1, strlen(strptr + 1) + 1);
859 if (
args.argc != 3) {
860 ast_log(
LOG_ERROR,
"Unexpected arguments: should have been in the form '\"<regex>\" <string>'\n");
863 if ((*
args.str ==
' ') || (*
args.str ==
'\t'))
868 if ((errcode = regcomp(®exbuf,
args.reg, REG_EXTENDED | REG_NOSUB))) {
869 regerror(errcode, ®exbuf, buf, len);
874 strcpy(buf, regexec(®exbuf,
args.str, 0, NULL, 0) ?
"0" :
"1");
886 #define HASH_PREFIX "~HASH~%s~"
887 #define HASH_FORMAT HASH_PREFIX "%s~"
895 int len = strlen(prefix);
908 snprintf(prefix,
sizeof(prefix),
HASH_PREFIX, data ? (
char *)data :
"null");
922 char *origvar =
"", *value2, varname[256];
930 if (!strcmp(cmd,
"HASH")) {
954 for (i = 0; i < arg1.argc; i++) {
955 ast_debug(1,
"array set value (%s=%s)\n", arg1.var[i],
956 S_OR(arg2.val[i],
""));
959 if (origvar[0] ==
'_') {
960 if (origvar[1] ==
'_') {
961 snprintf(varname,
sizeof(varname),
"__" HASH_FORMAT, origvar + 2, arg1.var[i]);
963 snprintf(varname,
sizeof(varname),
"_" HASH_FORMAT, origvar + 1, arg1.var[i]);
966 snprintf(varname,
sizeof(varname),
HASH_FORMAT, origvar, arg1.var[i]);
977 snprintf(varname,
sizeof(varname),
HASH_FORMAT, origvar, arg1.var[i]);
1006 buf[strlen(buf) - 1] =
',';
1010 buf[strlen(buf) - 1] =
'\0';
1050 if (!strchr(var,
',')) {
1052 return array(chan,
"HASH", var, value);
1056 if (arg.hashname[0] ==
'_') {
1057 if (arg.hashname[1] ==
'_') {
1058 snprintf(varname,
sizeof(varname),
"__" HASH_FORMAT, arg.hashname + 2, arg.hashkey);
1060 snprintf(varname,
sizeof(varname),
"_" HASH_FORMAT, arg.hashname + 1, arg.hashkey);
1063 snprintf(varname,
sizeof(varname),
HASH_FORMAT, arg.hashname, arg.hashkey);
1073 const char *varvalue;
1080 if (arg.argc == 2) {
1081 snprintf(varname,
sizeof(varname),
HASH_FORMAT, arg.hashname, arg.hashkey);
1087 }
else if (arg.argc == 1) {
1088 char colnames[4096];
1095 ast_log(
LOG_WARNING,
"No channel and only 1 parameter was provided to %s function.\n", cmd);
1100 hashkeys_read(chan,
"HASHKEYS", arg.hashname, colnames,
sizeof(colnames));
1107 for (i = 0; i < arg2.argc; i++) {
1108 snprintf(varname,
sizeof(varname),
HASH_FORMAT, arg.hashname, arg2.col[i]);
1110 strncat(buf, varvalue, len - strlen(buf) - 1);
1111 strncat(buf,
",", len - strlen(buf) - 1);
1115 buf[strlen(buf) - 1] =
'\0';
1140 char *bufptr = buf, *dataptr = data;
1154 for (; bufptr < buf + len - 3; dataptr++) {
1155 if (*dataptr ==
'\\') {
1158 }
else if (*dataptr ==
'"') {
1161 }
else if (*dataptr ==
'\0') {
1164 *bufptr++ = *dataptr;
1179 char *bufptr = buf, *dataptr = data;
1192 for (; bufptr < buf + len - 3; dataptr++){
1193 if (*dataptr ==
'"') {
1196 }
else if (*dataptr ==
'\0') {
1199 *bufptr++ = *dataptr;
1208 .
name =
"CSV_QUOTE",
1212 static int len(
struct ast_channel *chan,
const char *cmd,
char *data,
char *buf,
size_t buflen)
1217 length = strlen(data);
1219 snprintf(buf, buflen,
"%d", length);
1231 char *buf,
size_t buflen)
1238 struct timeval when;
1254 buf[buflen - 1] =
'\0';
1265 char *buf,
size_t buflen)
1278 "Asterisk function STRPTIME() requires an argument.\n");
1286 "No format supplied to STRPTIME(<timestring>,<timezone>,<format>)");
1293 struct timeval when;
1295 snprintf(buf, buflen,
"%d", (
int) when.tv_sec);
1307 char *buf,
size_t buflen)
1320 struct ast_str **buf, ssize_t buflen)
1340 char *bufptr, *dataptr;
1342 for (bufptr = buf, dataptr = data; bufptr < buf + buflen - 1; dataptr++) {
1343 if (*dataptr ==
'\0') {
1346 }
else if (*dataptr ==
'1') {
1348 }
else if (strchr(
"AaBbCc2", *dataptr)) {
1350 }
else if (strchr(
"DdEeFf3", *dataptr)) {
1352 }
else if (strchr(
"GgHhIi4", *dataptr)) {
1354 }
else if (strchr(
"JjKkLl5", *dataptr)) {
1356 }
else if (strchr(
"MmNnOo6", *dataptr)) {
1358 }
else if (strchr(
"PpQqRrSs7", *dataptr)) {
1360 }
else if (strchr(
"TtUuVv8", *dataptr)) {
1362 }
else if (strchr(
"WwXxYyZz9", *dataptr)) {
1364 }
else if (*dataptr ==
'0') {
1368 buf[buflen - 1] =
'\0';
1374 .
name =
"KEYPADHASH",
1380 char *bufptr = buf, *dataptr = data;
1382 while ((bufptr < buf + buflen - 1) && (*bufptr++ = toupper(*dataptr++)));
1389 char *bufptr, *dataptr = data;
1409 char *bufptr = buf, *dataptr = data;
1411 while ((bufptr < buf + buflen - 1) && (*bufptr++ = tolower(*dataptr++)));
1418 char *bufptr, *dataptr = data;
1438 #define beginning (cmd[0] == 'S')
1439 char *after, delimiter[2] =
",", *varsubst;
1442 char *(*search_func)(
const char *s,
int c) = (
beginning ? strchr : strrchr);
1460 sprintf(varsubst,
"${%s}",
args.var);
1472 if (!(after = search_func(
ast_str_buffer(before), delimiter[0]))) {
1498 #define beginning (cmd[0] == 'U')
1499 char delimiter[2] =
",", *varsubst;
1501 struct ast_str *buf, *previous_value;
1506 const char *stripped_var;
1530 stripped_var =
args.var +
MIN(strspn(
args.var,
"_"), 2);
1531 varsubst =
ast_alloca(strlen(stripped_var) + 4);
1532 sprintf(varsubst,
"${%s}", stripped_var);
1571 #ifdef TEST_FRAMEWORK
1577 char expression[256];
1582 const char *expected;
1584 {
"abc,def,ghi,jkl",
"\\,",
"ghi",
"3"},
1585 {
"abc def ghi jkl",
" ",
"abc",
"1"},
1586 {
"abc/def/ghi/jkl",
"\\\\x2f",
"def",
"2"},
1587 {
"abc$def$ghi$jkl",
"",
"ghi",
"0"},
1588 {
"abc,def,ghi,jkl",
"-",
"",
"0"},
1589 {
"abc-def-ghi-jkl",
"-",
"mno",
"0"}
1594 info->name =
"func_FIELDNUM_test";
1595 info->category =
"/funcs/func_strings/";
1596 info->summary =
"Test FIELDNUM function";
1597 info->description =
"Verify FIELDNUM behavior";
1614 for (i = 0; i <
ARRAY_LEN(test_args); i++) {
1624 snprintf(expression,
sizeof(expression),
"${FIELDNUM(%s,%s,%s)}", var->
name, test_args[i].delim, test_args[i].field);
1649 char expression[256];
1651 const char *test_string;
1652 const char *find_chars;
1653 const char *replace_char;
1654 const char *expected;
1656 {
"abc,def",
"\\,",
"-",
"abc-def"},
1657 {
"abc,abc",
"bc",
"a",
"aaa,aaa"},
1658 {
"abc,def",
"x",
"?",
"abc,def"},
1659 {
"abc,def",
"\\,",
"",
"abcdef"}
1664 info->name =
"func_REPLACE_test";
1665 info->category =
"/funcs/func_strings/";
1666 info->summary =
"Test REPLACE function";
1667 info->description =
"Verify REPLACE behavior";
1684 for (i = 0; i <
ARRAY_LEN(test_args); i++) {
1694 snprintf(expression,
sizeof(expression),
"${REPLACE(%s,%s,%s)}", var->
name, test_args[i].find_chars, test_args[i].replace_char);
1717 const char *test_strings[][2] = {
1720 {
"\\x41-R",
"DAHDI"},
1721 {
"0-9A-Ca-c",
"0042133333A12212"},
1722 {
"0-9a-cA-C_+\\-",
"0042133333A12212"},
1728 info->name =
"func_FILTER_test";
1729 info->category =
"/funcs/func_strings/";
1730 info->summary =
"Test FILTER function";
1731 info->description =
"Verify FILTER behavior";
1737 for (i = 0; test_strings[i][0]; i++) {
1738 char tmp[256], tmp2[256] =
"";
1739 snprintf(tmp,
sizeof(tmp),
"${FILTER(%s,0042133333&DAHDI/g1/2212)}", test_strings[i][0]);
1741 if (strcmp(test_strings[i][1], tmp2)) {
1742 ast_test_status_update(test,
"Format string '%s' substituted to '%s'. Expected '%s'.\n", test_strings[i][0], tmp2, test_strings[i][1]);
void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count)
#define AST_THREADSTORAGE(name)
Define a thread storage variable.
static int function_fieldqty(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static struct ast_custom_function hashkeys_function
static int hash_write(struct ast_channel *chan, const char *cmd, char *var, const char *value)
#define ast_channel_lock(chan)
Main Channel structure associated with a channel.
static struct ast_custom_function len_function
#define AST_MODULE_INFO_STANDARD(keystr, desc)
static int load_module(void)
Asterisk main include file. File version handling, generic pbx functions.
static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static struct ast_custom_function shift_function
static int listfilter_read(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
char * strsep(char **str, const char *delims)
static int function_fieldqty_helper(struct ast_channel *chan, const char *cmd, char *parse, char *buf, struct ast_str **sbuf, ssize_t len)
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
static int function_fieldnum(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static struct ast_custom_function strftime_function
static int acf_strftime(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t buflen)
size_t ast_str_size(const struct ast_str *buf)
Returns the current maximum length (without reallocation) of the current buffer.
struct ast_var_t * ast_var_assign(const char *name, const char *value)
static struct ast_custom_function passthru_function
struct ast_channel * ast_channel_release(struct ast_channel *chan)
Unlink and release reference to a channel.
const char * ast_var_name(const struct ast_var_t *var)
char * ast_get_encoded_str(const char *stream, char *result, size_t result_len)
Decode a stream of encoded control or extended ASCII characters.
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
static void clearvar_prefix(struct ast_channel *chan, const char *prefix)
struct ast_tm * ast_localtime(const struct timeval *timep, struct ast_tm *p_tm, const char *zone)
Timezone-independent version of localtime_r(3).
#define AST_DECLARE_APP_ARGS(name, arglist)
Declare a structure to hold an application's arguments.
void ast_str_substitute_variables(struct ast_str **buf, ssize_t maxlen, struct ast_channel *chan, const char *templ)
#define AST_TEST_REGISTER(cb)
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
struct ast_str * ast_str_create(size_t init_len)
Create a malloc'ed dynamic length string.
static struct ast_custom_function eval_function
static struct ast_custom_function fieldnum_function
#define ast_str_alloca(init_len)
static struct ast_custom_function push_function
static struct ast_custom_function unshift_function
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
int ast_get_timeval(const char *src, struct timeval *tv, struct timeval _default, int *consumed)
get values from config variables.
int ast_unregister_application(const char *app)
Unregister an application.
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
static int hashkeys_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int string_toupper2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
void ast_var_delete(struct ast_var_t *var)
static int string_tolower2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
int ast_custom_function_unregister(struct ast_custom_function *acf)
Unregister a custom function.
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
static int hashkeys_read2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static struct ast_custom_function replace_function
Custom localtime functions for multiple timezones.
static struct ast_custom_function quote_function
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
#define ast_opt_dont_warn
#define ast_debug(level,...)
Log a DEBUG message.
static int function_eval(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static struct ast_threadstorage tmp_buf
static int exec_clearhash(struct ast_channel *chan, const char *data)
General Asterisk PBX channel definitions.
static int quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
int ast_str_make_space(struct ast_str **buf, size_t new_len)
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
#define ast_test_status_update(a, b, c...)
static force_inline int attribute_pure ast_strlen_zero(const char *s)
char * ast_str_append_substr(struct ast_str **buf, ssize_t maxlen, const char *src, size_t maxsrc)
Append a non-NULL terminated substring to the end of a dynamic string.
Data structure associated with a custom dialplan function.
static struct ast_custom_function listfilter_function
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
static int keypadhash(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static char * app_clearhash
static struct ast_custom_function toupper_function
static struct ast_custom_function csv_quote_function
Core PBX routines and definitions.
char * ast_strptime(const char *s, const char *format, struct ast_tm *tm)
Special version of strptime(3) which places the answer in the common structure ast_tm. Also, unlike strptime(3), ast_strptime() initializes its memory prior to use.
int ast_autoservice_stop(struct ast_channel *chan)
Stop servicing a channel for us...
static struct ast_threadstorage result_buf
static int string_toupper(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int listfilter(struct ast_channel *chan, const char *cmd, char *parse, char *buf, struct ast_str **bufstr, ssize_t len)
#define ast_strdupa(s)
duplicate a string in memory from the stack
static struct ast_custom_function filter_function
static int string_tolower(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static struct ast_custom_function regex_function
int ast_get_encoded_char(const char *stream, char *result, size_t *consumed)
Decode an encoded control or extended ASCII character.
The descriptor of a dynamic string XXX storage will be optimized later if needed We use the ts field ...
static int array(struct ast_channel *chan, const char *cmd, char *var, const char *value)
#define AST_TEST_UNREGISTER(cb)
static int listfilter_read2(struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
static struct ast_custom_function array_function
static int csv_quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
struct sla_ringing_trunk * first
void ast_log(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message This is the standard logger function. Probably the only way you will i...
static struct ast_custom_function fieldqty_function
static int unshift_push(struct ast_channel *chan, const char *cmd, char *data, const char *new_value)
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
#define ast_channel_unlock(chan)
static void parse(struct mgcp_request *req)
static struct ast_custom_function keypadhash_function
struct ast_var_t::@158 entries
static int function_fieldnum_str(struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
static struct ast_custom_function hash_function
static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static int shift_pop(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
int ast_strftime(char *buf, size_t len, const char *format, const struct ast_tm *tm)
Special version of strftime(3) that handles fractions of a second. Takes the same arguments as strfti...
static struct ast_custom_function pop_function
static int function_fieldnum_helper(struct ast_channel *chan, const char *cmd, char *parse, char *buf, struct ast_str **sbuf, ssize_t len)
static int replace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name...
void ast_str_reset(struct ast_str *buf)
Reset the content of a dynamic string. Useful before a series of ast_str_append.
size_t ast_str_strlen(const struct ast_str *buf)
Returns the current length of the string stored within buf.
struct timeval ast_mktime(struct ast_tm *const tmp, const char *zone)
Timezone-independent version of mktime(3).
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
void ast_str_update(struct ast_str *buf)
Update the length of the buffer, after using ast_str merely as a buffer.
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one...
static int passthru(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
Application convenience functions, designed to give consistent look and feel to Asterisk apps...
#define AST_TEST_DEFINE(hdr)
#define AST_STANDARD_RAW_ARGS(args, parse)
static struct ast_custom_function tolower_function
static struct ast_custom_function strptime_function
#define AST_APP_ARG(name)
Define an application argument.
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
static int function_fieldqty_str(struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
struct ast_str * ast_str_thread_get(struct ast_threadstorage *ts, size_t init_len)
Retrieve a thread locally stored dynamic string.
#define AST_STANDARD_APP_ARGS(args, parse)
Performs the 'standard' argument separation process for an application.
static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
#define AST_NONSTANDARD_APP_ARGS(args, parse, sep)
Performs the 'nonstandard' argument separation process for an application.
struct ast_channel * ast_dummy_channel_alloc(void)
Create a fake channel structure.
#define ASTERISK_GPL_KEY
The text the key() function should return.
Asterisk module definitions.
static snd_pcm_format_t format
#define ast_custom_function_register(acf)
Register a custom function.
static int function_eval2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
#define ast_register_application_xml(app, execute)
Register an application using XML documentation.
#define ASTERISK_FILE_VERSION(file, version)
Register/unregister a source code file with the core.
static int unload_module(void)
static char prefix[MAX_PREFIX]
static int hash_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)