log.cpp

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS 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.
 *
 *   FREESECS 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 FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <syslog.h>
#include "log.h"

char* debugstr_hex_dump (const void *ptr, int len)
{
     /* Locals */
     char          dumpbuf[59];
     char          charbuf[20];
     char          tempbuf[8];
     const char    *p;
     int           i;
     unsigned int  nosign;
     char          *dst;
     char          *outptr;
 
 /* Begin function dbg_hex_dump */
 
     /*-----------------------------------------------------------------------
     **  Allocate an output buffer
     **      A reasonable value is one line overhand (80 chars), and
     **      then one line (80) for every 16 bytes.
     **---------------------------------------------------------------------*/
     outptr = dst = new char[len * (80 / 16) + 80];
 
     /*-----------------------------------------------------------------------
     **  Loop throught the input buffer, one character at a time
     **---------------------------------------------------------------------*/
     for (i = 0, p = (const char*)ptr; (i < len); i++, p++)
     {
 
         /*-------------------------------------------------------------------
         **  If we're just starting a line, 
         **      we need to possibly flush the old line, and then
         **      intialize the line buffer.
         **-----------------------------------------------------------------*/
         if ((i % 16) == 0)
         {
             if (i)
             {
                 sprintf(outptr, "  %-43.43s   %-16.16s\n", dumpbuf, charbuf);
                 outptr += strlen(outptr);
             }
             sprintf (dumpbuf, "%04x: ", i);
             strcpy (charbuf, "");
         }
 
         /*-------------------------------------------------------------------
         **  Add the current data byte to the dump section.
         **-----------------------------------------------------------------*/
         nosign = (unsigned char) *p;
         sprintf (tempbuf, "%02X", nosign);
 
         /*-------------------------------------------------------------------
         ** Separate bytes with a space
         **------------------------------------------------------------------*/
         /*if((i % 2) == 1)*/
            strcat(tempbuf, " ");
         strcat (dumpbuf, tempbuf);
 
         /*-------------------------------------------------------------------
         **  Add the current byte to the character display part of the
         **      hex dump
         **-----------------------------------------------------------------*/
         sprintf (tempbuf, "%c", isprint(*p) ? *p : '.');
         strcat (charbuf, tempbuf);
     }
 
     /*-----------------------------------------------------------------------
     **  Flush the last line, if any
     **---------------------------------------------------------------------*/
     if (i > 0)
     {
         sprintf(outptr, "  %-43.43s   %-16.16s\n", dumpbuf, charbuf);
         outptr += strlen(outptr);
     }
 
     return(dst);
} /* End function dbg_hex_dump */


#if 0

#ifdef TRACE_TIME_ON
#define ONE_MILLION 1000000L
char *hsms_gettime()
{
    const size_t len = 16;
    static char buf[len];
    struct timeval tv;
    gettimeofday(&tv, NULL);
    snprintf(buf, len, "%lu", tv.tv_sec*ONE_MILLION + tv.tv_usec);
    return buf;
}
#endif

#endif //if 0


#ifndef _MODULE_ID
#define _MODULE_ID "HSMS"
#endif 


static class _log_init
{
public:
    _log_init()
    {
        ::openlog(_MODULE_ID, LOG_NDELAY, 0);
    }
    ~_log_init()
    {
        ::closelog();
    }

} log_init;

static struct _hsms_log
{
public:
    void
    operator()(int level, const char *prefix, const char *fmt, va_list ap)
    {
        const int bufsize = 128;
        char format[bufsize];
    
        if(LOG_LEVEL_UPPER_BOUND < level || level < LOG_LEVEL_LOWER_BOUND)
        {
            return;
        }
#ifndef LOG_TO_CONSOLE
        snprintf(format, bufsize, "%s - %s", prefix, fmt);
        vsyslog(LOG_FACILITY | LOG_NOTICE, format, ap);
#else
        snprintf(format, bufsize, "%s - %s\n", prefix, fmt);
        vprintf(format, ap);
#endif
    }
    void
    operator()(int level, const char *prefix, const char *fmt...)
    {
        va_list ap;
        va_start(ap, fmt);
        this->operator()(level, prefix, fmt, ap);
        va_end(ap);
    }
}hsms_log;

#define HSMS_LOG(lvl, pfx, f) \
        { \
            va_list ap; \
            va_start(ap, f); \
            hsms_log(lvl, pfx, f, ap); \
            va_end(ap); \
        }

#define HSMS_LOG_EXTRA_FMT(lvl, pfx, f1, f2) \
        { \
            va_list ap; \
            va_start(ap, f1); \
            hsms_log(lvl, pfx, f2, ap); \
            va_end(ap); \
        }

void 
freesecs::TRACE_CRITICAL      (const char *fmt, ...)
{
    HSMS_LOG(0, "[CRTIICAL]", fmt);
}
void 
freesecs::TRACE_ERROR         (const char *fmt, ...)
{
    HSMS_LOG(1, "[ERROR]", fmt);
}
void 
freesecs::TRACE_INFO          (int lvl, const char *fmt, ...)
{
    HSMS_LOG(3, "[INFO]", fmt);
}
void 
freesecs::TRACE_DEBUG         (int lvl, const char *fmt, ...)
{
    HSMS_LOG(lvl, "[DEBUG]", fmt);
}
void 
freesecs::TRACE_FSM_BEGIN     (int lvl, const char *fsm_name, int state, int event)
{
    hsms_log(lvl, "[SM]", "{ %s: state %d, event e%d -->", fsm_name, state, event);
}
void 
freesecs::TRACE_FSM_END       (int lvl, const char *fsm_name, int state, int event)
{
    hsms_log(lvl, "[SM]", "} %s: state %d event e%d <--", fsm_name, state, event);
}
void 
freesecs::TRACE_FSM_TRANS     (int lvl, const char *fsm_name, int prev_state, int new_state)
{
    hsms_log(lvl, "[SM]", "T %s: state %d --> state %d", fsm_name, prev_state, new_state);
}
void 
freesecs::TRACE_FSM_ERROR     (int lvl, const char *fsm_name, const char *fmt, ...)
{
    char format[128];
    snprintf(format, 128, "! %s: %s", fsm_name, fmt);
    HSMS_LOG_EXTRA_FMT(lvl, "[SM]", fmt, format);
}
void 
freesecs::TRACE_FSM_ACTION    (int lvl, const char *fsm_name, const char *act, const char *fmt, ...)
{
    char format[128];
    snprintf(format, 128, "* %s: %s %s", fsm_name, act, fmt);
    HSMS_LOG_EXTRA_FMT(lvl, "[SM]", fmt, format);
}
void 
freesecs::TRACE_HEX_DUMP      (int lvl, const char *msg, size_t len)
{
    hsms_log(lvl, "[HEX]", debugstr_hex_dump(msg, len));
}

---