func_strings.c

	return 0;
}

static int function_eval2(struct ast_channel *chan, const char *cmd, char *data,
			 struct ast_str **buf, ssize_t buflen)
{
	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 struct ast_custom_function eval_function = {
	.name = "EVAL",
	.read = function_eval,
	.read2 = function_eval2,
};

static int keypadhash(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
{
	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 struct ast_custom_function keypadhash_function = {
	.name = "KEYPADHASH",
	.read = keypadhash,
};

static int string_toupper(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
{
	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)
{
	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 struct ast_custom_function toupper_function = {
	.name = "TOUPPER",
	.read = string_toupper,
	.read2 = string_toupper2,
};

static int string_tolower(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
{
	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)
{
	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 struct ast_custom_function tolower_function = {
	.name = "TOLOWER",
	.read = string_tolower,
	.read2 = string_tolower2,
};

static int array_remove(struct ast_channel *chan, const char *cmd, char *var, char *buf, size_t len, int beginning)
{
	const char *tmp;
	char *after, *before;
	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 (!chan) {
		ast_log(LOG_WARNING, "%s requires a channel\n", cmd);
		return -1;
	}

	AST_STANDARD_APP_ARGS(args, var);

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

	if (args.delimiter && strlen(args.delimiter) != 1) {
		ast_log(LOG_WARNING, "%s delimeters should be a single character\n", cmd);
		return -1;
	}

	ast_channel_lock(chan);
	if (ast_strlen_zero(tmp = pbx_builtin_getvar_helper(chan, args.var))) {
		ast_channel_unlock(chan);
		return 0;
	}

	before = ast_strdupa(tmp);
	ast_channel_unlock(chan);

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

	return 0;

}

static int shift(struct ast_channel *chan, const char *cmd, char *var, char *buf, size_t len)
{
	return array_remove(chan, cmd, var, buf, len, 1);
}
static struct ast_custom_function shift_function = {
	.name = "SHIFT",
	.read = shift,
};

static int pop(struct ast_channel *chan, const char *cmd, char *var, char *buf, size_t len)
{
	return array_remove(chan, cmd, var, buf, len, 0);
}

static struct ast_custom_function pop_function = {
	.name = "POP",
	.read = pop,
};

static int array_insert(struct ast_channel *chan, const char *cmd, char *var, const char *val, int beginning)
{
	const char *tmp;
	struct ast_str *buf;
	AST_DECLARE_APP_ARGS(args,
		AST_APP_ARG(var);
		AST_APP_ARG(delimiter);
	);

	if (!chan) {
		ast_log(LOG_WARNING, "%s requires a channel\n", cmd);
		return -1;
	}

	AST_STANDARD_APP_ARGS(args, var);

	if (ast_strlen_zero(args.var) || ast_strlen_zero(val)) {
		ast_log(LOG_WARNING, "%s requires a variable, and at least one value\n", cmd);
		return -1;
	}

	if (args.delimiter && strlen(args.delimiter) != 1) {
		ast_log(LOG_WARNING, "%s delimeters should be a single character\n", cmd);
		return -1;
	}

	if (!(buf = ast_str_create(32))) {
		ast_log(LOG_ERROR, "Unable to allocate memory for buffer!\n");
		return -1;
	}

	ast_channel_lock(chan);
	if (!(tmp = pbx_builtin_getvar_helper(chan, args.var))) {
		ast_str_set(&buf, 0, "%s", val);
	} else {
		ast_str_append(&buf, 0, "%s%s%s", beginning ? val : tmp, S_OR(args.delimiter, ","), beginning ? tmp : val);
	}
	ast_channel_unlock(chan);

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

	return 0;
}

static int push(struct ast_channel *chan, const char *cmd, char *var, const char *val)
{
	return array_insert(chan, cmd, var, val, 0);
}

static struct ast_custom_function push_function = {
	.name = "PUSH",
	.write = push,
};

static int unshift(struct ast_channel *chan, const char *cmd, char *var, const char *val)
{
	return array_insert(chan, cmd, var, val, 1);
}

static struct ast_custom_function unshift_function = {
	.name = "UNSHIFT",
	.write = unshift,
};

static int unload_module(void)
{
	int res = 0;

	res |= ast_custom_function_unregister(&fieldqty_function);
	res |= ast_custom_function_unregister(&filter_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(&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);

	return res;
}

static int load_module(void)
{
	int res = 0;

	res |= ast_custom_function_register(&fieldqty_function);
	res |= ast_custom_function_register(&filter_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(&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);

	return res;
}

AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "String handling dialplan functions");