strings.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2008, Digium, Inc.
 *
 * Tilghman Lesher <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief String manipulation API
 *
 * \author Tilghman Lesher <[email protected]>
 */

/*** MAKEOPTS
<category name="MENUSELECT_CFLAGS" displayname="Compiler Flags" positive_output="yes">
 <member name="DEBUG_OPAQUE" displayname="Change ast_str internals to detect improper usage" touch_on_change="include/asterisk/strings.h">
 <defaultenabled>yes</defaultenabled>
 </member>
</category>
 ***/

/*** MODULEINFO
 <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include <regex.h>
#include "asterisk/strings.h"
#include "asterisk/pbx.h"
#include "asterisk/vector.h"

/*!
 * core handler for dynamic strings.
 * This is not meant to be called directly, but rather through the
 * various wrapper macros
 * ast_str_set(...)
 * ast_str_append(...)
 * ast_str_set_va(...)
 * ast_str_append_va(...)
 */

int __ast_str_helper(struct ast_str **buf, ssize_t max_len,
 int append, const char *fmt, va_list ap,
 const char *file, int lineno, const char *function)
{
 int res;
 int added;
 int need;
 int offset = (append && (*buf)->__AST_STR_LEN) ? (*buf)->__AST_STR_USED : 0;
 va_list aq;

 if (max_len < 0) {
 max_len = (*buf)->__AST_STR_LEN; /* don't exceed the allocated space */
 }

 do {
 va_copy(aq, ap);
 res = vsnprintf((*buf)->__AST_STR_STR + offset, (*buf)->__AST_STR_LEN - offset, fmt, aq);
 va_end(aq);

 if (res < 0) {
 /*
 * vsnprintf write to string failed.
 * I don't think this is possible with a memory buffer.
 */
 res = AST_DYNSTR_BUILD_FAILED;
 added = 0;
 break;
 }

 /*
 * vsnprintf returns how much space we used or would need.
 * Remember that vsnprintf does not count the nil terminator
 * so we must add 1.
 */
 added = res;
 need = offset + added + 1;
 if (need <= (*buf)->__AST_STR_LEN
 || (max_len && max_len <= (*buf)->__AST_STR_LEN)) {
 /*
 * There was enough room for the string or we are not
 * allowed to try growing the string buffer.
 */
 break;
 }

 /* Reallocate the buffer and try again. */
 if (max_len == 0) {
 /* unbounded, give more room for next time */
 need += 16 + need / 4;
 } else if (max_len < need) {
 /* truncate as needed */
 need = max_len;
 }

 if (_ast_str_make_space(buf, need, file, lineno, function)) {
 ast_log_safe(LOG_VERBOSE, "failed to extend from %d to %d\n",
 (int) (*buf)->__AST_STR_LEN, need);

 res = AST_DYNSTR_BUILD_FAILED;
 break;
 }
 } while (1);

 /* Update space used, keep in mind truncation may be necessary. */
 (*buf)->__AST_STR_USED = ((*buf)->__AST_STR_LEN <= offset + added)
 ? (*buf)->__AST_STR_LEN - 1
 : offset + added;

 /* Ensure that the string is terminated. */
 (*buf)->__AST_STR_STR[(*buf)->__AST_STR_USED] = '\0';

 return res;
}

char *__ast_str_helper2(struct ast_str **buf, ssize_t maxlen, const char *src, size_t maxsrc, int append, int escapecommas)
{
 int dynamic = 0;
 char *ptr = append ? &((*buf)->__AST_STR_STR[(*buf)->__AST_STR_USED]) : (*buf)->__AST_STR_STR;

 if (maxlen < 1) {
 if (maxlen == 0) {
 dynamic = 1;
 }
 maxlen = (*buf)->__AST_STR_LEN;
 }

 while (*src && maxsrc && maxlen && (!escapecommas || (maxlen - 1))) {
 if (escapecommas && (*src == '\\' || *src == ',')) {
 *ptr++ = '\\';
 maxlen--;
 (*buf)->__AST_STR_USED++;
 }
 *ptr++ = *src++;
 maxsrc--;
 maxlen--;
 (*buf)->__AST_STR_USED++;

 if ((ptr >= (*buf)->__AST_STR_STR + (*buf)->__AST_STR_LEN - 3) ||
 (dynamic && (!maxlen || (escapecommas && !(maxlen - 1))))) {
 char *oldbase = (*buf)->__AST_STR_STR;
 size_t old = (*buf)->__AST_STR_LEN;
 if (ast_str_make_space(buf, (*buf)->__AST_STR_LEN * 2)) {
 /* If the buffer can't be extended, end it. */
 break;
 }
 /* What we extended the buffer by */
 maxlen = old;

 ptr += (*buf)->__AST_STR_STR - oldbase;
 }
 }
 if (__builtin_expect(!maxlen, 0)) {
 ptr--;
 }
 *ptr = '\0';
 return (*buf)->__AST_STR_STR;
}

static int str_hash(const void *obj, const int flags)
{
 return ast_str_hash(obj);
}

static int str_sort(const void *lhs, const void *rhs, int flags)
{
 if ((flags & OBJ_SEARCH_MASK) == OBJ_SEARCH_PARTIAL_KEY) {
 return strncmp(lhs, rhs, strlen(rhs));
 } else {
 return strcmp(lhs, rhs);
 }
}

static int str_cmp(void *lhs, void *rhs, int flags)
{
 int cmp = 0;

 if ((flags & OBJ_SEARCH_MASK) == OBJ_SEARCH_PARTIAL_KEY) {
 cmp = strncmp(lhs, rhs, strlen(rhs));
 } else {
 cmp = strcmp(lhs, rhs);
 }

 return cmp ? 0 : CMP_MATCH;
}

//struct ao2_container *ast_str_container_alloc_options(enum ao2_container_opts opts, int buckets)
struct ao2_container *ast_str_container_alloc_options(enum ao2_alloc_opts opts, int buckets)
{
 return ao2_container_alloc_hash(opts, 0, buckets, str_hash, str_sort, str_cmp);
}

int ast_str_container_add(struct ao2_container *str_container, const char *add)
{
 char *ao2_add;

 /* The ao2_add object is immutable so it doesn't need a lock of its own. */
 ao2_add = ao2_alloc_options(strlen(add) + 1, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
 if (!ao2_add) {
 return -1;
 }
 strcpy(ao2_add, add);/* Safe */

 ao2_link(str_container, ao2_add);
 ao2_ref(ao2_add, -1);
 return 0;
}

void ast_str_container_remove(struct ao2_container *str_container, const char *remove)
{
 ao2_find(str_container, remove, OBJ_SEARCH_KEY | OBJ_NODATA | OBJ_UNLINK);
}

char *ast_generate_random_string(char *buf, size_t size)
{
 int i;

 for (i = 0; i < size - 1; ++i) {
 buf[i] = 'a' + (ast_random() % 26);
 }
 buf[i] = '\0';

 return buf;
}

int ast_strings_equal(const char *str1, const char *str2)
{
 if (!str1 || !str2) {
 return 0;
 }

 return str1 == str2 || !strcmp(str1, str2);
}

int ast_strings_match(const char *left, const char *op, const char *right)
{
 char *internal_op = (char *)op;
 char *internal_right = (char *)right;
 double left_num;
 double right_num;
 int scan_numeric = 0;

 if (!(left && right)) {
 return 0;
 }

 if (ast_strlen_zero(op)) {
 if (ast_strlen_zero(left) && ast_strlen_zero(right)) {
 return 1;
 }

 if (strlen(right) >= 2 && right[0] == '/' && right[strlen(right) - 1] == '/') {
 internal_op = "regex";
 internal_right = ast_strdupa(right);
 /* strip the leading and trailing '/' */
 internal_right++;
 internal_right[strlen(internal_right) - 1] = '\0';
 goto regex;
 } else {
 internal_op = "=";
 goto equals;
 }
 }

 if (!strcasecmp(op, "like")) {
 char *tok;
 struct ast_str *buffer = ast_str_alloca(128);

 if (!strchr(right, '%')) {
 return !strcmp(left, right);
 } else {
 internal_op = "regex";
 internal_right = ast_strdupa(right);
 tok = strsep(&internal_right, "%");
 ast_str_set(&buffer, 0, "^%s", tok);

 while ((tok = strsep(&internal_right, "%"))) {
 ast_str_append(&buffer, 0, ".*%s", tok);
 }
 ast_str_append(&buffer, 0, "%s", "$");

 internal_right = ast_str_buffer(buffer);
 /* fall through to regex */
 }
 }

regex:
 if (!strcasecmp(internal_op, "regex")) {
 regex_t expression;
 int rc;

 if (regcomp(&expression, internal_right, REG_EXTENDED | REG_NOSUB)) {
 return 0;
 }

 rc = regexec(&expression, left, 0, NULL, 0);
 regfree(&expression);
 return !rc;
 }

equals:
 scan_numeric = (sscanf(left, "%lf", &left_num) > 0 && sscanf(internal_right, "%lf", &right_num) > 0);

 if (internal_op[0] == '=') {
 if (ast_strlen_zero(left) && ast_strlen_zero(internal_right)) {
 return 1;
 }

 if (scan_numeric) {
 return (left_num == right_num);
 } else {
 return (!strcmp(left, internal_right));
 }
 }

 if (internal_op[0] == '!' && internal_op[1] == '=') {
 if (scan_numeric) {
 return (left_num != right_num);
 } else {
 return !!strcmp(left, internal_right);
 }
 }

 if (internal_op[0] == '<') {
 if (scan_numeric) {
 if (internal_op[1] == '=') {
 return (left_num <= right_num);
 } else {
 return (left_num < right_num);
 }
 } else {
 if (internal_op[1] == '=') {
 return strcmp(left, internal_right) <= 0;
 } else {
 return strcmp(left, internal_right) < 0;
 }
 }
 }

 if (internal_op[0] == '>') {
 if (scan_numeric) {
 if (internal_op[1] == '=') {
 return (left_num >= right_num);
 } else {
 return (left_num > right_num);
 }
 } else {
 if (internal_op[1] == '=') {
 return strcmp(left, internal_right) >= 0;
 } else {
 return strcmp(left, internal_right) > 0;
 }
 }
 }

 return 0;
}

char *ast_read_line_from_buffer(char **buffer)
{
 char *start = *buffer;

 if (!buffer || !*buffer || *(*buffer) == '\0') {
 return NULL;
 }

 while (*(*buffer) && *(*buffer) != '\n' ) {
 (*buffer)++;
 }

 *(*buffer) = '\0';
 if (*(*buffer - 1) == '\r') {
 *(*buffer - 1) = '\0';
 }
 (*buffer)++;

 return start;
}

int ast_vector_string_split(struct ast_vector_string *dest,
 const char *input, const char *delim, int flags,
 int (*excludes_cmp)(const char *s1, const char *s2))
{
 char *buf;
 char *cur;
 int no_trim = flags & AST_VECTOR_STRING_SPLIT_NO_TRIM;
 int allow_empty = flags & AST_VECTOR_STRING_SPLIT_ALLOW_EMPTY;

 ast_assert(dest != NULL);
 ast_assert(!ast_strlen_zero(delim));

 if (ast_strlen_zero(input)) {
 return 0;
 }

 buf = ast_strdupa(input);
 while ((cur = strsep(&buf, delim))) {
 if (!no_trim) {
 cur = ast_strip(cur);
 }

 if (!allow_empty && ast_strlen_zero(cur)) {
 continue;
 }

 if (excludes_cmp && AST_VECTOR_GET_CMP(dest, cur, !excludes_cmp)) {
 continue;
 }

 cur = ast_strdup(cur);
 if (!cur || AST_VECTOR_APPEND(dest, cur)) {
 ast_free(cur);

 return -1;
 }
 }

 return 0;
}