logger_category.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2020, Sangoma Technologies Corporation
 *
 * Kevin Harwell <kharwell@sangoma.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.
 */
 
#include "asterisk.h"
 
#include "asterisk/cli.h"
#include "asterisk/conversions.h"
#include "asterisk/logger_category.h"
#include "asterisk/vector.h"
 
struct category_t {
    int sublevel;
    uintmax_t id;
    char name[0];
};
 
AST_VECTOR_RW(categories_t, struct category_t *);
 
struct categories_level_t {
    int type;
    int sublevel;
    uintmax_t id_pool;
    uintmax_t state;
    struct categories_t categories;
};
 
/*! \brief Retrieve the next available id.
 *
 * Ids must be a power of 2. This allows for fast lookup, and "or'ing" of ids
 * in order to permit multiple categories in a log statement.
 */
static uintmax_t get_next_id(struct categories_level_t *level)
{
    if (level->id_pool == 0) {
        level->id_pool = 1;
    } else if (level->id_pool >= (UINTMAX_MAX / 2)) {
        /* No more ids left*/
        return 0;
    } else {
        level->id_pool <<= 1;
    }
 
    return level->id_pool;
}
 
static int cmp_by_name(const struct category_t *category, const char *name)
{
    return !strcmp(category->name, name);
}
 
static uintmax_t category_register(struct categories_level_t *level, const char *name)
{
    int i;
    struct category_t *category;
 
    AST_VECTOR_RW_WRLOCK(&level->categories);
 
    i = AST_VECTOR_GET_INDEX(&level->categories, name, cmp_by_name);
    if (i >= 0) {
        AST_VECTOR_RW_UNLOCK(&level->categories);
        ast_log(LOG_ERROR, "Cannot register logger category '%s'. "
                "Name already used for type.\n", name);
        return 0;
    }
 
    category = ast_calloc(1, sizeof(*category) + strlen(name) + 1);
    if (!category) {
        AST_VECTOR_RW_UNLOCK(&level->categories);
        return 0;
    }
 
    category->id = get_next_id(level);
    category->sublevel = AST_LOG_CATEGORY_DISABLED;
    strcpy(category->name, name); /* Safe */
 
    if (AST_VECTOR_APPEND(&level->categories, category)) {
        AST_VECTOR_RW_UNLOCK(&level->categories);
        ast_log(LOG_ERROR, "Cannot register logger category '%s'. "
                "Unable to append.\n", name);
        return 0;
    }
 
    AST_VECTOR_RW_UNLOCK(&level->categories);
    return category->id;
}
 
static int category_unregister(struct categories_level_t *level, const char *name)
{
    int res;
 
    AST_VECTOR_RW_WRLOCK(&level->categories);
    res = AST_VECTOR_REMOVE_CMP_UNORDERED(&level->categories, name, cmp_by_name, ast_free);
    AST_VECTOR_RW_UNLOCK(&level->categories);
 
    return res;
}
 
static int casecmp_by_name(const struct category_t *category, const char *name)
{
    return !strcasecmp(category->name, name);
}
 
static int category_set_sublevel(struct category_t *category, struct categories_level_t *level,
    const char *name, int sublevel)
{
    int locked = 0;
 
    if (!category) {
        struct category_t **obj;
 
        if (!name) {
            return -1;
        }
 
        locked = !AST_VECTOR_RW_WRLOCK(&level->categories);
        if (!locked) {
            return -1;
        }
 
        obj = AST_VECTOR_GET_CMP(&level->categories, name, casecmp_by_name);
        if (!obj) {
            AST_VECTOR_RW_UNLOCK(&level->categories);
            return -1;
        }
 
        category = *obj;
    }
 
    category->sublevel = sublevel;
 
    if (category->sublevel == AST_LOG_CATEGORY_DISABLED) {
        level->state &= ~category->id;
    } else {
        level->state |= category->id;
    }
 
    if (locked) {
        AST_VECTOR_RW_UNLOCK(&level->categories);
    }
 
    return 0;
}
 
static int category_set_sublevels(struct categories_level_t *level,
    const char * const *names, size_t size, int default_sublevel)
{
    int i;
 
    if (!names || !size) {
        level->state = default_sublevel;
        AST_VECTOR_RW_WRLOCK(&level->categories);
        AST_VECTOR_CALLBACK_VOID(&level->categories, category_set_sublevel,
            level, NULL, default_sublevel);
        AST_VECTOR_RW_UNLOCK(&level->categories);
        return 0;
    }
 
    for (i = 0; i < size; ++i) {
        const char *sublevel;
        int num = default_sublevel;
 
        sublevel = strchr(names[i], ':');
        if (sublevel) {
            size_t len = ++sublevel - names[i];
            char name[len];
 
            if (*sublevel && ast_str_to_int(sublevel, &num)) {
                continue;
            }
 
            ast_copy_string(name, names[i], len);
            category_set_sublevel(NULL, level, name, num);
        } else {
            category_set_sublevel(NULL, level, names[i], num);
        }
    }
 
    return 0;
}
 
static char *category_complete(struct categories_level_t *level, const char * const *argv,
    int argc, const char *word, int state)
{
    int wordlen = strlen(word);
    int which = 0;
    int i, j;
 
    AST_VECTOR_RW_RDLOCK(&level->categories);
 
    if (argc == AST_VECTOR_SIZE(&level->categories)) {
        AST_VECTOR_RW_UNLOCK(&level->categories);
        return NULL;
    }
 
    for (i = 0; i < AST_VECTOR_SIZE(&level->categories); ++i) {
        struct category_t *category = AST_VECTOR_GET(&level->categories, i);
 
        if (!strncasecmp(word, category->name, wordlen) && (++which > state)) {
            /* Check to see if one is already been included */
            for (j = 0; j < argc; ++j) {
                if (!strncasecmp(category->name, argv[j], strlen(category->name))) {
                    break;
                }
            }
 
            if (j != argc) {
                continue;
            }
 
            if (state != -1) {
                AST_VECTOR_RW_UNLOCK(&level->categories);
                return ast_strdup(category->name);
            }
 
            if (ast_cli_completion_add(ast_strdup(category->name))) {
                AST_VECTOR_RW_UNLOCK(&level->categories);
                return NULL;
            }
        }
    }
 
    AST_VECTOR_RW_UNLOCK(&level->categories);
    return NULL;
}
 
static int category_is_allowed(int sublevel, struct categories_level_t *level, uintmax_t ids)
{
    /* Check level, and potentially allow but only if there is a matching state enabled */
    if (ids & level->state) {
        int i;
 
        if (sublevel == AST_LOG_CATEGORY_ENABLED || sublevel == 0) {
            /* If at least one id is enabled then always allow these sublevels */
            return 1;
        }
 
        AST_VECTOR_RW_RDLOCK(&level->categories);
        for (i = 0; i < AST_VECTOR_SIZE(&level->categories); ++i) {
            struct category_t *category = AST_VECTOR_GET(&level->categories, i);
 
            /*
             * If there is at least one matching category, and that category is enabled
             * or its sub-level is at or above the given sub-level then allow.
             */
            if ((category->id & ids) && category->sublevel != AST_LOG_CATEGORY_DISABLED &&
                (category->sublevel == AST_LOG_CATEGORY_ENABLED || category->sublevel >= sublevel)) {
                AST_VECTOR_RW_UNLOCK(&level->categories);
                return 1;
            }
        }
        AST_VECTOR_RW_UNLOCK(&level->categories);
    }
 
    return 0;
}
 
static struct categories_level_t debug_categories = {
    .type = __LOG_DEBUG,
    .sublevel = 0,
    .id_pool = 0,
    .state = 0,
};
 
uintmax_t ast_debug_category_register(const char *name)
{
    return category_register(&debug_categories, name);
}
 
int ast_debug_category_unregister(const char *name)
{
    return category_unregister(&debug_categories, name);
}
 
int ast_debug_category_set_sublevel(const char *name, int sublevel)
{
    return category_set_sublevel(NULL, &debug_categories, name, sublevel);
}
 
int ast_debug_category_set_sublevels(const char * const *names,
    size_t size, int default_sublevel)
{
    return category_set_sublevels(&debug_categories, names, size, default_sublevel);
}
 
char *ast_debug_category_complete(const char * const *argv, int argc,
    const char *word, int state)
{
    return category_complete(&debug_categories, argv, argc, word, state);
}
 
int ast_debug_category_is_allowed(int sublevel, uintmax_t ids)
{
    return category_is_allowed(sublevel, &debug_categories, ids);
}
 
int ast_logger_category_unload(void)
{
    AST_VECTOR_RW_FREE(&debug_categories.categories);
    return 0;
}
 
int ast_logger_category_load(void)
{
    if (AST_VECTOR_RW_INIT(&debug_categories.categories, 10)) {
        return -1;
    }
 
    return 0;
}