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] == 'S')
#define	beginning (cmd[0] == 'U')
#define	HASH_FORMAT HASH_PREFIX "%s~"
#define	HASH_PREFIX "~HASH~%s~"
Functions
static void	__init_result_buf (void)
static void	__init_tmp_buf (void)
static void	__reg_module (void)
static void	__unreg_module (void)
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)
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 struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "String handling dialplan functions" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "7a1b8b48c852d7a7061c7e499b9bd0d2" , .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, }
static char *	app_clearhash = "ClearHash"
static struct ast_custom_function	array_function
static struct ast_module_info *	ast_module_info = &__mod_info
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_threadstorage	result_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_result_buf , .custom_init = NULL , }
static struct ast_custom_function	shift_function
static struct ast_custom_function	strftime_function
static struct ast_custom_function	strptime_function
static struct ast_threadstorage	tmp_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_tmp_buf , .custom_init = NULL , }
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] == 'S')

Referenced by shift_pop(), and unshift_push().

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

#define HASH_FORMAT HASH_PREFIX "%s~"

Definition at line 881 of file func_strings.c.

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

#define HASH_PREFIX "~HASH~%s~"

Definition at line 880 of file func_strings.c.

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

Function Documentation

static void __init_result_buf ( void ) [static]

Definition at line 43 of file func_strings.c.

static void __init_tmp_buf ( void ) [static]

Definition at line 44 of file func_strings.c.

static void __reg_module ( void ) [static]

Definition at line 1712 of file func_strings.c.

static void __unreg_module ( void ) [static]

Definition at line 1712 of file func_strings.c.

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

Definition at line 1208 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 1242 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 907 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(), S_OR, and var.

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;

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

   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;
}

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

Definition at line 886 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(), ast_var_t::entries, 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 1155 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");
      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 899 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 687 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(), data_result_generate_node(), 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 1284 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 1297 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 540 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 479 of file func_strings.c.

References args, 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, str, and strsep().

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 = 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 546 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 461 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 416 of file func_strings.c.

References args, 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, str, and strsep().

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 = 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 467 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 1053 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 1025 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 981 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 1002 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 1316 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 1190 of file func_strings.c.

Referenced by __analog_ss_thread(), __ast_cli_register(), __ast_dsp_call_progress(), __ast_dsp_silence_noise(), __ast_str_helper(), __get_header(), __rtp_recvfrom(), __rtp_sendto(), __sip_reliable_xmit(), _parse(), _sip_tcp_helper_thread(), acf_escape(), add_sdp(), adsi_careful_send(), ael_token_subst(), aji_io_recv(), aji_recv(), aji_send_header(), aji_send_raw(), aji_start_sasl(), alsa_write(), amdf_pitch(), analog_ss_thread(), anti_injection(), 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_app_options2str64(), ast_callerid_vmwi_generate(), ast_cdr_appenduserfield(), ast_cli_complete(), ast_cli_register_multiple(), ast_cli_unregister_multiple(), 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_join(), ast_mkdir(), ast_pri_pack_hex_string(), ast_read_image(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_read(), ast_say_number_full_ka(), ast_smoother_read(), ast_srtp_protect(), ast_srtp_unprotect(), ast_str_buffer(), ast_str_substitute_variables_full(), ast_tdd_gen_ecdisa(), ast_translate(), ast_udptl_write(), ast_xmldoc_printable(), auth_exec(), authenticate(), build_device(), build_facility(), build_route(), builtin_automixmonitor(), builtin_automonitor(), calc_energy(), callerid_feed(), callerid_feed_jp(), callerid_generate(), cleaned_basedn(), clearvar_prefix(), cli_console_sendtext(), complete_agent_logoff_cmd(), 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(), complete_peer_helper(), complete_trans_path_choice(), conf_play(), config_jitterbuffer(), cops_getmsg(), copy(), create_video_frame(), dahdi_sendtext(), dahdi_setoption(), decimals2int(), decode_length(), decode_open_type(), devstate_write(), dialgroup_refreshdb(), dictate_exec(), do_pktccops(), do_tone(), dump_prefs(), dump_raw(), dump_string(), dundi_encrypt(), dundi_parse_ies(), dundi_send(), enc_ie_facility(), encode_length(), evt_event_deliver_cb(), expr2_token_subst(), fax_generator_generate(), fbuf_append(), fetch_response_reader(), ffmpeg_decode(), find_by_part(), flip_buf_bits(), fsk_serial(), gen_tone(), gen_tones(), 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_output(), handle_response(), handle_show_sysinfo(), handle_subscribe(), help1(), iax_parse_ies(), iax_str2flags(), iconv_read(), jpeg_read_image(), launch_monitor_thread(), listener(), load_file(), local_call(), lpc10tolin_framein(), lws2sws(), make_tone_burst(), manager_rpt_status(), memcpy_decrypt(), memcpy_encrypt(), message_template_parse_emailbody(), method_match(), mgcp_postrequest(), mgcp_ss(), mgcpsock_read(), milliwatt_generate(), misdn_jb_empty(), misdn_jb_fill(), misdn_lib_tx2misdn_frm(), misdn_read(), misdn_tx_jitter(), monmp3thread(), mpeg4_encap(), my_dahdi_write(), newpvt(), ogg_vorbis_read(), parse_ie(), ParseBookmark(), pbx_load_users(), pbx_substitute_variables_helper_full(), phone_write_buf(), phoneprov_callback(), playtones_generator(), plc_fillin(), plc_rx(), pp_each_extension_helper(), pp_each_user_helper(), pri_ss_thread(), process_sdp(), read_credentials(), readfile_exec(), red_t140_to_red(), reschedule_precache(), run_agi(), save_history(), scan_thread(), schedule_delivery(), send_morse(), set(), set_egress_subscription(), sig_pri_set_subaddress(), sip_addheader(), sip_show_channel(), sip_show_history(), sip_tcptls_write(), skinny_ss(), sms_messagetx(), socket_process_meta(), socket_read(), ssl_write(), static_callback(), strnncpy(), tdd_feed(), term_filter_escapes(), tonepair_generator(), transfer_exec(), try_firmware(), udptl_build_packet(), unistim_sp(), unquote(), wav_write(), xmldoc_get_syntax_fun(), and xmldoc_setpostbr().

{
   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 558 of file func_strings.c.

References args, 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, result_buf, and tmp_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);
   );
   const char *ptr;
   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 = 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 (!(ptr = 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 = 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 671 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 676 of file func_strings.c.

References listfilter().

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

static int load_module ( void ) [static]

Definition at line 1678 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_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 1530 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 1116 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");
      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 838 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 768 of file func_strings.c.

References args, 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 = 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)) {
            /* Remove character */
            strcpy(strptr, strptr + 1); /* SAFE */
            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 1414 of file func_strings.c.

References args, 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 = 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 1385 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 1394 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 1356 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 1365 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 1644 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_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 1474 of file func_strings.c.

References args, 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, tmp_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 = 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

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "String handling dialplan functions" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "7a1b8b48c852d7a7061c7e499b9bd0d2" , .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, } [static]

Definition at line 1712 of file func_strings.c.

char* app_clearhash = "ClearHash" [static]

Definition at line 883 of file func_strings.c.

struct ast_custom_function array_function [static]

Initial value:

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

Definition at line 1111 of file func_strings.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 1712 of file func_strings.c.

struct ast_custom_function csv_quote_function [static]

Initial value:

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

Definition at line 1185 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 1310 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 552 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 473 of file func_strings.c.

struct ast_custom_function filter_function [static]

Initial value:

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

Definition at line 763 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 1099 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 1105 of file func_strings.c.

struct ast_custom_function keypadhash_function [static]

Initial value:

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

Definition at line 1351 of file func_strings.c.

struct ast_custom_function len_function [static]

Initial value:

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

Definition at line 1202 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 681 of file func_strings.c.

struct ast_custom_function passthru_function [static]

Initial value:

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

Definition at line 1536 of file func_strings.c.

struct ast_custom_function pop_function [static]

Initial value:

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

Definition at line 1469 of file func_strings.c.

struct ast_custom_function push_function [static]

Initial value:

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

Definition at line 1520 of file func_strings.c.

struct ast_custom_function quote_function [static]

Initial value:

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

Definition at line 1150 of file func_strings.c.

struct ast_custom_function regex_function [static]

Initial value:

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

Definition at line 875 of file func_strings.c.

struct ast_custom_function replace_function [static]

Initial value:

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

Definition at line 833 of file func_strings.c.

struct ast_threadstorage result_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_result_buf , .custom_init = NULL , } [static]

Definition at line 43 of file func_strings.c.

Referenced by function_fieldnum_helper(), function_fieldqty_helper(), listfilter(), replace(), shift_pop(), and unshift_push().

struct ast_custom_function shift_function [static]

Initial value:

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

Definition at line 1464 of file func_strings.c.

struct ast_custom_function strftime_function [static]

Initial value:

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

Definition at line 1237 of file func_strings.c.

struct ast_custom_function strptime_function [static]

Initial value:

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

Definition at line 1279 of file func_strings.c.

struct ast_threadstorage tmp_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_tmp_buf , .custom_init = NULL , } [static]

Definition at line 44 of file func_strings.c.

Referenced by listfilter(), and unshift_push().

struct ast_custom_function tolower_function [static]

Initial value:

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

Definition at line 1408 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 1379 of file func_strings.c.

struct ast_custom_function unshift_function [static]

Initial value:

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

Definition at line 1525 of file func_strings.c.

Asterisk developer's documentation

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation