netex/src/net/logging/log.c

#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "netex.h"
#include "log.h"

bool canLog = false;

log_base* initialize_log_base(const char* logPath, const char* executable, const int max_file_size_bytes, const enum log_level maxLogLevel)
{
    log_base* app_log = (log_base*) malloc(sizeof(log_base));
    if (app_log == NULL)
        return NULL;
    app_log->log_file = strdup(logPath);
    app_log->executable_name = strdup(executable);
    app_log->log_file_max_size = max_file_size_bytes;
    app_log->max_log_level = maxLogLevel;
    canLog = true;
    return app_log;
}

iterate_state destroy_logger(const void* data)
{
    logger* logger = (struct logger*)data;
    logger->app_logger = NULL;
    free(logger->name);
    free(logger);
    return DELETE;
}

void shutdown_log(log_base* base)
{
    canLog = false;
    iterate_list(base->loggers, true, &destroy_logger);
    free(base->log_file);
    free(base->executable_name);
    free(base);
}

logger* create_logger(log_base* base, const char* name)
{
    logger* new_logger = (logger*)malloc(sizeof(logger));
    if (new_logger == NULL)
        return NULL;
    new_logger->name = strdup(name);
    if (new_logger->name == NULL)
    {
        int err = errno;
        //TODO: log!?
        free(new_logger);
        return NULL;
    }
    add_node(base->loggers, new_logger, false);
    return new_logger;
}

void log_to_file(const logger* logger, const enum log_level logLevel, const char* format, ...)
{
    if (!canLog || logger->app_logger->max_log_level <= logLevel) return;
    char* logMessage;
    va_list args;
    va_start(args, format);
    int formatedStringSize = vasprintf(&logMessage, format, args);
    va_end(args);
    if (0 > formatedStringSize) logMessage = NULL;
    //TODO: Handle logging to file/queue
    free(logMessage);
}