log.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <pthread.h>

Go to the source code of this file.

Data Structures
struct	logger
	The logger structure used to store the logger for the logging system. More...
struct	loggers
	The loggers structure used to store the loggers for the logging system. More...

Macros
#define	MAX_LOG_FILES   10
#define	MAX_FILENAME_LENGTH   256
#define	BITLAB_LOG   "bitlab.log"
#define	LOG_BITLAB_STARTED   "BitLab started ----------------------------------------------------------------------------------------"
#define	LOG_BITLAB_FINISHED   "BitLab finished successfully"
#define	LOCKED_FILE_RETRY_TIME   1000
#define	LOCKED_FILE_TIMEOUT   5000000

Typedefs
typedef struct logger	logger
	The logger structure used to store the logger for the logging system.
typedef struct loggers	loggers
	The loggers structure used to store the loggers for the logging system.

Enumerations
enum	log_level {   LOG_DEBUG , LOG_INFO , LOG_WARN , LOG_ERROR ,   LOG_FATAL }
	The log level enumeration used to define the level of logging that is being used. More...

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.

Macro Definition Documentation

BITLAB_LOG

#define BITLAB_LOG   "bitlab.log"

Definition at line 11 of file log.h.

LOCKED_FILE_RETRY_TIME

#define LOCKED_FILE_RETRY_TIME   1000

Definition at line 15 of file log.h.

LOCKED_FILE_TIMEOUT

#define LOCKED_FILE_TIMEOUT   5000000

Definition at line 16 of file log.h.

LOG_BITLAB_FINISHED

#define LOG_BITLAB_FINISHED   "BitLab finished successfully"

Definition at line 13 of file log.h.

LOG_BITLAB_STARTED

#define LOG_BITLAB_STARTED   "BitLab started ----------------------------------------------------------------------------------------"

Definition at line 12 of file log.h.

MAX_FILENAME_LENGTH

#define MAX_FILENAME_LENGTH   256

Definition at line 10 of file log.h.

MAX_LOG_FILES

#define MAX_LOG_FILES   10

Definition at line 9 of file log.h.

Typedef Documentation

logger

typedef struct logger logger

The logger structure used to store the logger for the logging system.

Parameters

filename	The filename of the log file.
file	The file pointer for the log file.

loggers

typedef struct loggers loggers

The loggers structure used to store the loggers for the logging system.

Parameters

log_mutex	The mutex for the loggers.
array	The array of loggers.
is_initializing	The flag to indicate if the loggers are initializing.

Enumeration Type Documentation

log_level

enum log_level

The log level enumeration used to define the level of logging that is being used.

Parameters

LOG_DEBUG	Debug level logging
LOG_INFO	Information level logging
LOG_WARN	Warning level logging
LOG_ERROR	Error level logging
LOG_FATAL	Fatal level logging

Enumerator
LOG_DEBUG
LOG_INFO
LOG_WARN
LOG_ERROR
LOG_FATAL

Definition at line 27 of file log.h.

{
    LOG_DEBUG,
    LOG_INFO,
    LOG_WARN,
    LOG_ERROR,
    LOG_FATAL
} log_level;

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().