func_strings.c File Reference

String manipulation dialplan functions. More...

#include "asterisk.h"
#include <regex.h>
#include <ctype.h>
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/utils.h"
#include "asterisk/app.h"
#include "asterisk/localtime.h"
#include "asterisk/test.h"

Include dependency graph for func_strings.c:

Go to the source code of this file.

Defines
#define	beginning   (cmd[0] == 'U')
#define	beginning   (cmd[0] == 'S')
#define	HASH_FORMAT   HASH_PREFIX "%s~"
#define	HASH_PREFIX   "~HASH~%s~"
Functions
static int	acf_strftime (struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t buflen)
static int	acf_strptime (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int	array (struct ast_channel *chan, const char *cmd, char *var, const char *value)
	AST_MODULE_INFO_STANDARD (ASTERISK_GPL_KEY,"String handling dialplan functions")
	AST_THREADSTORAGE (tmp_buf)
	AST_THREADSTORAGE (result_buf)
static void	clearvar_prefix (struct ast_channel *chan, const char *prefix)
static int	csv_quote (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	exec_clearhash (struct ast_channel *chan, const char *data)
static int	filter (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	function_eval2 (struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
static int	function_fieldnum (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	function_fieldnum_str (struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
static int	function_fieldqty (struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
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	function_fieldqty_str (struct ast_channel *chan, const char *cmd, char *parse, struct ast_str **buf, ssize_t len)
static int	hash_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	hash_write (struct ast_channel *chan, const char *cmd, char *var, const char *value)
static int	hashkeys_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	hashkeys_read2 (struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int	keypadhash (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
static int	len (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)
static int	listfilter_read (struct ast_channel *chan, const char *cmd, char *parse, 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 int	load_module (void)
static int	passthru (struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int	quote (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	regex (struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static int	replace (struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
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	string_tolower2 (struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t buflen)
static int	string_toupper (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 int	unload_module (void)
static int	unshift_push (struct ast_channel *chan, const char *cmd, char *data, const char *new_value)
Variables
static char *	app_clearhash = "ClearHash"
static struct ast_custom_function	array_function
static struct ast_custom_function	csv_quote_function
static struct ast_custom_function	eval_function
static struct ast_custom_function	fieldnum_function
static struct ast_custom_function	fieldqty_function
static struct ast_custom_function	filter_function
static struct ast_custom_function	hash_function
static struct ast_custom_function	hashkeys_function
static struct ast_custom_function	keypadhash_function
static struct ast_custom_function	len_function
static struct ast_custom_function	listfilter_function
static struct ast_custom_function	passthru_function
static struct ast_custom_function	pop_function
static struct ast_custom_function	push_function
static struct ast_custom_function	quote_function
static struct ast_custom_function	regex_function
static struct ast_custom_function	replace_function
static struct ast_custom_function	shift_function
static struct ast_custom_function	strftime_function
static struct ast_custom_function	strptime_function
static struct ast_custom_function	tolower_function
static struct ast_custom_function	toupper_function
static struct ast_custom_function	unshift_function

---

Detailed Description

String manipulation dialplan functions.

Author:

Tilghman Lesher

Anothony Minessale II

Definition in file func_strings.c.

---

Define Documentation

#define beginning   (cmd[0] == 'U')

#define beginning   (cmd[0] == 'S')

Referenced by shift_pop(), and unshift_push().

#define HASH_FORMAT   HASH_PREFIX "%s~"

Definition at line 887 of file func_strings.c.

Referenced by array(), hash_read(), and hash_write().

#define HASH_PREFIX   "~HASH~%s~"

Definition at line 886 of file func_strings.c.

Referenced by exec_clearhash(), hashkeys_read(), and hashkeys_read2().

---

Function Documentation

static int acf_strftime	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1215 of file func_strings.c.

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_get_timeval(), ast_localtime(), ast_log(), AST_STANDARD_APP_ARGS, ast_strftime(), ast_tvnow(), format, and LOG_WARNING.

{
   AST_DECLARE_APP_ARGS(args,
              AST_APP_ARG(epoch);
              AST_APP_ARG(timezone);
              AST_APP_ARG(format);
   );
   struct timeval when;
   struct ast_tm tm;

   buf[0] = '\0';

   AST_STANDARD_APP_ARGS(args, parse);

   ast_get_timeval(args.epoch, &when, ast_tvnow(), NULL);
   ast_localtime(&when, &tm, args.timezone);

   if (!args.format)
      args.format = "%c";

   if (ast_strftime(buf, buflen, args.format, &tm) <= 0)
      ast_log(LOG_WARNING, "C function strftime() output nothing?!!\n");

   buf[buflen - 1] = '\0';

   return 0;
}

static int acf_strptime	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1249 of file func_strings.c.

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log(), ast_mktime(), AST_STANDARD_APP_ARGS, ast_strlen_zero(), ast_strptime(), format, LOG_ERROR, and LOG_WARNING.

{
   AST_DECLARE_APP_ARGS(args,
              AST_APP_ARG(timestring);
              AST_APP_ARG(timezone);
              AST_APP_ARG(format);
   );
   struct ast_tm tm;

   buf[0] = '\0';

   if (!data) {
      ast_log(LOG_ERROR,
            "Asterisk function STRPTIME() requires an argument.\n");
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, data);

   if (ast_strlen_zero(args.format)) {
      ast_log(LOG_ERROR,
            "No format supplied to STRPTIME(<timestring>,<timezone>,<format>)");
      return -1;
   }

   if (!ast_strptime(args.timestring, args.format, &tm)) {
      ast_log(LOG_WARNING, "STRPTIME() found no time specified within the string\n");
   } else {
      struct timeval when;
      when = ast_mktime(&tm, args.timezone);
      snprintf(buf, buflen, "%d", (int) when.tv_sec);
   }

   return 0;
}

static int array	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	var,
		const char *	value
	)			[static]

Definition at line 913 of file func_strings.c.

References AST_APP_ARG, ast_autoservice_stop(), ast_debug, AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, ast_strdupa, HASH_FORMAT, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), and S_OR.

Referenced by hash_write().

{
   AST_DECLARE_APP_ARGS(arg1,
              AST_APP_ARG(var)[100];
   );
   AST_DECLARE_APP_ARGS(arg2,
              AST_APP_ARG(val)[100];
   );
   char *origvar = "", *value2, varname[256];
   int i, ishash = 0;

   if (!var) {
      return -1;
   }
   value2 = ast_strdupa(value);

   if (!strcmp(cmd, "HASH")) {
      const char *var2 = pbx_builtin_getvar_helper(chan, "~ODBCFIELDS~");
      origvar = var;
      if (var2)
         var = ast_strdupa(var2);
      else {
         if (chan)
            ast_autoservice_stop(chan);
         return -1;
      }
      ishash = 1;
   }

   /* The functions this will generally be used with are SORT and ODBC_*, which
    * both return comma-delimited lists.  However, if somebody uses literal lists,
    * their commas will be translated to vertical bars by the load, and I don't
    * want them to be surprised by the result.  Hence, we prefer commas as the
    * delimiter, but we'll fall back to vertical bars if commas aren't found.
    */
   ast_debug(1, "array (%s=%s)\n", var, S_OR(value2, ""));
   AST_STANDARD_APP_ARGS(arg1, var);

   AST_STANDARD_APP_ARGS(arg2, value2);

   for (i = 0; i < arg1.argc; i++) {
      ast_debug(1, "array set value (%s=%s)\n", arg1.var[i],
            S_OR(arg2.val[i], ""));
      if (i < arg2.argc) {
         if (ishash) {
            if (origvar[0] == '_') {
               if (origvar[1] == '_') {
                  snprintf(varname, sizeof(varname), "__" HASH_FORMAT, origvar + 2, arg1.var[i]);
               } else {
                  snprintf(varname, sizeof(varname), "_" HASH_FORMAT, origvar + 1, arg1.var[i]);
               }
            } else {
               snprintf(varname, sizeof(varname), HASH_FORMAT, origvar, arg1.var[i]);
            }

            pbx_builtin_setvar_helper(chan, varname, arg2.val[i]);
         } else {
            pbx_builtin_setvar_helper(chan, arg1.var[i], arg2.val[i]);
         }
      } else {
         /* We could unset the variable, by passing a NULL, but due to
          * pushvar semantics, that could create some undesired behavior. */
         if (ishash) {
            snprintf(varname, sizeof(varname), HASH_FORMAT, origvar, arg1.var[i]);
            pbx_builtin_setvar_helper(chan, varname, "");
         } else {
            pbx_builtin_setvar_helper(chan, arg1.var[i], "");
         }
      }
   }

   return 0;
}

AST_MODULE_INFO_STANDARD	(	ASTERISK_GPL_KEY	,
		"String handling dialplan functions"
	)

AST_THREADSTORAGE

(

tmp_buf

)

AST_THREADSTORAGE

(

result_buf

)

static void clearvar_prefix	(	struct ast_channel *	chan,
		const char *	prefix
	)			[static]

Definition at line 892 of file func_strings.c.

References ast_free, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_var_name(), len(), var, and ast_channel::varshead.

Referenced by exec_clearhash().

{
   struct ast_var_t *var;
   int len = strlen(prefix);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->varshead, var, entries) {
      if (strncasecmp(prefix, ast_var_name(var), len) == 0) {
         AST_LIST_REMOVE_CURRENT(entries);
         ast_free(var);
      }
   }
   AST_LIST_TRAVERSE_SAFE_END
}

static int csv_quote	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 1162 of file func_strings.c.

References ast_copy_string(), ast_log(), ast_strlen_zero(), and LOG_ERROR.

{
   char *bufptr = buf, *dataptr = data;

   if (len < 3) { /* at least two for quotes and one for binary zero */
      ast_log(LOG_ERROR, "Not enough buffer\n");
      return -1;
   }

   if (ast_strlen_zero(data)) {
      ast_copy_string(buf, "\"\"", len);
      return 0;
   }

   *bufptr++ = '"';
   for (; bufptr < buf + len - 3; dataptr++){
      if (*dataptr == '"') {
         *bufptr++ = '"';
         *bufptr++ = '"';
      } else if (*dataptr == '\0') {
         break;
      } else {
         *bufptr++ = *dataptr;
      }
   }
   *bufptr++ = '"';
   *bufptr='\0';
   return 0;
}

static int exec_clearhash	(	struct ast_channel *	chan,
		const char *	data
	)			[static]

Definition at line 905 of file func_strings.c.

References clearvar_prefix(), HASH_PREFIX, and prefix.

Referenced by load_module().

{
   char prefix[80];
   snprintf(prefix, sizeof(prefix), HASH_PREFIX, data ? (char *)data : "null");
   clearvar_prefix(chan, prefix);
   return 0;
}

static int filter	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		size_t	len
	)			[static]

Note:

Looks a little strange, until you realize that we can overflow the size of a char.

Definition at line 694 of file func_strings.c.

References args, AST_APP_ARG, ast_debug, AST_DECLARE_APP_ARGS, ast_get_encoded_char(), ast_log(), ast_opt_dont_warn, AST_STANDARD_RAW_ARGS, LOG_ERROR, and LOG_WARNING.

Referenced by __ast_data_add(), data_filter_destructor(), data_filter_generate(), data_result_generate(), manager_data_get(), realtime_ldap_base_ap(), set_egress_subscription(), update2_ldap(), and update_ldap().

{
   AST_DECLARE_APP_ARGS(args,
              AST_APP_ARG(allowed);
              AST_APP_ARG(string);
   );
   char *outbuf = buf;
   unsigned char ac;
   char allowed[256] = "";
   size_t allowedlen = 0;
   int32_t bitfield[8] = { 0, }; /* 256 bits */

   AST_STANDARD_RAW_ARGS(args, parse);

   if (!args.string) {
      ast_log(LOG_ERROR, "Usage: FILTER(<allowed-chars>,<string>)\n");
      return -1;
   }

   if (args.allowed[0] == '"' && !ast_opt_dont_warn) {
      ast_log(LOG_WARNING, "FILTER allowed characters includes the quote (\") character.  This may not be what you want.\n");
   }

   /* Expand ranges */
   for (; *(args.allowed);) {
      char c1 = 0, c2 = 0;
      size_t consumed = 0;

      if (ast_get_encoded_char(args.allowed, &c1, &consumed))
         return -1;
      args.allowed += consumed;

      if (*(args.allowed) == '-') {
         if (ast_get_encoded_char(args.allowed + 1, &c2, &consumed))
            c2 = c1;
         args.allowed += consumed + 1;

         if ((unsigned char) c2 < (unsigned char) c1 && !ast_opt_dont_warn) {
            ast_log(LOG_WARNING, "Range wrapping in FILTER(%s,%s).  This may not be what you want.\n", parse, args.string);
         }

         /*!\note
          * Looks a little strange, until you realize that we can overflow
          * the size of a char.
          */
         for (ac = (unsigned char) c1; ac != (unsigned char) c2; ac++) {
            bitfield[ac / 32] |= 1 << (ac % 32);
         }
         bitfield[ac / 32] |= 1 << (ac % 32);

         ast_debug(4, "c1=%d, c2=%d\n", c1, c2);
      } else {
         ac = (unsigned char) c1;
         ast_debug(4, "c1=%d, consumed=%d, args.allowed=%s\n", c1, (int) consumed, args.allowed - consumed);
         bitfield[ac / 32] |= 1 << (ac % 32);
      }
   }

   for (ac = 1; ac != 0; ac++) {
      if (bitfield[ac / 32] & (1 << (ac % 32))) {
         allowed[allowedlen++] = ac;
      }
   }

   ast_debug(1, "Allowed: %s\n", allowed);

   for (; *(args.string) && (buf + len - 1 > outbuf); (args.string)++) {
      if (strchr(allowed, *(args.string)))
         *outbuf++ = *(args.string);
   }
   *outbuf = '\0';

   return 0;
}

static int function_eval	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1291 of file func_strings.c.

References ast_log(), ast_strlen_zero(), LOG_WARNING, and pbx_substitute_variables_helper().

{
   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
      return -1;
   }

   pbx_substitute_variables_helper(chan, data, buf, buflen - 1);

   return 0;
}

static int function_eval2	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	buflen
	)			[static]

Definition at line 1304 of file func_strings.c.

References ast_log(), ast_str_substitute_variables(), ast_strlen_zero(), and LOG_WARNING.

{
   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "EVAL requires an argument: EVAL(<string>)\n");
      return -1;
   }

   ast_str_substitute_variables(buf, buflen, chan, data);

   return 0;
}

static int function_fieldnum	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 548 of file func_strings.c.

References function_fieldnum_helper().

{
   return function_fieldnum_helper(chan, cmd, parse, buf, NULL, 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]

Definition at line 487 of file func_strings.c.

References args, ast_alloca, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_get_encoded_char(), ast_log(), AST_STANDARD_APP_ARGS, ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_str_substitute_variables(), ast_str_thread_get(), ast_strlen_zero(), LOG_ERROR, result_buf, and str.

Referenced by function_fieldnum(), and function_fieldnum_str().

{
   char *varsubst, *field;
   struct ast_str *str = ast_str_thread_get(&result_buf, 16);
   int fieldindex = 0, res = 0;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(varname);
      AST_APP_ARG(delim);
      AST_APP_ARG(field);
   );
   char delim[2] = "";
   size_t delim_used;

   if (!str) {
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, parse);

   if (args.argc < 3) {
      ast_log(LOG_ERROR, "Usage: FIELDNUM(<listname>,<delimiter>,<fieldvalue>)\n");
      res = -1;
   } else {
      varsubst = ast_alloca(strlen(args.varname) + 4);
      sprintf(varsubst, "${%s}", args.varname);

      ast_str_substitute_variables(&str, 0, chan, varsubst);

      if (ast_str_strlen(str) == 0 || ast_strlen_zero(args.delim)) {
         fieldindex = 0;
      } else if (ast_get_encoded_char(args.delim, delim, &delim_used) == -1) {
         res = -1;
      } else {
         char *varval = ast_str_buffer(str);

         while ((field = strsep(&varval, delim)) != NULL) {
            fieldindex++;

            if (!strcasecmp(field, args.field)) {
               break;
            }
         }

         if (!field) {
            fieldindex = 0;
         }

         res = 0;
      }
   }

   if (sbuf) {
      ast_str_set(sbuf, len, "%d", fieldindex);
   } else {
      snprintf(buf, len, "%d", fieldindex);
   }

   return res;
}

static int function_fieldnum_str	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 554 of file func_strings.c.

References function_fieldnum_helper().

{
   return function_fieldnum_helper(chan, cmd, parse, NULL, buf, len);
}

static int function_fieldqty	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 469 of file func_strings.c.

References function_fieldqty_helper().

{
   return function_fieldqty_helper(chan, cmd, parse, buf, NULL, len);
}

static int function_fieldqty_helper	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		struct ast_str **	sbuf,
		ssize_t	len
	)			[static]

Definition at line 424 of file func_strings.c.

References args, ast_alloca, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_get_encoded_char(), AST_STANDARD_APP_ARGS, ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_str_substitute_variables(), ast_str_thread_get(), result_buf, and str.

Referenced by function_fieldqty(), and function_fieldqty_str().

{
   char *varsubst;
   struct ast_str *str = ast_str_thread_get(&result_buf, 16);
   int fieldcount = 0;
   AST_DECLARE_APP_ARGS(args,
              AST_APP_ARG(varname);
              AST_APP_ARG(delim);
      );
   char delim[2] = "";
   size_t delim_used;

   if (!str) {
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, parse);
   if (args.delim) {
      ast_get_encoded_char(args.delim, delim, &delim_used);

      varsubst = ast_alloca(strlen(args.varname) + 4);

      sprintf(varsubst, "${%s}", args.varname);
      ast_str_substitute_variables(&str, 0, chan, varsubst);
      if (ast_str_strlen(str) == 0) {
         fieldcount = 0;
      } else {
         char *varval = ast_str_buffer(str);
         while (strsep(&varval, delim)) {
            fieldcount++;
         }
      }
   } else {
      fieldcount = 1;
   }
   if (sbuf) {
      ast_str_set(sbuf, len, "%d", fieldcount);
   } else {
      snprintf(buf, len, "%d", fieldcount);
   }

   return 0;
}

static int function_fieldqty_str	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 475 of file func_strings.c.

References function_fieldqty_helper().

{
   return function_fieldqty_helper(chan, cmd, parse, NULL, buf, len);
}

static int hash_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 1060 of file func_strings.c.

References AST_APP_ARG, ast_copy_string(), AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, HASH_FORMAT, hashkeys_read(), pbx_builtin_getvar_helper(), and pbx_builtin_setvar_helper().

{
   char varname[256];
   const char *varvalue;
   AST_DECLARE_APP_ARGS(arg,
      AST_APP_ARG(hashname);
      AST_APP_ARG(hashkey);
   );

   AST_STANDARD_APP_ARGS(arg, data);
   if (arg.argc == 2) {
      snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg.hashkey);
      varvalue = pbx_builtin_getvar_helper(chan, varname);
      if (varvalue)
         ast_copy_string(buf, varvalue, len);
      else
         *buf = '\0';
   } else if (arg.argc == 1) {
      char colnames[4096];
      int i;
      AST_DECLARE_APP_ARGS(arg2,
         AST_APP_ARG(col)[100];
      );

      /* Get column names, in no particular order */
      hashkeys_read(chan, "HASHKEYS", arg.hashname, colnames, sizeof(colnames));
      pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", colnames);

      AST_STANDARD_APP_ARGS(arg2, colnames);
      *buf = '\0';

      /* Now get the corresponding column values, in exactly the same order */
      for (i = 0; i < arg2.argc; i++) {
         snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg2.col[i]);
         varvalue = pbx_builtin_getvar_helper(chan, varname);
         strncat(buf, varvalue, len - strlen(buf) - 1);
         strncat(buf, ",", len - strlen(buf) - 1);
      }

      /* Strip trailing comma */
      buf[strlen(buf) - 1] = '\0';
   }

   return 0;
}

static int hash_write	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	var,
		const char *	value
	)			[static]

Definition at line 1032 of file func_strings.c.

References array(), AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, HASH_FORMAT, and pbx_builtin_setvar_helper().

{
   char varname[256];
   AST_DECLARE_APP_ARGS(arg,
      AST_APP_ARG(hashname);
      AST_APP_ARG(hashkey);
   );

   if (!strchr(var, ',')) {
      /* Single argument version */
      return array(chan, "HASH", var, value);
   }

   AST_STANDARD_APP_ARGS(arg, var);
   if (arg.hashname[0] == '_') {
      if (arg.hashname[1] == '_') {
         snprintf(varname, sizeof(varname), "__" HASH_FORMAT, arg.hashname + 2, arg.hashkey);
      } else {
         snprintf(varname, sizeof(varname), "_" HASH_FORMAT, arg.hashname + 1, arg.hashkey);
      }
   } else {
      snprintf(varname, sizeof(varname), HASH_FORMAT, arg.hashname, arg.hashkey);
   }
   pbx_builtin_setvar_helper(chan, varname, value);

   return 0;
}

static int hashkeys_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 988 of file func_strings.c.

References AST_LIST_TRAVERSE, ast_str_alloca, ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_var_name(), HASH_PREFIX, prefix, and ast_channel::varshead.

Referenced by hash_read().

{
   struct ast_var_t *newvar;
   struct ast_str *prefix = ast_str_alloca(80);

   ast_str_set(&prefix, -1, HASH_PREFIX, data);
   memset(buf, 0, len);

   AST_LIST_TRAVERSE(&chan->varshead, newvar, entries) {
      if (strncasecmp(ast_str_buffer(prefix), ast_var_name(newvar), ast_str_strlen(prefix)) == 0) {
         /* Copy everything after the prefix */
         strncat(buf, ast_var_name(newvar) + ast_str_strlen(prefix), len - strlen(buf) - 1);
         /* Trim the trailing ~ */
         buf[strlen(buf) - 1] = ',';
      }
   }
   /* Trim the trailing comma */
   buf[strlen(buf) - 1] = '\0';
   return 0;
}

static int hashkeys_read2	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 1009 of file func_strings.c.

References AST_LIST_TRAVERSE, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_var_name(), HASH_PREFIX, prefix, and ast_channel::varshead.

{
   struct ast_var_t *newvar;
   struct ast_str *prefix = ast_str_alloca(80);
   char *tmp;

   ast_str_set(&prefix, -1, HASH_PREFIX, data);

   AST_LIST_TRAVERSE(&chan->varshead, newvar, entries) {
      if (strncasecmp(ast_str_buffer(prefix), ast_var_name(newvar), ast_str_strlen(prefix)) == 0) {
         /* Copy everything after the prefix */
         ast_str_append(buf, len, "%s", ast_var_name(newvar) + ast_str_strlen(prefix));
         /* Trim the trailing ~ */
         tmp = ast_str_buffer(*buf);
         tmp[ast_str_strlen(*buf) - 1] = ',';
      }
   }
   /* Trim the trailing comma */
   tmp = ast_str_buffer(*buf);
   tmp[ast_str_strlen(*buf) - 1] = '\0';
   return 0;
}

static int keypadhash	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1323 of file func_strings.c.

{
   char *bufptr, *dataptr;

   for (bufptr = buf, dataptr = data; bufptr < buf + buflen - 1; dataptr++) {
      if (*dataptr == '\0') {
         *bufptr++ = '\0';
         break;
      } else if (*dataptr == '1') {
         *bufptr++ = '1';
      } else if (strchr("AaBbCc2", *dataptr)) {
         *bufptr++ = '2';
      } else if (strchr("DdEeFf3", *dataptr)) {
         *bufptr++ = '3';
      } else if (strchr("GgHhIi4", *dataptr)) {
         *bufptr++ = '4';
      } else if (strchr("JjKkLl5", *dataptr)) {
         *bufptr++ = '5';
      } else if (strchr("MmNnOo6", *dataptr)) {
         *bufptr++ = '6';
      } else if (strchr("PpQqRrSs7", *dataptr)) {
         *bufptr++ = '7';
      } else if (strchr("TtUuVv8", *dataptr)) {
         *bufptr++ = '8';
      } else if (strchr("WwXxYyZz9", *dataptr)) {
         *bufptr++ = '9';
      } else if (*dataptr == '0') {
         *bufptr++ = '0';
      }
   }
   buf[buflen - 1] = '\0';

   return 0;
}

static int len	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1197 of file func_strings.c.

Referenced by __analog_ss_thread(), __ast_cli_register(), __ast_str_helper(), __get_header(), __rtp_recvfrom(), __rtp_sendto(), _parse(), add_sdp(), ael_token_subst(), aji_io_recv(), aji_recv(), aji_send_header(), aji_send_raw(), aji_start_sasl(), alsa_write(), analog_ss_thread(), aoc_parse_ie(), append_interface(), append_var_and_value_to_filter(), ast_agi_register_multiple(), ast_agi_unregister_multiple(), ast_app_group_set_channel(), ast_callerid_vmwi_generate(), ast_cdr_appenduserfield(), ast_cli_complete(), ast_codec_get_len(), ast_complete_source_filename(), ast_dsp_noise(), ast_dsp_process(), ast_dsp_silence(), ast_event_cb(), ast_format_str_reduce(), ast_frdup(), ast_getformatname_multiple(), ast_http_send(), ast_http_uri_link(), ast_mkdir(), ast_read_image(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_read(), ast_say_number_full_ka(), ast_smoother_read(), ast_str_buffer(), ast_str_substitute_variables_full(), ast_translate(), ast_udptl_write(), ast_xml_escape(), ast_xmldoc_printable(), auth_exec(), authenticate(), build_device(), build_facility(), build_route(), callerid_generate(), cleaned_basedn(), clearvar_prefix(), cli_console_sendtext(), complete_agent_logoff_cmd(), complete_confno(), complete_dialplan_add_extension(), complete_dialplan_add_ignorepat(), complete_dialplan_add_include(), complete_dialplan_remove_extension(), complete_dialplan_remove_ignorepat(), complete_dialplan_remove_include(), complete_meetmecmd_list(), complete_meetmecmd_mute_kick(), complete_peer_helper(), complete_trans_path_choice(), complete_userno(), conf_play(), config_jitterbuffer(), cops_getmsg(), copy(), create_video_frame(), dahdi_sendtext(), dahdi_setoption(), devstate_write(), dialgroup_refreshdb(), dictate_exec(), do_pktccops(), dundi_encrypt(), dundi_parse_ies(), dundi_send(), enc_ie_facility(), evt_event_deliver_cb(), expr2_token_subst(), ext_cmp_exten_strlen(), ffmpeg_decode(), find_by_part(), get_body(), get_ip_and_port_from_sdp(), get_sdp(), get_sdp_iterate(), get_to_address(), gsm_write(), gsmtolin_framein(), h261_encap(), h263_encap(), h263_read(), h263_write(), h263p_encap(), h264_read(), h264_write(), handle_cli_core_show_translation(), handle_cli_devstate_change(), handle_commandmatchesarray(), handle_incoming(), handle_message(), handle_output(), handle_response(), handle_show_sysinfo(), help1(), iax_parse_ies(), iax_str2flags(), launch_monitor_thread(), listener(), load_file(), local_call(), lpc10tolin_framein(), lws2sws(), message_template_parse_emailbody(), method_match(), mgcp_ss(), mgcpsock_read(), misdn_read(), monmp3thread(), mpeg4_encap(), newpvt(), parse_ie(), ParseBookmark(), pbx_substitute_variables_helper_full(), phoneprov_callback(), process_sdp(), read_credentials(), readfile_exec(), red_t140_to_red(), reschedule_precache(), run_agi(), scan_thread(), schedule_delivery(), set(), set_egress_subscription(), sip_addheader(), sip_show_channel(), sip_show_history(), skinny_ss(), sms_messagetx(), socket_process_meta(), socket_read(), static_callback(), term_filter_escapes(), transfer_exec(), try_firmware(), udptl_build_packet(), unistim_sp(), unquote(), wav_write(), and xmldoc_get_syntax_fun().

{
   int length = 0;

   if (data)
      length = strlen(data);

   snprintf(buf, buflen, "%d", length);

   return 0;
}

static int listfilter	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		struct ast_str **	bufstr,
		ssize_t	len
	)			[static]

Definition at line 566 of file func_strings.c.

References args, ast_alloca, AST_APP_ARG, ast_channel_lock, ast_channel_unlock, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_get_encoded_str(), ast_log(), AST_STANDARD_APP_ARGS, ast_str_append(), ast_str_append_substr(), ast_str_buffer(), ast_str_make_space(), ast_str_reset(), ast_str_set(), ast_str_strlen(), ast_str_substitute_variables(), ast_str_thread_get(), first, LOG_ERROR, and result_buf.

Referenced by listfilter_read(), and listfilter_read2().

{
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(listname);
      AST_APP_ARG(delimiter);
      AST_APP_ARG(fieldvalue);
   );
   struct ast_str *orig_list = ast_str_thread_get(&tmp_buf, 16);
   const char *begin, *cur, *next;
   int dlen, flen, first = 1;
   struct ast_str *result, **result_ptr = &result;
   char *delim, *varsubst;

   AST_STANDARD_APP_ARGS(args, parse);

   if (buf) {
      if (!(result = ast_str_thread_get(&result_buf, 16))) {
         return -1;
      }
   } else {
      /* Place the result directly into the output buffer */
      result_ptr = bufstr;
   }

   if (args.argc < 3) {
      ast_log(LOG_ERROR, "Usage: LISTFILTER(<listname>,<delimiter>,<fieldvalue>)\n");
      return -1;
   }

   varsubst = ast_alloca(strlen(args.listname) + 4);
   sprintf(varsubst, "${%s}", args.listname);

   /* If we don't lock the channel, the variable could disappear out from underneath us. */
   if (chan) {
      ast_channel_lock(chan);
   }
   ast_str_substitute_variables(&orig_list, 0, chan, varsubst);
   if (!ast_str_strlen(orig_list)) {
      ast_log(LOG_ERROR, "List variable '%s' not found\n", args.listname);
      if (chan) {
         ast_channel_unlock(chan);
      }
      return -1;
   }

   /* If the string isn't there, just copy out the string and be done with it. */
   if (!strstr(ast_str_buffer(orig_list), args.fieldvalue)) {
      if (buf) {
         ast_copy_string(buf, ast_str_buffer(orig_list), len);
      } else {
         ast_str_set(result_ptr, len, "%s", ast_str_buffer(orig_list));
      }
      if (chan) {
         ast_channel_unlock(chan);
      }
      return 0;
   }

   dlen = strlen(args.delimiter);
   delim = ast_alloca(dlen + 1);
   ast_get_encoded_str(args.delimiter, delim, dlen + 1);

   if ((dlen = strlen(delim)) == 0) {
      delim = ",";
      dlen = 1;
   }

   flen = strlen(args.fieldvalue);

   ast_str_reset(*result_ptr);
   /* Enough space for any result */
   if (len > -1) {
      ast_str_make_space(result_ptr, len ? len : ast_str_strlen(orig_list) + 1);
   }

   begin = ast_str_buffer(orig_list);
   next = strstr(begin, delim);

   do {
      /* Find next boundary */
      if (next) {
         cur = next;
         next = strstr(cur + dlen, delim);
      } else {
         cur = strchr(begin + dlen, '\0');
      }

      if (flen == cur - begin && !strncmp(begin, args.fieldvalue, flen)) {
         /* Skip field */
         begin += flen + dlen;
      } else {
         /* Copy field to output */
         if (!first) {
            ast_str_append(result_ptr, len, "%s", delim);
         }

         ast_str_append_substr(result_ptr, len, begin, cur - begin);
         first = 0;
         begin = cur + dlen;
      }
   } while (*cur != '\0');
   if (chan) {
      ast_channel_unlock(chan);
   }

   if (buf) {
      ast_copy_string(buf, ast_str_buffer(result), len);
   }

   return 0;
}

static int listfilter_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 678 of file func_strings.c.

References listfilter().

{
   return listfilter(chan, cmd, parse, buf, NULL, len);
}

static int listfilter_read2	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 683 of file func_strings.c.

References listfilter().

{
   return listfilter(chan, cmd, parse, NULL, buf, len);
}

static int load_module

(

void

)

[static]

Definition at line 1762 of file func_strings.c.

References ast_custom_function_register, ast_register_application_xml, AST_TEST_REGISTER, and exec_clearhash().

{
   int res = 0;

   AST_TEST_REGISTER(test_FIELDNUM);
   AST_TEST_REGISTER(test_REPLACE);
   AST_TEST_REGISTER(test_FILTER);
   res |= ast_custom_function_register(&fieldqty_function);
   res |= ast_custom_function_register(&fieldnum_function);
   res |= ast_custom_function_register(&filter_function);
   res |= ast_custom_function_register(&replace_function);
   res |= ast_custom_function_register(&listfilter_function);
   res |= ast_custom_function_register(&regex_function);
   res |= ast_custom_function_register(&array_function);
   res |= ast_custom_function_register(&quote_function);
   res |= ast_custom_function_register(&csv_quote_function);
   res |= ast_custom_function_register(&len_function);
   res |= ast_custom_function_register(&strftime_function);
   res |= ast_custom_function_register(&strptime_function);
   res |= ast_custom_function_register(&eval_function);
   res |= ast_custom_function_register(&keypadhash_function);
   res |= ast_custom_function_register(&hashkeys_function);
   res |= ast_custom_function_register(&hash_function);
   res |= ast_register_application_xml(app_clearhash, exec_clearhash);
   res |= ast_custom_function_register(&toupper_function);
   res |= ast_custom_function_register(&tolower_function);
   res |= ast_custom_function_register(&shift_function);
   res |= ast_custom_function_register(&pop_function);
   res |= ast_custom_function_register(&push_function);
   res |= ast_custom_function_register(&unshift_function);
   res |= ast_custom_function_register(&passthru_function);

   return res;
}

static int passthru	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 1537 of file func_strings.c.

References ast_str_set().

{
   ast_str_set(buf, len, "%s", data);
   return 0;
}

static int quote	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 1123 of file func_strings.c.

References ast_copy_string(), ast_log(), ast_strlen_zero(), LOG_ERROR, and LOG_WARNING.

Referenced by __ast_app_separate_args(), and parse_options().

{
   char *bufptr = buf, *dataptr = data;

   if (len < 3){ /* at least two for quotes and one for binary zero */
      ast_log(LOG_ERROR, "Not enough buffer\n");
      return -1;
   }

   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "No argument specified!\n");
      ast_copy_string(buf, "\"\"", len);
      return 0;
   }

   *bufptr++ = '"';
   for (; bufptr < buf + len - 3; dataptr++) {
      if (*dataptr == '\\') {
         *bufptr++ = '\\';
         *bufptr++ = '\\';
      } else if (*dataptr == '"') {
         *bufptr++ = '\\';
         *bufptr++ = '"';
      } else if (*dataptr == '\0') {
         break;
      } else {
         *bufptr++ = *dataptr;
      }
   }
   *bufptr++ = '"';
   *bufptr = '\0';
   return 0;
}

static int regex	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	parse,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 844 of file func_strings.c.

References args, AST_APP_ARG, ast_debug, AST_DECLARE_APP_ARGS, ast_log(), AST_NONSTANDARD_APP_ARGS, LOG_ERROR, LOG_WARNING, and str.

{
   AST_DECLARE_APP_ARGS(args,
              AST_APP_ARG(null);
              AST_APP_ARG(reg);
              AST_APP_ARG(str);
   );
   int errcode;
   regex_t regexbuf;

   buf[0] = '\0';

   AST_NONSTANDARD_APP_ARGS(args, parse, '"');

   if (args.argc != 3) {
      ast_log(LOG_ERROR, "Unexpected arguments: should have been in the form '\"<regex>\" <string>'\n");
      return -1;
   }
   if ((*args.str == ' ') || (*args.str == '\t'))
      args.str++;

   ast_debug(1, "FUNCTION REGEX (%s)(%s)\n", args.reg, args.str);

   if ((errcode = regcomp(&regexbuf, args.reg, REG_EXTENDED | REG_NOSUB))) {
      regerror(errcode, &regexbuf, buf, len);
      ast_log(LOG_WARNING, "Malformed input %s(%s): %s\n", cmd, parse, buf);
      return -1;
   }
   
   strcpy(buf, regexec(&regexbuf, args.str, 0, NULL, 0) ? "0" : "1");

   regfree(&regexbuf);

   return 0;
}

static int replace	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 775 of file func_strings.c.

References args, ast_alloca, AST_APP_ARG, ast_debug, AST_DECLARE_APP_ARGS, ast_get_encoded_char(), ast_get_encoded_str(), ast_log(), AST_STANDARD_APP_ARGS, ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_str_substitute_variables(), ast_str_thread_get(), ast_strlen_zero(), LOG_ERROR, result_buf, and str.

Referenced by process_text_line().

{
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(varname);
      AST_APP_ARG(find);
      AST_APP_ARG(replace);
   );
   char *strptr, *varsubst;
   struct ast_str *str = ast_str_thread_get(&result_buf, 16);
   char find[256]; /* Only 256 characters possible */
   char replace[2] = "";
   size_t unused;

   AST_STANDARD_APP_ARGS(args, data);

   if (!str) {
      return -1;
   }

   if (args.argc < 2) {
      ast_log(LOG_ERROR, "Usage: %s(<varname>,<search-chars>[,<replace-char>])\n", cmd);
      return -1;
   }

   /* Decode escapes */
   ast_get_encoded_str(args.find, find, sizeof(find));
   ast_get_encoded_char(args.replace, replace, &unused);

   if (ast_strlen_zero(find) || ast_strlen_zero(args.varname)) {
      ast_log(LOG_ERROR, "The characters to search for and the variable name must not be empty.\n");
      return -1;
   }

   varsubst = ast_alloca(strlen(args.varname) + 4);
   sprintf(varsubst, "${%s}", args.varname);
   ast_str_substitute_variables(&str, 0, chan, varsubst);

   if (!ast_str_strlen(str)) {
      /* Blank, nothing to replace */
      return -1;
   }

   ast_debug(3, "String to search: (%s)\n", ast_str_buffer(str));
   ast_debug(3, "Characters to find: (%s)\n", find);
   ast_debug(3, "Character to replace with: (%s)\n", replace);

   for (strptr = ast_str_buffer(str); *strptr; strptr++) {
      /* buf is already a mutable buffer, so we construct the result
       * directly there */
      if (strchr(find, *strptr)) {
         if (ast_strlen_zero(replace)) {
            memmove(strptr, strptr + 1, strlen(strptr + 1) + 1);
            strptr--;
         } else {
            /* Replace character */
            *strptr = *replace;
         }
      }
   }

   ast_str_set(buf, len, "%s", ast_str_buffer(str));
   return 0;
}

static int shift_pop	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	len
	)			[static]

Definition at line 1421 of file func_strings.c.

References args, ast_alloca, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_get_encoded_char(), ast_log(), AST_STANDARD_APP_ARGS, ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_str_substitute_variables(), ast_str_thread_get(), ast_strlen_zero(), beginning, LOG_WARNING, pbx_builtin_setvar_helper(), result_buf, and var.

{
#define beginning (cmd[0] == 'S') /* SHIFT */
   char *after, delimiter[2] = ",", *varsubst;
   size_t unused;
   struct ast_str *before = ast_str_thread_get(&result_buf, 16);
   char *(*search_func)(const char *s, int c) = (beginning ? strchr : strrchr);
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(var);
      AST_APP_ARG(delimiter);
   );

   if (!before) {
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, data);

   if (ast_strlen_zero(args.var)) {
      ast_log(LOG_WARNING, "%s requires a variable name\n", cmd);
      return -1;
   }

   varsubst = ast_alloca(strlen(args.var) + 4);
   sprintf(varsubst, "${%s}", args.var);
   ast_str_substitute_variables(&before, 0, chan, varsubst);

   if (args.argc > 1 && !ast_strlen_zero(args.delimiter)) {
      ast_get_encoded_char(args.delimiter, delimiter, &unused);
   }

   if (!ast_str_strlen(before)) {
      /* Nothing to pop */
      return -1;
   }

   if (!(after = search_func(ast_str_buffer(before), delimiter[0]))) {
      /* Only one entry in array */
      ast_str_set(buf, len, "%s", ast_str_buffer(before));
      pbx_builtin_setvar_helper(chan, args.var, "");
   } else {
      *after++ = '\0';
      ast_str_set(buf, len, "%s", beginning ? ast_str_buffer(before) : after);
      pbx_builtin_setvar_helper(chan, args.var, beginning ? after : ast_str_buffer(before));
   }

   return 0;
#undef beginning
}

static int string_tolower	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1392 of file func_strings.c.

{
   char *bufptr = buf, *dataptr = data;

   while ((bufptr < buf + buflen - 1) && (*bufptr++ = tolower(*dataptr++)));

   return 0;
}

static int string_tolower2	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	buflen
	)			[static]

Definition at line 1401 of file func_strings.c.

References ast_str_buffer(), ast_str_make_space(), ast_str_size(), and ast_str_update().

{
   char *bufptr, *dataptr = data;

   if (buflen > -1) {
      ast_str_make_space(buf, buflen > 0 ? buflen : strlen(data) + 1);
   }
   bufptr = ast_str_buffer(*buf);
   while ((bufptr < ast_str_buffer(*buf) + ast_str_size(*buf) - 1) && (*bufptr++ = tolower(*dataptr++)));
   ast_str_update(*buf);

   return 0;
}

static int string_toupper	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 1363 of file func_strings.c.

{
   char *bufptr = buf, *dataptr = data;

   while ((bufptr < buf + buflen - 1) && (*bufptr++ = toupper(*dataptr++)));

   return 0;
}

static int string_toupper2	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		struct ast_str **	buf,
		ssize_t	buflen
	)			[static]

Definition at line 1372 of file func_strings.c.

References ast_str_buffer(), ast_str_make_space(), ast_str_size(), and ast_str_update().

{
   char *bufptr, *dataptr = data;

   if (buflen > -1) {
      ast_str_make_space(buf, buflen > 0 ? buflen : strlen(data) + 1);
   }
   bufptr = ast_str_buffer(*buf);
   while ((bufptr < ast_str_buffer(*buf) + ast_str_size(*buf) - 1) && (*bufptr++ = toupper(*dataptr++)));
   ast_str_update(*buf);

   return 0;
}

static int unload_module

(

void

)

[static]

Definition at line 1727 of file func_strings.c.

References ast_custom_function_unregister(), AST_TEST_UNREGISTER, and ast_unregister_application().

{
   int res = 0;

   AST_TEST_UNREGISTER(test_FIELDNUM);
   AST_TEST_UNREGISTER(test_REPLACE);
   AST_TEST_UNREGISTER(test_FILTER);
   res |= ast_custom_function_unregister(&fieldqty_function);
   res |= ast_custom_function_unregister(&fieldnum_function);
   res |= ast_custom_function_unregister(&filter_function);
   res |= ast_custom_function_unregister(&replace_function);
   res |= ast_custom_function_unregister(&listfilter_function);
   res |= ast_custom_function_unregister(&regex_function);
   res |= ast_custom_function_unregister(&array_function);
   res |= ast_custom_function_unregister(&quote_function);
   res |= ast_custom_function_unregister(&csv_quote_function);
   res |= ast_custom_function_unregister(&len_function);
   res |= ast_custom_function_unregister(&strftime_function);
   res |= ast_custom_function_unregister(&strptime_function);
   res |= ast_custom_function_unregister(&eval_function);
   res |= ast_custom_function_unregister(&keypadhash_function);
   res |= ast_custom_function_unregister(&hashkeys_function);
   res |= ast_custom_function_unregister(&hash_function);
   res |= ast_unregister_application(app_clearhash);
   res |= ast_custom_function_unregister(&toupper_function);
   res |= ast_custom_function_unregister(&tolower_function);
   res |= ast_custom_function_unregister(&shift_function);
   res |= ast_custom_function_unregister(&pop_function);
   res |= ast_custom_function_unregister(&push_function);
   res |= ast_custom_function_unregister(&unshift_function);
   res |= ast_custom_function_unregister(&passthru_function);

   return res;
}

static int unshift_push	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		const char *	new_value
	)			[static]

Definition at line 1481 of file func_strings.c.

References args, ast_alloca, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_get_encoded_char(), ast_log(), AST_STANDARD_APP_ARGS, ast_str_buffer(), ast_str_set(), ast_str_strlen(), ast_str_substitute_variables(), ast_str_thread_get(), ast_strlen_zero(), beginning, LOG_WARNING, pbx_builtin_setvar_helper(), result_buf, and var.

{
#define beginning (cmd[0] == 'U') /* UNSHIFT */
   char delimiter[2] = ",", *varsubst;
   size_t unused;
   struct ast_str *buf, *previous_value;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(var);
      AST_APP_ARG(delimiter);
   );

   if (!(buf = ast_str_thread_get(&result_buf, 16)) ||
      !(previous_value = ast_str_thread_get(&tmp_buf, 16))) {
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, data);

   if (ast_strlen_zero(args.var)) {
      ast_log(LOG_WARNING, "%s requires a variable name\n", cmd);
      return -1;
   }

   if (args.argc > 1 && !ast_strlen_zero(args.delimiter)) {
      ast_get_encoded_char(args.delimiter, delimiter, &unused);
   }

   varsubst = ast_alloca(strlen(args.var) + 4);
   sprintf(varsubst, "${%s}", args.var);
   ast_str_substitute_variables(&previous_value, 0, chan, varsubst);

   if (!ast_str_strlen(previous_value)) {
      ast_str_set(&buf, 0, "%s", new_value);
   } else {
      ast_str_set(&buf, 0, "%s%c%s",
         beginning ? new_value : ast_str_buffer(previous_value),
         delimiter[0],
         beginning ? ast_str_buffer(previous_value) : new_value);
   }

   pbx_builtin_setvar_helper(chan, args.var, ast_str_buffer(buf));

   return 0;
#undef beginning
}

---

Variable Documentation

char* app_clearhash = "ClearHash" [static]

Definition at line 889 of file func_strings.c.

struct ast_custom_function array_function [static]

Initial value:

 {
   .name = "ARRAY",
   .write = array,
}

Definition at line 1118 of file func_strings.c.

struct ast_custom_function csv_quote_function [static]

Initial value:

 {
   .name = "CSV_QUOTE",
   .read = csv_quote,
}

Definition at line 1192 of file func_strings.c.

struct ast_custom_function eval_function [static]

Initial value:

 {
   .name = "EVAL",
   .read = function_eval,
   .read2 = function_eval2,
}

Definition at line 1317 of file func_strings.c.

struct ast_custom_function fieldnum_function [static]

Initial value:

 {
   .name = "FIELDNUM",
   .read = function_fieldnum,
   .read2 = function_fieldnum_str,
}

Definition at line 560 of file func_strings.c.

struct ast_custom_function fieldqty_function [static]

Initial value:

 {
   .name = "FIELDQTY",
   .read = function_fieldqty,
   .read2 = function_fieldqty_str,
}

Definition at line 481 of file func_strings.c.

struct ast_custom_function filter_function [static]

Initial value:

 {
   .name = "FILTER",
   .read = filter,
}

Definition at line 770 of file func_strings.c.

struct ast_custom_function hash_function [static]

Initial value:

 {
   .name = "HASH",
   .write = hash_write,
   .read = hash_read,
}

Definition at line 1106 of file func_strings.c.

struct ast_custom_function hashkeys_function [static]

Initial value:

 {
   .name = "HASHKEYS",
   .read = hashkeys_read,
   .read2 = hashkeys_read2,
}

Definition at line 1112 of file func_strings.c.

struct ast_custom_function keypadhash_function [static]

Initial value:

 {
   .name = "KEYPADHASH",
   .read = keypadhash,
}

Definition at line 1358 of file func_strings.c.

struct ast_custom_function len_function [static]

Initial value:

 {
   .name = "LEN",
   .read = len,
   .read_max = 12,
}

Definition at line 1209 of file func_strings.c.

struct ast_custom_function listfilter_function [static]

Initial value:

 {
   .name = "LISTFILTER",
   .read = listfilter_read,
   .read2 = listfilter_read2,
}

Definition at line 688 of file func_strings.c.

struct ast_custom_function passthru_function [static]

Initial value:

 {
   .name = "PASSTHRU",
   .read2 = passthru,
}

Definition at line 1543 of file func_strings.c.

struct ast_custom_function pop_function [static]

Initial value:

 {
   .name = "POP",
   .read2 = shift_pop,
}

Definition at line 1476 of file func_strings.c.

struct ast_custom_function push_function [static]

Initial value:

 {
   .name = "PUSH",
   .write = unshift_push,
}

Definition at line 1527 of file func_strings.c.

struct ast_custom_function quote_function [static]

Initial value:

 {
   .name = "QUOTE",
   .read = quote,
}

Definition at line 1157 of file func_strings.c.

struct ast_custom_function regex_function [static]

Initial value:

 {
   .name = "REGEX",
   .read = regex,
}

Definition at line 881 of file func_strings.c.

struct ast_custom_function replace_function [static]

Initial value:

 {
   .name = "REPLACE",
   .read2 = replace,
}

Definition at line 839 of file func_strings.c.

struct ast_custom_function shift_function [static]

Initial value:

 {
   .name = "SHIFT",
   .read2 = shift_pop,
}

Definition at line 1471 of file func_strings.c.

struct ast_custom_function strftime_function [static]

Initial value:

 {
   .name = "STRFTIME",
   .read = acf_strftime,
}

Definition at line 1244 of file func_strings.c.

struct ast_custom_function strptime_function [static]

Initial value:

 {
   .name = "STRPTIME",
   .read = acf_strptime,
}

Definition at line 1286 of file func_strings.c.

struct ast_custom_function tolower_function [static]

Initial value:

 {
   .name = "TOLOWER",
   .read = string_tolower,
   .read2 = string_tolower2,
}

Definition at line 1415 of file func_strings.c.

struct ast_custom_function toupper_function [static]

Initial value:

 {
   .name = "TOUPPER",
   .read = string_toupper,
   .read2 = string_toupper2,
}

Definition at line 1386 of file func_strings.c.

struct ast_custom_function unshift_function [static]

Initial value:

 {
   .name = "UNSHIFT",
   .write = unshift_push,
}

Definition at line 1532 of file func_strings.c.