strings.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2008, Digium, Inc.
 *
 * Tilghman Lesher <tlesher@digium.com>
 *
 * 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 <tilghman@digium.com>
 */
 
/*** 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_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);
}
 
static int parse_double(const char *input, double *result)
{
    char *endptr;
 
    errno = 0;
    *result = strtod(input, &endptr);
    if (*endptr || errno == ERANGE) {
        return 0;
    }
 
    return 1;
}
 
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 = parse_double(left, &left_num)
        && parse_double(internal_right, &right_num);
 
    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;
}
 
int ast_in_delimited_string(const char *needle, const char *haystack, char delim)
{
    const char *end;
    unsigned long needle_size;
 
    ast_assert(haystack != NULL);
 
    if (!needle) {
        return 0;
    }
 
    needle_size = strlen(needle);
    haystack = ast_skip_blanks(haystack);
 
    while ((end = strchr(haystack, delim))) {
        if (needle_size == end - haystack && !strncmp(haystack, needle, needle_size)) {
            return 1;
        }
        haystack = ast_skip_blanks(end + 1);
    }
 
    return strcmp(haystack, needle) ? 0 : -1;
}