n_nodup_log.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#define _GNU_SOURCE_WAS_NOT_DEFINED
#endif
#include <stdio.h>
#include <stdarg.h>
#ifdef _GNU_SOURCE_WAS_NOT_DEFINED
#undef _GNU_SOURCE
#endif
 
#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#include "nilorea/n_str.h"
#include "nilorea/n_list.h"
#include "nilorea/n_hash.h"
 
#include "nilorea/n_nodup_log.h"
 
static HASH_TABLE* _n_nodup_table = NULL;
 
int init_nodup_log(size_t max) {
    if (_n_nodup_table != NULL) {
        n_log(LOG_ERR, "Could not allocate the internal hash table because it's already done");
        return FALSE;
    }
    if (max == 0)
        max = 1024;
 
    _n_nodup_table = new_ht(max);
 
    if (_n_nodup_table == NULL) {
        n_log(LOG_ERR, "Could not allocate the internal hash with size %zu", max);
        return FALSE;
    } else {
        n_log(LOG_DEBUG, "LOGGING: nodup system activated with a hash table of %zu cells", max);
    }
 
    return TRUE;
} /* init_nodup_log() */
 
int empty_nodup_table() {
    __n_assert(_n_nodup_table, return FALSE);
    return empty_ht(_n_nodup_table);
} /* empty_nodup_table() */
 
int close_nodup_log() {
    __n_assert(_n_nodup_table, return FALSE);
    return destroy_ht(&_n_nodup_table);
} /* close_nodup_log() */
 
static char* get_nodup_key(const char* file, const char* func, int line) {
    N_STR* nstr = NULL;
    char* ptr = NULL;
    nstrprintf(nstr, "%s%s%d", file, func, line);
    __n_assert(nstr, return NULL);
    ptr = nstr->data;
    Free(nstr);
    return ptr;
} /* get_nodup_key */
 
static char* get_nodup_indexed_key(const char* file, const char* func, const char* prefix, int line) {
    N_STR* nstr = NULL;
    char* ptr = NULL;
    nstrprintf(nstr, "%s%s%s%d", file, func, prefix, line);
    __n_assert(nstr, return NULL);
    ptr = nstr->data;
    Free(nstr);
    return ptr;
} /* get_nodup_indexed_key */
 
int check_n_log_dup(const char* log, const char* file, const char* func, int line) {
    const HASH_NODE* node = NULL;
    char* key = NULL;
 
    /* check if the nopdup session is on, else do a normal n_log */
    if (!_n_nodup_table) {
        return 3;
    }
 
    key = get_nodup_key(file, func, line);
 
    __n_assert(key, return FALSE);
 
    node = ht_get_node(_n_nodup_table, key);
 
    Free(key);
 
    if (node) {
        if (strcmp(log, node->data.string) == 0) {
            return 1;
        }
        return 2;
    }
    return 0;
 
} /* check_n_log_dup(...) */
 
int check_n_log_dup_indexed(const char* log, const char* file, const char* func, int line, const char* prefix) {
    const HASH_NODE* node = NULL;
    char* key = NULL;
 
    /* check if the nopdup session is on, else do a normal n_log */
    if (!_n_nodup_table) {
        return 3;
    }
 
    key = get_nodup_indexed_key(file, func, prefix, line);
 
    __n_assert(key, return FALSE);
 
    node = ht_get_node(_n_nodup_table, key);
 
    Free(key);
 
    if (node) {
        if (strcmp(log, node->data.string) == 0) {
            return 1;
        }
        return 2;
    }
    return 0;
} /* check_nolog_dup_indexed() */
 
void _n_nodup_log(int LEVEL, const char* file, const char* func, int line, const char* format, ...) {
    __n_assert(file, return);
    __n_assert(func, return);
    __n_assert(format, return);
 
    HASH_NODE* node = NULL;
    va_list args;
 
    char* syslogbuffer = NULL;
 
    va_start(args, format);
    if (vasprintf(&syslogbuffer, format, args) == -1) {
        int error = errno;
        n_log(LOG_ERR, "=>%s:%s:%d unable to parse '%s', %s", file, func, line, format, strerror(error));
        va_end(args);
        syslogbuffer = NULL;
        return;
    }
    va_end(args);
 
    char* key = get_nodup_key(file, func, line);
    int is_dup = check_n_log_dup(syslogbuffer, file, func, line);
 
    switch (is_dup) {
        /* new log entry for file,func,line */
        case 0:
            if (_n_nodup_table) {
                ht_put_string(_n_nodup_table, key, syslogbuffer);
            }
            _n_log(LEVEL, file, func, line, "%s", syslogbuffer);
            break;
 
        /* exising and same log entry, do nothing (maybe latter we will add a timeout to repeat logging)  */
        case 1:
            break;
        /* existing but different entry. We have to refresh and log it one time*/
        case 2:
            node = ht_get_node(_n_nodup_table, key);
            if (node) {
                Free(node->data.string);
                node->data.string = syslogbuffer;
                syslogbuffer = NULL;
            }
            _n_log(LEVEL, file, func, line, "%s", node ? node->data.string : "");
            break;
        /* no nodup session started, normal loggin */
        case 3:
        default:
            _n_log(LEVEL, file, func, line, "%s", syslogbuffer);
            break;
    }
 
    Free(syslogbuffer);
    Free(key);
 
} /* _n_nodup_log() */
 
void _n_nodup_log_indexed(int LEVEL, const char* prefix, const char* file, const char* func, int line, const char* format, ...) {
    HASH_NODE* node = NULL;
    va_list args;
 
    char* syslogbuffer = NULL;
 
    va_start(args, format);
    if (vasprintf(&syslogbuffer, format, args) == -1) {
        int error = errno;
        n_log(LOG_ERR, "=>%s:%s:%d unable to parse '%s:%s', %s", file, func, line, prefix, format, strerror(error));
        va_end(args);
        syslogbuffer = NULL;
        return;
    }
    va_end(args);
 
    char* key = get_nodup_indexed_key(file, func, prefix, line);
    int is_dup = check_n_log_dup_indexed(syslogbuffer, file, func, line, prefix);
 
    switch (is_dup) {
        /* new log entry for file,func,line */
        case 0:
            if (_n_nodup_table) {
                ht_put_string(_n_nodup_table, key, syslogbuffer);
            }
            _n_log(LEVEL, file, func, line, "%s", syslogbuffer);
            break;
 
        /* exising and same log entry, do nothing (maybe latter we will add a timeout to repeat logging)  */
        case 1:
            break;
        /* existing but different entry. We have to refresh and log it one time*/
        case 2:
            node = ht_get_node(_n_nodup_table, key);
            if (node) {
                Free(node->data.string);
                node->data.string = syslogbuffer;
                syslogbuffer = NULL;
            }
            _n_log(LEVEL, file, func, line, "%s", node ? node->data.string : "");
            break;
        /* no nodup session started, normal loggin */
        case 3:
        default:
            _n_log(LEVEL, file, func, line, "%s", syslogbuffer);
            break;
    }
 
    Free(syslogbuffer);
    Free(key);
 
} /* _n_nodup_log_indexed() */
 
int dump_nodup_log(char* file) {
    FILE* out = NULL;
    __n_assert(file, return FALSE);
    __n_assert(_n_nodup_table, return FALSE);
 
    char* tmpfile = NULL;
    n_log(LOG_DEBUG, "outfile:%s", file);
    strprintf(tmpfile, "%s.tmp", file);
    if (!tmpfile) {
        n_log(LOG_ERR, "could not create tmp file name from filename %s", _str(file));
        return FALSE;
    }
 
    int fd = open(tmpfile, O_CREAT | O_WRONLY | O_TRUNC, 0600);  // Only owner can read/write
    if (fd < 0) {
        n_log(LOG_ERR, "could not create file %s with 0600 permissions", _str(tmpfile));
        Free(tmpfile);
        return FALSE;
    }
 
    out = fdopen(fd, "wb");
    __n_assert(out, close(fd); Free(tmpfile); return FALSE);
 
    if (_n_nodup_table) {
        for (unsigned long int it = 0; it < _n_nodup_table->size; it++) {
            list_foreach(list_node, _n_nodup_table->hash_table[it]) {
                const HASH_NODE* hash_node = (const HASH_NODE*)list_node->ptr;
                fprintf(out, "%s\n", hash_node->data.string);
            }
        }
    }
    fclose(out);
 
    if (rename(tmpfile, file) != 0) {
        int error = errno;
        n_log(LOG_ERR, "could not rename '%s' to '%s' , %s", tmpfile, file,
              strerror(error));
    }
    Free(tmpfile);
 
    return TRUE;
 
} /* dump_nodup_log() */