log.c File Reference

#include "log.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "utils.h"

Go to the source code of this file.

Functions
const char *	create_logs_dir ()
	Create logs directory used to create the logs directory if it does not exist.
void	init_logging (const char *filename)
	Initialize logging used to initialize the logging system, open and preserve the log file.
void	log_message (log_level level, const char *filename, const char *source_file, const char *format,...)
	Log a message used to log a message to the console or a file.
void	finish_logging ()
	Finish logging used to finish logging and close the log file.

Variables
static struct loggers	logs = { PTHREAD_MUTEX_INITIALIZER, {NULL}, 0 }
static const char *	logs_dir = NULL

Function Documentation

create_logs_dir()

const char * create_logs_dir

(

)

Create logs directory used to create the logs directory if it does not exist.

Returns

The logs directory.

Definition at line 20 of file log.c.

{
    const char* home = getenv("HOME");
    if (home == NULL)
        return NULL;
    const char* suffix = "/.bitlab/logs";
    char* logs_dir = malloc(strlen(home) + strlen(suffix) + 1);
    if (logs_dir == NULL)
        return NULL;
    strcpy(logs_dir, home);
    strcat(logs_dir, suffix);
    return logs_dir;
}

References logs_dir.

Referenced by init_logging(), and log_message().

finish_logging()

void finish_logging

(

)

Finish logging used to finish logging and close the log file.

Definition at line 199 of file log.c.

{
    while (logs.is_initializing)
    {
        usleep(10000); // 10 ms
    }
    pthread_mutex_lock(&logs.log_mutex);
    for (int i = 0; i < MAX_LOG_FILES; ++i)
    {
        if (logs.array[i] != NULL)
        {
            fclose(logs.array[i]->file);
            if (logs.array[i]->filename != NULL)
                free(logs.array[i]->filename);
            free(logs.array[i]);
            logs.array[i] = NULL;
        }
    }
    pthread_mutex_unlock(&logs.log_mutex);
    if (logs_dir != NULL)
    {
        free((void*)logs_dir);
        logs_dir = NULL;
    }
}

References loggers::array, logger::file, logger::filename, loggers::is_initializing, loggers::log_mutex, logs, logs_dir, MAX_LOG_FILES, and usleep().

Referenced by run_bitlab().

init_logging()

void init_logging

(

const char *

filename

)

Initialize logging used to initialize the logging system, open and preserve the log file.

Parameters

log_file

The log file to write to.

Definition at line 34 of file log.c.

{
    logs.is_initializing = 1;
    if (logs_dir != NULL)
    {
        free((void*)logs_dir);
    }
    logs_dir = create_logs_dir();
    struct stat st = { 0 };
 
    if (stat(logs_dir, &st) == -1)
    {
        if (mkdir(logs_dir, 0700) != 0)
        {
            perror("Failed to create logs directory");
            logs.is_initializing = 0;
            free((void*)logs_dir); // Free logs_dir on error
            logs_dir = NULL;
            return;
        }
    }
 
    char full_path[BUFFER_SIZE];
    snprintf(full_path, sizeof(full_path), "%s/%s", logs_dir, filename);
 
    pthread_mutex_lock(&logs.log_mutex);
    for (int i = 0; i < MAX_LOG_FILES; ++i)
    {
        if (logs.array[i] == NULL)
        {
            logs.array[i] = (struct logger*)malloc(sizeof(logger));
            logs.array[i]->filename = (char*)malloc(strlen(full_path) + 1);
            if (logs.array[i]->filename == NULL)
            {
                perror("Failed to allocate memory for filename");
                free(logs.array[i]);
                logs.array[i] = NULL;
                break;
            }
            snprintf(logs.array[i]->filename, strlen(full_path) + 1, "%s", full_path);
            logs.array[i]->file = fopen(full_path, "a");
            if (logs.array[i]->file == NULL)
            {
                perror("Failed to open log file");
                free(logs.array[i]->filename);
                free(logs.array[i]);
                logs.array[i] = NULL;
            }
            break;
        }
    }
    logs.is_initializing = 0;
    pthread_mutex_unlock(&logs.log_mutex);
}

References loggers::array, BUFFER_SIZE, create_logs_dir(), logger::file, logger::filename, loggers::is_initializing, loggers::log_mutex, logs, logs_dir, and MAX_LOG_FILES.

Referenced by connect_to_peer(), and run_bitlab().

log_message()

void log_message	(	log_level	level,
		const char *	filename,
		const char *	source_file,
		const char *	format,
			...
	)

Log a message used to log a message to the console or a file.

Parameters

level	The log level.
log_file	The file that the log message is destined for.
source_file	The source file that the log message is from.
format	The format of the log message.
...	The arguments for the format.

Definition at line 89 of file log.c.

{
    if (logs_dir == NULL)
    {
        logs_dir = create_logs_dir();
        if (logs_dir == NULL)
        {
            fprintf(stderr, "Failed to create logs directory\n");
            return;
        }
    }
 
    char full_path[BUFFER_SIZE];
    snprintf(full_path, sizeof(full_path), "%s/%s", logs_dir, filename);
 
    pthread_mutex_lock(&logs.log_mutex);
 
    FILE* log = NULL;
    for (int i = 0; i < MAX_LOG_FILES; ++i)
    {
        if (logs.array[i] != NULL && !strcmp(logs.array[i]->filename, full_path))
        {
            log = logs.array[i]->file;
            break;
        }
    }
 
    if (log == NULL)
    {
        // Try to create and open the log file if it doesn't exist
        log = fopen(full_path, "a");
        if (log == NULL)
        {
            pthread_mutex_unlock(&logs.log_mutex);
            fprintf(stderr, "Failed to create or open log file: %s\n", full_path);
            return;
        }
 
        // Add the new log file to the logs array
        for (int i = 0; i < MAX_LOG_FILES; ++i)
        {
            if (logs.array[i] == NULL)
            {
                logs.array[i] = (struct logger*)malloc(sizeof(logger));
                logs.array[i]->filename = (char*)malloc(strlen(full_path) + 1);
                if (logs.array[i]->filename == NULL)
                {
                    perror("Failed to allocate memory for filename");
                    free(logs.array[i]);
                    logs.array[i] = NULL;
                    fclose(log);
                    pthread_mutex_unlock(&logs.log_mutex);
                    return;
                }
                snprintf(logs.array[i]->filename, strlen(full_path) + 1, "%s", full_path);
                logs.array[i]->file = log;
                break;
            }
        }
    }
 
    int timeout = 0;
    int error = 0;
 
    error = flock(fileno(log), LOCK_EX | LOCK_NB);
    while (error == -1 && (errno == EWOULDBLOCK || errno == EAGAIN))
    {
        usleep(LOCKED_FILE_RETRY_TIME);
        timeout += LOCKED_FILE_RETRY_TIME;
 
        if (timeout > LOCKED_FILE_TIMEOUT)
        {
            fprintf(stderr, "Log file locking timed out: %s\n", full_path);
            pthread_mutex_unlock(&logs.log_mutex);
            return;
        }
        error = flock(fileno(log), LOCK_EX | LOCK_NB);
    }
 
    fseek(log, 0, SEEK_END);
 
    const char* level_str;
    switch (level)
    {
    case LOG_DEBUG: level_str = "DEBUG"; break;
    case LOG_INFO: level_str = "INFO"; break;
    case LOG_WARN: level_str = "WARN"; break;
    case LOG_ERROR: level_str = "ERROR"; break;
    case LOG_FATAL: level_str = "FATAL"; break;
    default: level_str = "UNKNOWN"; break;
    }
 
    char timestamp[TIMESTAMP_LENGTH];
    get_formatted_timestamp(timestamp, TIMESTAMP_LENGTH);
 
    char message[1024];
    va_list args;
    va_start(args, format);
    vsnprintf(message, sizeof(message), format, args);
    va_end(args);
 
    fprintf(log, "%s - %s - %s - %s\n", timestamp, level_str, source_file, message);
 
    fflush(log);
 
    flock(fileno(log), LOCK_UN);
 
    pthread_mutex_unlock(&logs.log_mutex);
}

References loggers::array, BUFFER_SIZE, create_logs_dir(), logger::file, logger::filename, fileno(), get_formatted_timestamp(), LOCKED_FILE_RETRY_TIME, LOCKED_FILE_TIMEOUT, LOG_DEBUG, LOG_ERROR, LOG_FATAL, LOG_INFO, loggers::log_mutex, LOG_WARN, logs, logs_dir, MAX_LOG_FILES, TIMESTAMP_LENGTH, and usleep().

Referenced by add_peer_to_queue(), build_inv_message(), cli_clear(), cli_connect(), cli_disconnect(), cli_echo(), cli_exec_line(), cli_exit(), cli_getaddr(), cli_getblocks(), cli_getdata(), cli_getheaders(), cli_help(), cli_history(), cli_info(), cli_inv(), cli_list(), cli_peer_discovery(), cli_ping(), cli_tx(), cli_whoami(), connect_to_peer(), disconnect(), force_stop_peer_discovery(), handle_cli(), handle_inv_message(), handle_peer_discovery(), init_program_state(), is_in_private_network(), is_valid_domain_address(), lookup_address(), peer_communication(), run_bitlab(), send_addr(), send_getaddr_and_wait(), send_getblocks_and_wait(), send_getdata_and_wait(), send_getheaders_and_wait(), send_headers(), send_inv_and_wait(), send_ping(), send_tx(), send_verack(), set_peer_discovery(), set_peer_discovery_dns_domain(), start_peer_discovery_progress(), thread_runner(), and write_var_int().

Variable Documentation

logs

struct loggers logs = { PTHREAD_MUTEX_INITIALIZER, {NULL}, 0 }

static

Definition at line 16 of file log.c.

{ PTHREAD_MUTEX_INITIALIZER, {NULL}, 0 };

Referenced by finish_logging(), init_logging(), and log_message().

logs_dir

const char* logs_dir = NULL

static

Definition at line 18 of file log.c.

Referenced by create_history_dir(), create_logs_dir(), finish_logging(), init_logging(), and log_message().