logger_category.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2020, Sangoma Technologies Corporation
 *
 * Kevin Harwell <[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.
 */

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