error.c

Go to the documentation of this file.

/*
    clsync - file tree sync utility based on inotify/kqueue
 
    Copyright (C) 2013-2014 Dmitry Yu Okunev <dyokunev@ut.mephi.ru> 0x8E30679C
 
    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 <http://www.gnu.org/licenses/>.
 */
 
/*
 * This file implements way to output debugging information. It's supposed
 * to be slow but convenient functions.
 */
 
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <syslog.h>
#include <pthread.h>    /* pthread_self() */
#include <sys/types.h>  /* getpid() */
#include <unistd.h> /* getpid() */
 
#include "macros.h"
#include "configuration.h"
 
#include "error.h"
#include "pthreadex.h"  /* pthread_*_shared() */
 
#ifdef BACKTRACE_SUPPORT
#include <execinfo.h>
#endif
 
static int zero     = 0;
static int three    = 3;
 
static int *outputmethod = &zero;
static int *debug    = &zero;
static int *quiet    = &zero;
static int *verbose  = &three;
 
pthread_mutex_t *error_mutex_p = NULL;
 
static int printf_stderr ( const char *fmt, ... )
{
    va_list args;
    int rc;
    va_start ( args, fmt );
    rc = vfprintf ( stderr, fmt, args );
    va_end ( args );
    return rc;
}
 
static int printf_stdout ( const char *fmt, ... )
{
    va_list args;
    int rc;
    va_start ( args, fmt );
    rc = vfprintf ( stdout, fmt, args );
    va_end ( args );
    return rc;
}
 
static int vprintf_stderr ( const char *fmt, va_list args )
{
    return vfprintf ( stderr, fmt, args );
}
 
static int vprintf_stdout ( const char *fmt, va_list args )
{
    return vfprintf ( stdout, fmt, args );
}
 
 
static void flush_stderr ( int level )
{
    ( void ) level;
    fprintf ( stderr, "\n" );
    fflush ( stderr );
}
 
static void flush_stdout ( int level )
{
    ( void ) level;
    fprintf ( stdout, "\n" );
    fflush ( stdout );
}
 
 
static char _syslog_buffer[SYSLOG_BUFSIZ + 1] = {0};
size_t      _syslog_buffer_filled = 0;
 
static int vsyslog_buf ( const char *fmt, va_list args )
{
    int len;
    size_t size;
    size = SYSLOG_BUFSIZ - _syslog_buffer_filled;
#ifdef VERYPARANOID
 
    if (
        (            size   > SYSLOG_BUFSIZ )   ||
        ( _syslog_buffer_filled + size  > SYSLOG_BUFSIZ )   ||
        ( _syslog_buffer_filled     > SYSLOG_BUFSIZ )
    ) {
        fprintf ( stderr, "Security problem while vsyslog_buf(): "
                  "_syslog_buffer_filled == %lu; "
                  "size == %lu; "
                  "SYSLOG_BUFSIZ == "XTOSTR ( SYSLOG_BUFSIZ ) "\n",
                  _syslog_buffer_filled, size );
        exit ( ENOBUFS );
    }
 
#endif
 
    if ( !size )
        return 0;
 
    len = vsnprintf (
              &_syslog_buffer[_syslog_buffer_filled],
              size,
              fmt,
              args
          );
 
    if ( len > 0 ) {
        _syslog_buffer_filled += len;
 
        if ( _syslog_buffer_filled > SYSLOG_BUFSIZ )
            _syslog_buffer_filled = SYSLOG_BUFSIZ;
    }
 
    return 0;
}
 
static int syslog_buf ( const char *fmt, ... )
{
    va_list args;
    int rc;
    va_start ( args, fmt );
    rc = vsyslog_buf ( fmt, args );
    va_end ( args );
    return rc;
}
 
static void syslog_flush ( int level )
{
    syslog ( level, "%s", _syslog_buffer );
    _syslog_buffer_filled = 0;
}
 
typedef int  (  *outfunct_t ) ( const char *format, ... );
typedef int  ( *voutfunct_t ) ( const char *format, va_list ap );
typedef void ( *flushfunct_t ) ( int level );
 
static outfunct_t outfunct[] = {
    [OM_STDERR] = ( outfunct_t ) printf_stderr,
    [OM_STDOUT] = ( outfunct_t ) printf_stdout,
    [OM_SYSLOG] = ( outfunct_t ) syslog_buf,
};
 
static voutfunct_t voutfunct[] = {
    [OM_STDERR] = ( voutfunct_t ) vprintf_stderr,
    [OM_STDOUT] = ( voutfunct_t ) vprintf_stdout,
    [OM_SYSLOG] = ( voutfunct_t ) vsyslog_buf,
};
 
static flushfunct_t flushfunct[] = {
    [OM_STDERR] = ( flushfunct_t ) flush_stderr,
    [OM_STDOUT] = ( flushfunct_t ) flush_stdout,
    [OM_SYSLOG] = ( flushfunct_t ) syslog_flush,
};
 
void _critical ( const char *const function_name, const char *fmt, ... )
{
    if ( *quiet )
        return;
 
    struct timespec abs_time;
    clock_gettime ( CLOCK_REALTIME, &abs_time );
    abs_time.tv_sec += 1;
 
    if ( error_mutex_p != NULL )
        pthread_mutex_timedlock ( error_mutex_p, &abs_time );
 
    outputmethod_t method = *outputmethod;
    {
        va_list args;
        pthread_t thread = pthread_self();
        pid_t pid = getpid();
        outfunct[method] ( "Critical (pid: %u; thread: %p): %s(): ", pid, thread, function_name );
        va_start ( args, fmt );
        voutfunct[method] ( fmt, args );
        va_end ( args );
        outfunct[method] ( " (current errno %i: %s)", errno, strerror ( errno ) );
        flushfunct[method] ( LOG_CRIT );
    }
#ifdef BACKTRACE_SUPPORT
    {
        void  *buf[BACKTRACE_LENGTH];
        char **strings;
        int backtrace_len = backtrace ( ( void ** ) buf, BACKTRACE_LENGTH );
        strings = backtrace_symbols ( buf, backtrace_len );
 
        if ( strings == NULL ) {
            outfunct[method] ( "_critical(): Got error, but cannot print the backtrace. Current errno: %u: %s\n",
                               errno, strerror ( errno ) );
            flushfunct[method] ( LOG_CRIT );
            pthread_mutex_unlock ( error_mutex_p );
            exit ( EXIT_FAILURE );
        }
 
        for ( int j = 1; j < backtrace_len; j++ ) {
            outfunct[method] ( "        %s", strings[j] );
            flushfunct[method] ( LOG_CRIT );
        }
    }
#endif
 
    if ( error_mutex_p != NULL )
        pthread_mutex_unlock ( error_mutex_p );
 
    error_deinit();
    exit ( errno );
    return;
}
 
void _error ( const char *const function_name, const char *fmt, ... )
{
    va_list args;
 
    if ( *quiet )
        return;
 
    if ( *verbose < 1 )
        return;
 
    if ( error_mutex_p != NULL )
        pthread_mutex_reltimedlock ( error_mutex_p, 0, OUTPUT_LOCK_TIMEOUT );
 
    pthread_t thread = pthread_self();
    pid_t pid = getpid();
    outputmethod_t method = *outputmethod;
    outfunct[method] ( *debug ? "Error (pid: %u; thread: %p): %s(): " : "Error: ", pid, thread, function_name );
    va_start ( args, fmt );
    voutfunct[method] ( fmt, args );
    va_end ( args );
 
    if ( errno )
        outfunct[method] ( " (%i: %s)", errno, strerror ( errno ) );
 
    flushfunct[method] ( LOG_ERR );
 
    if ( error_mutex_p != NULL )
        pthread_mutex_unlock ( error_mutex_p );
 
    return;
}
 
void _info ( const char *const function_name, const char *fmt, ... )
{
    va_list args;
 
    if ( *quiet )
        return;
 
    if ( *verbose < 3 )
        return;
 
    if ( error_mutex_p != NULL )
        pthread_mutex_reltimedlock ( error_mutex_p, 0, OUTPUT_LOCK_TIMEOUT );
 
    pthread_t thread = pthread_self();
    pid_t pid = getpid();
    outputmethod_t method = *outputmethod;
    outfunct[method] ( *debug ? "Info (pid: %u; thread: %p): %s(): " : "Info: ", pid, thread, function_name );
    va_start ( args, fmt );
    voutfunct[method] ( fmt, args );
    va_end ( args );
    flushfunct[method] ( LOG_INFO );
 
    if ( error_mutex_p != NULL )
        pthread_mutex_unlock ( error_mutex_p );
 
    return;
}
 
void _warning ( const char *const function_name, const char *fmt, ... )
{
    va_list args;
 
    if ( *quiet )
        return;
 
    if ( *verbose < 2 )
        return;
 
    if ( error_mutex_p != NULL )
        pthread_mutex_reltimedlock ( error_mutex_p, 0, OUTPUT_LOCK_TIMEOUT );
 
    pthread_t thread = pthread_self();
    pid_t pid = getpid();
    outputmethod_t method = *outputmethod;
    outfunct[method] ( *debug ? "Warning (pid: %u; thread: %p): %s(): " : "Warning: ", pid, thread, function_name );
    va_start ( args, fmt );
    voutfunct[method] ( fmt, args );
    va_end ( args );
    flushfunct[method] ( LOG_WARNING );
 
    if ( error_mutex_p != NULL )
        pthread_mutex_unlock ( error_mutex_p );
 
    return;
}
 
#ifdef _DEBUG_SUPPORT
void _debug ( int debug_level, const char *const function_name, const char *fmt, ... )
{
    va_list args;
 
    if ( *quiet )
        return;
 
    if ( debug_level > *debug )
        return;
 
    if ( error_mutex_p != NULL )
        pthread_mutex_reltimedlock ( error_mutex_p, 0, OUTPUT_LOCK_TIMEOUT );
 
    pthread_t thread = pthread_self();
    pid_t pid = getpid();
    outputmethod_t method = *outputmethod;
    outfunct[method] ( "Debug%u (pid: %u; thread: %p): %s(): ", debug_level, pid, thread, function_name );
    va_start ( args, fmt );
    voutfunct[method] ( fmt, args );
    va_end ( args );
    flushfunct[method] ( LOG_DEBUG );
 
    if ( error_mutex_p != NULL )
        pthread_mutex_unlock ( error_mutex_p );
 
    return;
}
#endif
 
void error_init ( void *_outputmethod, int *_quiet, int *_verbose, int *_debug )
{
    outputmethod    = _outputmethod;
    quiet       = _quiet;
    verbose     = _verbose;
    debug       = _debug;
    openlog ( NULL, SYSLOG_FLAGS, SYSLOG_FACILITY );
    return;
}
 
ipc_type_t ipc_type;
void error_init_ipc ( ipc_type_t _ipc_type )
{
    static pthread_mutex_t error_mutex = PTHREAD_MUTEX_INITIALIZER;
    ipc_type = _ipc_type;
 
    switch ( ipc_type ) {
        case IPCT_SHARED:
            pthread_mutex_init_shared ( &error_mutex_p );
            break;
 
        case IPCT_PRIVATE:
            error_mutex_p = &error_mutex;
            pthread_mutex_init ( error_mutex_p, NULL );
            break;
 
        default:
            critical ( "Unknown ipc_type: %i", ipc_type );
    }
 
    return;
}
 
void error_deinit()
{
    switch ( ipc_type ) {
        case IPCT_SHARED:
            pthread_mutex_destroy_shared ( error_mutex_p );
            error_mutex_p = NULL;
            break;
 
        case IPCT_PRIVATE:
            break;
    }
 
    return;
}