488 sprintf(varsubst,
"${%s}",
args.varname);
494 while (
strsep(&varval, delim)) {
504 snprintf(
buf,
len,
"%d", fieldcount);
531 char *varsubst, *field;
533 int fieldindex = 0, res = 0;
549 ast_log(
LOG_ERROR,
"Usage: FIELDNUM(<listname>,<delimiter>,<fieldvalue>)\n");
553 sprintf(varsubst,
"${%s}",
args.varname);
564 while ((field =
strsep(&varval, delim)) !=
NULL) {
567 if (!strcasecmp(field,
args.field)) {
583 snprintf(
buf,
len,
"%d", fieldindex);
615 const char *begin, *cur, *next;
616 int dlen, flen,
first = 1;
618 char *delim, *varsubst;
632 ast_log(
LOG_ERROR,
"Usage: LISTFILTER(<listname>,<delimiter>,<fieldvalue>)\n");
637 sprintf(varsubst,
"${%s}",
args.listname);
664 dlen = strlen(
args.delimiter);
668 if ((dlen = strlen(delim)) == 0) {
673 flen = strlen(
args.fieldvalue);
682 next = strstr(begin, delim);
688 next = strstr(cur + dlen, delim);
690 cur = strchr(begin + dlen,
'\0');
693 if (flen == cur - begin && !strncmp(begin,
args.fieldvalue, flen)) {
695 begin += flen + dlen;
706 }
while (*cur !=
'\0');
729 .
name =
"LISTFILTER",
743 char allowed[256] =
"";
744 size_t allowedlen = 0;
755 ast_log(
LOG_WARNING,
"FILTER allowed characters includes the quote (\") character. This may not be what you want.\n");
759 for (; *(
args.allowed);) {
765 args.allowed += consumed;
767 if (*(
args.allowed) ==
'-') {
770 args.allowed += consumed + 1;
780 for (ac = (
unsigned char) c1; ac != (
unsigned char) c2; ac++) {
781 bitfield[ac / 32] |= 1 << (ac % 32);
783 bitfield[ac / 32] |= 1 << (ac % 32);
787 ac = (
unsigned char) c1;
788 ast_debug(4,
"c1=%d, consumed=%d, args.allowed=%s\n", c1, (
int) consumed,
args.allowed - consumed);
789 bitfield[ac / 32] |= 1 << (ac % 32);
793 for (ac = 1; ac != 0; ac++) {
794 if (bitfield[ac / 32] & (1 << (ac % 32))) {
795 allowed[allowedlen++] = ac;
801 for (; *(
args.string) && (
buf +
len - 1 > outbuf); (
args.string)++) {
802 if (strchr(allowed, *(
args.string)))
803 *outbuf++ = *(
args.string);
822 char *strptr, *varsubst;
835 ast_log(
LOG_ERROR,
"Usage: %s(<varname>,<search-chars>[,<replace-char>])\n", cmd);
844 ast_log(
LOG_ERROR,
"The characters to search for and the variable name must not be empty.\n");
849 sprintf(varsubst,
"${%s}",
args.varname);
858 ast_debug(3,
"Characters to find: (%s)\n", find);
864 if (strchr(find, *strptr)) {
866 memmove(strptr, strptr + 1, strlen(strptr + 1) + 1);
890 unsigned max_matches;
916 "Usage: %s(<varname>,<find-string>[,<replace-string>,[<max-replacements>]])\n",
931 find_size = strlen(
args.find_string);
935 sprintf(varsubstr,
"${%s}",
args.varname);
939 if (!
args.max_replacements
940 || (max_matches = atoi(
args.max_replacements)) <= 0) {
947 for (count = 0; count < max_matches; ++count) {
948 end = strstr(start,
args.find_string);
957 if (
args.replace_string) {
961 start =
end + find_size;
969 .
name =
"STRREPLACE",
976 char *varsubstr, *origstr;
1000 sprintf(varsubstr,
"${%s}",
args.varname);
1003 origsize = strlen(origstr);
1004 for (
c = 0;
c < origsize;
c++) {
1007 if (
c < (origsize - 1)) {
1016 .
name =
"STRBETWEEN",
1035 if (
args.argc != 3) {
1036 ast_log(
LOG_ERROR,
"Unexpected arguments: should have been in the form '\"<regex>\" <string>'\n");
1039 if ((*
args.str ==
' ') || (*
args.str ==
'\t'))
1044 if ((errcode = regcomp(®exbuf,
args.reg, REG_EXTENDED | REG_NOSUB))) {
1045 regerror(errcode, ®exbuf,
buf,
len);
1050 strcpy(
buf, regexec(®exbuf,
args.str, 0,
NULL, 0) ?
"0" :
"1");
1062 #define HASH_PREFIX "~HASH~%s~"
1063 #define HASH_FORMAT HASH_PREFIX "%s~"
1098 char *origvar =
"", *value2, varname[256];
1106 if (!strcmp(cmd,
"HASH")) {
1130 for (i = 0; i < arg1.argc; i++) {
1131 ast_debug(1,
"array set value (%s=%s)\n", arg1.var[i],
1132 S_OR(arg2.val[i],
""));
1133 if (i < arg2.argc) {
1135 if (origvar[0] ==
'_') {
1136 if (origvar[1] ==
'_') {
1137 snprintf(varname,
sizeof(varname),
"__" HASH_FORMAT, origvar + 2, arg1.var[i]);
1139 snprintf(varname,
sizeof(varname),
"_" HASH_FORMAT, origvar + 1, arg1.var[i]);
1142 snprintf(varname,
sizeof(varname),
HASH_FORMAT, origvar, arg1.var[i]);
1153 snprintf(varname,
sizeof(varname),
HASH_FORMAT, origvar, arg1.var[i]);
1176 var_len = strlen(var_name);
1182 return var_len > (prefix_len + 1) && var_name[var_len - 1] ==
'~' &&
1183 strncmp(prefix_name, var_name, prefix_len) == 0 ? var_name + prefix_len :
NULL;
1204 strncat(
buf, key,
len - strlen(
buf) - 1);
1206 buf[strlen(
buf) - 1] =
',';
1210 buf_len = strlen(
buf);
1212 buf[buf_len - 1] =
'\0';
1254 if (!strchr(
var,
',')) {
1260 if (arg.hashname[0] ==
'_') {
1261 if (arg.hashname[1] ==
'_') {
1262 snprintf(varname,
sizeof(varname),
"__" HASH_FORMAT, arg.hashname + 2, arg.hashkey);
1264 snprintf(varname,
sizeof(varname),
"_" HASH_FORMAT, arg.hashname + 1, arg.hashkey);
1267 snprintf(varname,
sizeof(varname),
HASH_FORMAT, arg.hashname, arg.hashkey);
1277 const char *varvalue;
1284 if (arg.argc == 2) {
1285 snprintf(varname,
sizeof(varname),
HASH_FORMAT, arg.hashname, arg.hashkey);
1291 }
else if (arg.argc == 1) {
1292 char colnames[4096];
1299 ast_log(
LOG_WARNING,
"No channel and only 1 parameter was provided to %s function.\n", cmd);
1304 hashkeys_read(chan,
"HASHKEYS", arg.hashname, colnames,
sizeof(colnames));
1311 for (i = 0; i < arg2.argc; i++) {
1312 snprintf(varname,
sizeof(varname),
HASH_FORMAT, arg.hashname, arg2.col[i]);
1314 strncat(
buf, varvalue,
len - strlen(
buf) - 1);
1315 strncat(
buf,
",",
len - strlen(
buf) - 1);
1319 buf[strlen(
buf) - 1] =
'\0';
1344 char *bufptr =
buf, *dataptr = data;
1358 for (; bufptr <
buf +
len - 3; dataptr++) {
1359 if (*dataptr ==
'\\') {
1362 }
else if (*dataptr ==
'"') {
1365 }
else if (*dataptr ==
'\0') {
1368 *bufptr++ = *dataptr;
1383 char *bufptr =
buf, *dataptr = data;
1396 for (; bufptr <
buf +
len - 3; dataptr++){
1397 if (*dataptr ==
'"') {
1400 }
else if (*dataptr ==
'\0') {
1403 *bufptr++ = *dataptr;
1412 .
name =
"CSV_QUOTE",
1421 length = strlen(data);
1423 snprintf(
buf, buflen,
"%d", length);
1435 char *
buf,
size_t buflen)
1442 struct timeval when;
1458 buf[buflen - 1] =
'\0';
1469 char *
buf,
size_t buflen)
1482 "Asterisk function STRPTIME() requires an argument.\n");
1490 "No format supplied to STRPTIME(<timestring>,<timezone>,<format>)");
1497 struct timeval when;
1499 snprintf(
buf, buflen,
"%d", (
int) when.tv_sec);
1511 char *
buf,
size_t buflen)
1544 char *bufptr, *dataptr;
1546 for (bufptr =
buf, dataptr = data; bufptr <
buf + buflen - 1; dataptr++) {
1547 if (*dataptr ==
'\0') {
1550 }
else if (*dataptr ==
'1') {
1552 }
else if (strchr(
"AaBbCc2", *dataptr)) {
1554 }
else if (strchr(
"DdEeFf3", *dataptr)) {
1556 }
else if (strchr(
"GgHhIi4", *dataptr)) {
1558 }
else if (strchr(
"JjKkLl5", *dataptr)) {
1560 }
else if (strchr(
"MmNnOo6", *dataptr)) {
1562 }
else if (strchr(
"PpQqRrSs7", *dataptr)) {
1564 }
else if (strchr(
"TtUuVv8", *dataptr)) {
1566 }
else if (strchr(
"WwXxYyZz9", *dataptr)) {
1568 }
else if (*dataptr ==
'0') {
1572 buf[buflen - 1] =
'\0';
1578 .
name =
"KEYPADHASH",
1584 char *bufptr =
buf, *dataptr = data;
1586 while ((bufptr <
buf + buflen - 1) && (*bufptr++ = toupper(*dataptr++)));
1593 char *bufptr, *dataptr = data;
1613 char *bufptr =
buf, *dataptr = data;
1615 while ((bufptr <
buf + buflen - 1) && (*bufptr++ = tolower(*dataptr++)));
1622 char *bufptr, *dataptr = data;
1642 #define beginning (cmd[0] == 'S')
1643 char *after, delimiter[2] =
",", *varsubst;
1646 char *(*search_func)(
const char *s,
int c) = (
beginning ? strchr : strrchr);
1664 sprintf(varsubst,
"${%s}",
args.var);
1676 if (!(after = search_func(
ast_str_buffer(before), delimiter[0]))) {
1702 #define beginning (cmd[0] == 'U')
1703 char delimiter[2] =
",", *varsubst;
1710 const char *stripped_var;
1734 stripped_var =
args.var +
MIN(strspn(
args.var,
"_"), 2);
1735 varsubst =
ast_alloca(strlen(stripped_var) + 4);
1736 sprintf(varsubst,
"${%s}", stripped_var);
1775 #ifdef TEST_FRAMEWORK
1781 char expression[256];
1786 const char *expected;
1788 {
"abc,def,ghi,jkl",
"\\,",
"ghi",
"3"},
1789 {
"abc def ghi jkl",
" ",
"abc",
"1"},
1790 {
"abc/def/ghi/jkl",
"\\\\x2f",
"def",
"2"},
1791 {
"abc$def$ghi$jkl",
"",
"ghi",
"0"},
1792 {
"abc,def,ghi,jkl",
"-",
"",
"0"},
1793 {
"abc-def-ghi-jkl",
"-",
"mno",
"0"}
1798 info->name =
"func_FIELDNUM_test";
1799 info->category =
"/funcs/func_strings/";
1800 info->summary =
"Test FIELDNUM function";
1801 info->description =
"Verify FIELDNUM behavior";
1818 for (i = 0; i <
ARRAY_LEN(test_args); i++) {
1828 snprintf(expression,
sizeof(expression),
"${FIELDNUM(%s,%s,%s)}",
var->name, test_args[i].delim, test_args[i].field);
1853 char expression[256];
1855 const char *test_string;
1856 const char *find_chars;
1857 const char *replace_char;
1858 const char *expected;
1860 {
"abc,def",
"\\,",
"-",
"abc-def"},
1861 {
"abc,abc",
"bc",
"a",
"aaa,aaa"},
1862 {
"abc,def",
"x",
"?",
"abc,def"},
1863 {
"abc,def",
"\\,",
"",
"abcdef"}
1868 info->name =
"func_REPLACE_test";
1869 info->category =
"/funcs/func_strings/";
1870 info->summary =
"Test REPLACE function";
1871 info->description =
"Verify REPLACE behavior";
1888 for (i = 0; i <
ARRAY_LEN(test_args); i++) {
1898 snprintf(expression,
sizeof(expression),
"${REPLACE(%s,%s,%s)}",
var->name, test_args[i].find_chars, test_args[i].replace_char);
1924 {
"\\x41-R",
"DAHDI"},
1925 {
"0-9A-Ca-c",
"0042133333A12212"},
1926 {
"0-9a-cA-C_+\\-",
"0042133333A12212"},
1932 info->name =
"func_FILTER_test";
1933 info->category =
"/funcs/func_strings/";
1934 info->summary =
"Test FILTER function";
1935 info->description =
"Verify FILTER behavior";
1942 char tmp[256], tmp2[256] =
"";
1943 snprintf(
tmp,
sizeof(
tmp),
"${FILTER(%s,0042133333&DAHDI/g1/2212)}",
test_strings[i][0]);
1960 {
"Weasels have eaten my telephone system",
"have eaten my",
"are eating our",
"",
"Weasels are eating our telephone system"},
1961 {
"Did you know twenty plus two is twenty-two?",
"twenty",
"thirty",
NULL,
"Did you know thirty plus two is thirty-two?"},
1962 {
"foofoofoofoofoofoofoo",
"foofoo",
"bar",
NULL,
"barbarbarfoo"},
1963 {
"My pet dog once ate a dog who sat on a dog while eating a corndog.",
"dog",
"cat",
"3",
"My pet cat once ate a cat who sat on a cat while eating a corndog."},
1964 {
"One and one and one is three",
"and",
"plus",
"1",
"One plus one and one is three"},
1965 {
"",
"fhqwagads",
"spelunker",
NULL,
""},
1966 {
"Part of this string is missing.",
"missing",
NULL,
NULL,
"Part of this string is ."},
1967 {
"'Accidentally' left off a bunch of stuff.",
NULL,
NULL,
NULL,
""},
1968 {
"This test will also error.",
"",
"",
"",
""},
1969 {
"This is an \"escape character\" test.",
"\\\"escape character\\\"",
"evil",
NULL,
"This is an evil test."}
1974 info->name =
"func_STRREPLACE_test";
1975 info->category =
"/funcs/func_strings/";
1976 info->summary =
"Test STRREPLACE function";
1977 info->description =
"Verify STRREPLACE behavior";
1995 char tmp[512], tmp2[512] =
"";
2012 snprintf(
tmp,
sizeof(
tmp),
"${STRREPLACE(%s,%s)}",
"test_string",
test_strings[i][1]);
2014 snprintf(
tmp,
sizeof(
tmp),
"${STRREPLACE(%s)}",
"test_string");
2038 {
"212",
"w",
"2w1w2"},
2039 {
"212",
"55",
"2551552"},
2040 {
"212",
" ",
"2 1 2"},
2043 {
"abcdefg",
"_",
"a_b_c_d_e_f_g"},
2046 {
"AAA",
"B",
"ABABA"},
2051 info->name =
"func_STRBETWEEN";
2052 info->category =
"/funcs/func_strings/";
2053 info->summary =
"Test STRBETWEEN function";
2054 info->description =
"Verify STRBETWEEN behavior";
2072 char tmp[512], tmp2[512] =
"";
2085 snprintf(
tmp,
sizeof(
tmp),
"${STRBETWEEN(%s,%s)}",
"test_string",
test_strings[i][1]);
2087 snprintf(
tmp,
sizeof(
tmp),
"${STRBETWEEN(%s)}",
"test_string");
struct sla_ringing_trunk * first
Asterisk main include file. File version handling, generic pbx functions.
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
#define ast_strdupa(s)
duplicate a string in memory from the stack
static snd_pcm_format_t format
static void parse(struct mgcp_request *req)
General Asterisk PBX channel definitions.
struct ast_channel * ast_channel_release(struct ast_channel *chan)
Unlink and release reference to a channel.
int ast_autoservice_stop(struct ast_channel *chan)
Stop servicing a channel for us...
#define ast_channel_lock(chan)
#define ast_dummy_channel_alloc()
Create a fake channel structure.
struct varshead * ast_channel_varshead(struct ast_channel *chan)
#define ast_channel_unlock(chan)
const char * ast_var_name(const struct ast_var_t *var)
#define ast_var_assign(name, value)
void ast_var_delete(struct ast_var_t *var)
static struct ast_custom_function fieldqty_function
static struct ast_threadstorage result_buf
static int function_fieldqty_str(struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
static struct ast_custom_function eval_function
static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static struct ast_custom_function shift_function
static struct ast_custom_function hashkeys_function
static int listfilter(struct ast_channel *chan, const char *cmd, char *parse, char *buf, struct ast_str **bufstr, ssize_t len)
static struct ast_custom_function fieldnum_function
static struct ast_custom_function filter_function
static struct ast_custom_function hash_function
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 strptime_function
static const char * get_key(const struct ast_str *prefix, const struct ast_var_t *var)
static int csv_quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static struct ast_custom_function strbetween_function
static int hash_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static struct ast_custom_function regex_function
static int shift_pop(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int string_tolower(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int unshift_push(struct ast_channel *chan, const char *cmd, char *data, const char *new_value)
static struct ast_custom_function replace_function
static char * app_clearhash
static int hashkeys_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
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 strreplace_function
static int function_fieldqty_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)
static struct ast_custom_function passthru_function
static struct ast_custom_function listfilter_function
static int acf_strptime(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static struct ast_custom_function pop_function
static int string_tolower2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
static struct ast_custom_function unshift_function
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 keypadhash_function
static struct ast_custom_function strftime_function
static int listfilter_read(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static struct ast_custom_function toupper_function
static int array(struct ast_channel *chan, const char *cmd, char *var, const char *value)
static int function_eval2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
static int strreplace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int string_toupper(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int quote(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int passthru(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static struct ast_custom_function quote_function
static int load_module(void)
static int keypadhash(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static struct ast_custom_function csv_quote_function
static struct ast_threadstorage tmp_buf
static int unload_module(void)
static int function_fieldqty(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static int function_eval(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int string_toupper2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
static void clearvar_prefix(struct ast_channel *chan, const char *prefix)
static struct ast_custom_function tolower_function
static struct ast_custom_function array_function
static struct ast_custom_function push_function
static int acf_strftime(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t buflen)
static int function_fieldnum(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static int strbetween(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int hash_write(struct ast_channel *chan, const char *cmd, char *var, const char *value)
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int filter(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
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 exec_clearhash(struct ast_channel *chan, const char *data)
static struct ast_custom_function len_function
static char prefix[MAX_PREFIX]
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
#define AST_APP_ARG(name)
Define an application argument.
int ast_get_encoded_char(const char *stream, char *result, size_t *consumed)
Decode an encoded control or extended ASCII character.
#define AST_STANDARD_RAW_ARGS(args, parse)
char * ast_get_encoded_str(const char *stream, char *result, size_t result_len)
Decode a stream of encoded control or extended ASCII characters.
#define AST_DECLARE_APP_ARGS(name, arglist)
Declare a structure to hold an application's arguments.
#define AST_STANDARD_APP_ARGS(args, parse)
Performs the 'standard' argument separation process for an application.
#define AST_NONSTANDARD_APP_ARGS(args, parse, sep)
Performs the 'nonstandard' argument separation process for an application.
char * strsep(char **str, const char *delims)
#define ast_debug(level,...)
Log a DEBUG message.
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Custom localtime functions for multiple timezones.
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....
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...
struct timeval ast_mktime(struct ast_tm *const tmp, const char *zone)
Timezone-independent version of mktime(3).
struct ast_tm * ast_localtime(const struct timeval *timep, struct ast_tm *p_tm, const char *zone)
Timezone-independent version of localtime_r(3).
Asterisk module definitions.
#define AST_MODULE_INFO_STANDARD(keystr, desc)
#define ASTERISK_GPL_KEY
The text the key() function should return.
int ast_unregister_application(const char *app)
Unregister an application.
#define ast_register_application_xml(app, execute)
Register an application using XML documentation.
#define ast_opt_dont_warn
Core PBX routines and definitions.
void ast_str_substitute_variables(struct ast_str **buf, ssize_t maxlen, struct ast_channel *chan, const char *templ)
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.
#define ast_custom_function_register(acf)
Register a custom function.
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.
void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count)
char * ast_str_truncate(struct ast_str *buf, ssize_t len)
Truncates the enclosed string to the given length.
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
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.
#define ast_str_alloca(init_len)
void ast_str_reset(struct ast_str *buf)
Reset the content of a dynamic string. Useful before a series of ast_str_append.
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
#define ast_str_make_space(buf, new_len)
void ast_str_update(struct ast_str *buf)
Update the length of the buffer, after using ast_str merely as a buffer.
size_t ast_str_strlen(const struct ast_str *buf)
Returns the current length of the string stored within buf.
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
size_t ast_str_size(const struct ast_str *buf)
Returns the current maximum length (without reallocation) of the current buffer.
int ast_get_timeval(const char *src, struct timeval *tv, struct timeval _default, int *consumed)
Parse a time (float) string.
struct ast_str * ast_str_thread_get(struct ast_threadstorage *ts, size_t init_len)
Retrieve a thread locally stored dynamic string.
Main Channel structure associated with a channel.
Data structure associated with a custom dialplan function.
Support for dynamic strings.
struct ast_var_t::@239 entries
#define AST_TEST_REGISTER(cb)
#define ast_test_status_update(a, b, c...)
#define AST_TEST_UNREGISTER(cb)
#define AST_TEST_DEFINE(hdr)
#define AST_THREADSTORAGE(name)
Define a thread storage variable.
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.