source: libcf/trunk/src/cf_log.c@ 35

/**
 * @file    cf_log.c
 * @author  myusgun <myusgun@gmail.com>
 * @version 0.1
 */
#ifdef _WIN32
# define _USE_32BIT_TIME_T
#endif

#include "cf_log.h"
#include "cf_file.h"
#include "cf_thread.h"
#include "cf_local.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>

#ifdef _WIN32
# define snprintf       _snprintf
# include <Windows.h>
#else // #ifdef _WIN32
# include <sys/time.h>
#endif // #ifdef _WIN32

#define CHECK_INVALID_CTX(__ctx)        (__ctx == NULL)
#define LOCK_LOG_CTX(__ctx)             CF_Mutex_Lock (&__ctx->mutex)
#define UNLOCK_LOG_CTX(__ctx)           CF_Mutex_Unlock (&__ctx->mutex)
#define CHECK_INITIALIZED()             (gLogEnvironment.ctxPool == NULL||  \
                                         gLogEnvironment.ctxSize <= 0   )
#define CHECK_INVALID_MAPID(__mapid)    (gLogEnvironment.ctxSize <= __mapid)
#define CHECK_MAPPED_ID(__mapid)        (gLogEnvironment.ctxPool[__mapid] != NULL)  \


#define CF_LOG_BUFFER_DEFAULT_SIZE      128 * 1024

#define CF_LOG_DATETIME_LENGTH          sizeof ("0000-00-00 00:00:00.000") - 1

typedef struct __cf_util_datetime__
{
    int year;
    int month;
    int day;
    int week; /* SUN:0 ~ SAT:6 */

    int hour;
    int min;
    int sec;
    int usec;
} S_CF_LOG_DATETIME, CF_LOG_DATETIME;

typedef struct __cf_log_ctx__ {
    char        path[NAME_LENGTH + 1];
    int         fd;
    char        * buffer;
    size_t      size;   /* entire size of buffer */
    size_t      length; /* data length in current */
    CF_Mutex    mutex;
} S_CF_LOG_CTX, CF_LOG_CTX;

typedef struct __cf_log_environment__ {
    CF_Log_Ctx  * ctxPool;
    int         ctxSize;
} S_CF_LOG_ENVIRONMENT, CF_LOG_ENVIRONMENT;

static CF_LOG_ENVIRONMENT   gLogEnvironment;

#if defined(_WIN32) || defined(_WIN64)
/* #if defined(_WIN32) || defined(_WIN64) {{{ */
struct timezone
{
    int tz_minuteswest; /* minutes W of Greenwich */
    int tz_dsttime;     /* type of dst correction */
};

// Definition of a gettimeofday function
int gettimeofday(struct timeval *tv, struct timezone *tz)
{
    // Define a structure to receive the current Windows filetime
    FILETIME ft;

    // Initialize the present time to 0 and the timezone to UTC
    unsigned __int64 ui64 =0;
    static int tzflag = 0;

    if (NULL != tv)
    {
        GetSystemTimeAsFileTime(&ft);

        ui64 = (((unsigned __int64) ft.dwHighDateTime << 32)
                + (unsigned __int64) ft.dwLowDateTime);

        if (ui64)
        {
            ui64 /= 10;
            ui64 -= ((369 * 365 + 89) * (unsigned __int64) 86400) * 1000000;
        }

        // Finally change microseconds to seconds and place in the seconds value.
        // The modulus picks up the microseconds.
        tv->tv_sec = (long)(ui64 / 1000000UL);
        tv->tv_usec = (long)(ui64 % 1000000UL);
    }

    if (NULL != tz)
    {
        if (!tzflag)
        {
            _tzset();
            tzflag++;
        }

        // Adjust for the timezone west of Greenwich
        tz->tz_minuteswest = _timezone / 60;
        tz->tz_dsttime = _daylight;
    }

    return 0;
}
#endif // #if defined(_WIN32) || defined(_WIN64)
/* }}} #if defined(_WIN32) || defined(_WIN64) */

static int
CF_Log_Local_GetTime (CF_LOG_DATETIME * dt)
{
    struct timeval  timeVal;
    struct tm       * timeSt;

    gettimeofday (&timeVal, NULL);
    timeSt = localtime ((const time_t *)&timeVal.tv_sec);

    dt->year    = timeSt->tm_year + 1900;
    dt->month   = timeSt->tm_mon + 1;
    dt->day     = timeSt->tm_mday;
    dt->week    = timeSt->tm_wday;

    dt->hour    = timeSt->tm_hour;
    dt->min     = timeSt->tm_min;
    dt->sec     = timeSt->tm_sec;

    dt->usec    = (int) timeVal.tv_usec;

    return CF_OK;
}

static int
CF_Log_Local_GetTimeString (char * buffer)
{
    CF_LOG_DATETIME dt;
    CF_Log_Local_GetTime (&dt);

    snprintf (buffer, CF_LOG_DATETIME_LENGTH,
              "%02d-%02d-%02d %02d:%02d:%02d.%03d",
              dt.year, dt.month, dt.day,
              dt.hour, dt.min, dt.sec, dt.usec);

    return CF_OK;
}

static int
CF_Log_Local_Flush (CF_LOG_CTX * ctx)
{
    if (CF_File_Write (ctx->fd, ctx->buffer, ctx->length) < 0)
        return CF_ERROR_LOG_FLUSH;

    memset (ctx->buffer, 0x00, ctx->size);
    ctx->length = 0;

    return CF_OK;
}

/**
 * 로그 데이터 처리
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx           로그 컨텍스트
 * @param buffer        로그 데이터
 * @param demandSize    로그 데이터 길이
 *
 * @author vfire
 */
/* static */int
CF_Log_Local_Push (CF_LOG_CTX   * ctx,
                   const char   * buffer,
                   const size_t demandSize)
{
    if( ctx->size > 0 ) /* 버퍼단위 버퍼링.... */
    {
        size_t writeSize;
        size_t remainSize;

        remainSize = demandSize;
        while (remainSize)
        {
            writeSize = (ctx->size - ctx->length) < remainSize ? (ctx->size - ctx->length) : remainSize;

            memcpy (ctx->buffer + ctx->length, buffer + demandSize - remainSize, writeSize);
            ctx->length += writeSize;

            if (ctx->length == ctx->size)
                CF_Log_Local_Flush (ctx);

            remainSize -= writeSize;
        }
    }
    else /* flush되어야 함. */
    {
        if (CF_File_Write (ctx->fd, buffer, demandSize) < 0)
            return CF_ERROR_LOG_FLUSH;
    }

    return CF_OK;
}

/**
 * 로그를 사용하기 위해 초기화
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param logPool 아이디 넘버 최대 값
 */
int
CF_Log_Initialize (const int logPool)
{
    memset (&gLogEnvironment, 0x00, sizeof (CF_LOG_ENVIRONMENT));

    if (logPool > 0)
    {
        gLogEnvironment.ctxPool =
            (CF_Log_Ctx *) calloc ((size_t) logPool, sizeof (CF_Log_Ctx));
        if (gLogEnvironment.ctxPool == NULL)
            return CF_ERROR_LOG_INITIALIZE;
        gLogEnvironment.ctxSize = logPool;
    }

    return CF_OK;
}

/**
 * 로그가 모두 사용된 후 자원 해제
 *
 * @return CF_OK 반환
 */
int
CF_Log_Finalize (void)
{
    int mapid = 0;

    for (mapid = 0 ; mapid < gLogEnvironment.ctxSize ; mapid++)
    {
        CF_Log_UnmapCtxID (mapid);
    }

    if (gLogEnvironment.ctxPool != NULL)
        free (gLogEnvironment.ctxPool);

    memset (&gLogEnvironment, 0x00, sizeof (CF_LOG_ENVIRONMENT));

    return CF_OK;
}

/**
 * 로그 컨텍스트 생성
 *
 * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
 *
 * @param path      로그 파일 경로
 * @param memsize   로그 버퍼 크기
 *
 * @see CF_LOG_BUFFER_DEFAULT, CF_LOG_BUFFER_NO
 */
CF_Log_Ctx
CF_Log_CreateCtx (const char    * path,
                  const int     memsize)
{
    int result = 0;
    int size = (memsize == CF_LOG_BUFFER_DEFAULT)
             ? CF_LOG_BUFFER_DEFAULT_SIZE
             : memsize;
    CF_LOG_CTX  * context = NULL;

    if (path == NULL)
        return NULL;

    TRY
    {
        context = (CF_LOG_CTX *) calloc (sizeof (CF_LOG_CTX), 1);
        if (context == NULL)
        {
            result = -1;
            TRY_BREAK;
        }

        context->fd = CF_File_Create (path);
        if (context->fd < 0)
        {
            result = -2;
            TRY_BREAK;
        }
        sprintf (context->path, "%s", path);

        if (size > 0)
        {
            context->buffer = (char *) calloc ((size_t) size + 1, 1);
            if (context->buffer == NULL)
            {
                result = -3;
                TRY_BREAK;
            }
            context->size = (size_t) size;
        }
    }
    CATCH_IF (result < 0)
    {
        CF_Log_DestroyCtx ((CF_Log_Ctx) context);
        return NULL;
    }

    return (CF_Log_Ctx) context;
}

/**
 * 로그 컨텍스트 해제
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드 
 *
 * @param ctx 로그 컨텍스트
 */
int
CF_Log_DestroyCtx (CF_Log_Ctx ctx)
{
    CF_LOG_CTX * context = (CF_LOG_CTX *) ctx;

    if (CHECK_INVALID_CTX (ctx))
        return CF_ERROR_LOG_INVALID_CTX;

    memset (context->path, 0x00, sizeof (context->path));

    if (context->buffer != NULL)
    {
        CF_Log_Flush (ctx);
        free (context->buffer);
        context->buffer = NULL;
        context->size = 0;
    }

    CF_File_Close (context->fd);

    if (context->mutex != NULL)
    {
        if (CF_Mutex_Destory (&context->mutex) < 0)
            /* do something ? */;

        context->mutex = NULL;
    }

    return CF_OK;
}

/**
 * 로그 컨텍스트에 멀티쓰레드 모드 설정
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드 
 *
 * @param ctx 로그 컨텍스트
 */
int
CF_Log_SetMultiThread (CF_Log_Ctx ctx)
{
    CF_LOG_CTX * context = (CF_LOG_CTX *) ctx;

    if (CHECK_INVALID_CTX (ctx))
        return CF_ERROR_LOG_INVALID_CTX;

    if (CF_Mutex_Create (&context->mutex) < 0)
        return CF_ERROR_LOG_SET_MULTITHREAD;

    return CF_OK;
}

/**
 * 로그 컨텍스트에 멀티쓰레드 모드 설정 해제
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드 
 *
 * @param ctx 로그 컨텍스트
 */
int
CF_Log_UnsetMultiThread (CF_Log_Ctx ctx)
{
    CF_LOG_CTX * context = (CF_LOG_CTX *) ctx;

    if (CHECK_INVALID_CTX (ctx))
        return CF_ERROR_LOG_INVALID_CTX;

    if (CF_Mutex_Destory (&context->mutex) < 0)
        return CF_ERROR_LOG_UNSET_MULTITHREAD;

    return CF_OK;
}

/**
 * 로그 컨텍스트에 따라 로그 쓰기
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx       로그 컨텍스트
 * @param prefix    로그의 프리픽스 문자열
 * @param fmt       포맷 스트링
 * @param ...       가변 인자
 */
int
CF_Log_Write (CF_Log_Ctx    ctx,
              const char    * prefix,
              const char    * fmt, ...)
{
    CF_LOG_CTX  * context = (CF_LOG_CTX *) ctx;
    va_list     valist;
    char        buffer[16 * 1024] = {0x00,};
    char        datetime[CF_LOG_DATETIME_LENGTH + 1] = {0x00,};

    if (CHECK_INVALID_CTX (ctx))
        return CF_ERROR_LOG_INVALID_CTX;

    LOCK_LOG_CTX (context);
    va_start (valist, fmt);

    CF_Log_Local_GetTimeString (datetime);
    sprintf (buffer, "[%s][%s] ", datetime, prefix);
    vsprintf (buffer + strlen (buffer), fmt, valist);

    CF_Log_Local_Push (context, buffer, strlen (buffer));

    va_end (valist);
    UNLOCK_LOG_CTX (context);

    return CF_OK;
}

/**
 * 로그 버퍼의 데이터를 즉시 로그 파일에 쓰기
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx 로그 컨텍스트
 */
int
CF_Log_Flush (CF_Log_Ctx ctx)
{
    CF_LOG_CTX * context = (CF_LOG_CTX *) ctx;

    if (CHECK_INVALID_CTX (ctx))
        return CF_ERROR_LOG_INVALID_CTX;

    LOCK_LOG_CTX (context);
    CF_Log_Local_Flush (context);
    UNLOCK_LOG_CTX (context);

    return CF_OK;
}

/**
 * 로그 컨텍스트에 아이디 넘버 할당<br />
 * 로그 기록 시, 아이디 넘버를 사용하면 해당 로그로 기록할 수 있음
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param mapid 부여할 아이디 넘버
 * @param ctx   로그 컨텍스트
 *
 * @remark 반드시 먼저 초기화 해야하며, 초기화 시에 주어진 번호보다 작은 아이디 넘버를 사용해야 함
 *
 * @see CF_LOG_OPEN, CF_Log_CreateCtx
 */
int
CF_Log_MapCtxID (const int          mapid,
                 const CF_Log_Ctx   ctx)
{
    int result = 0;

    TRY
    {
        if (CHECK_INITIALIZED())
        {
            result = CF_ERROR_LOG_NOT_INITIALIZE;
            TRY_BREAK;
        }
        if (CHECK_INVALID_MAPID(mapid))
        {
            result = CF_ERROR_LOG_INVALID_MAPID;
            TRY_BREAK;
        }
        if (CHECK_MAPPED_ID(mapid))
        {
            result = CF_ERROR_LOG_ALREADY_MAPPED_ID;
            TRY_BREAK;
        }
    }
    CATCH_IF (result < 0)
    {
        CF_Log_DestroyCtx (ctx);
        return result;
    }

    gLogEnvironment.ctxPool[mapid] = ctx;

    return CF_OK;
}

/**
 * 아이디 넘버에 해당하는 로그를 닫고 해당하는 컨텍스트를 해제
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param mapid 로그의 아이디 넘버
 *
 * @remark 아이디 넘버에 해당하는 컨텍스트가 해제되므로 주의
 *
 * @see CF_LOG_CLOSE, CF_Log_DestroyCtx
 */
int
CF_Log_UnmapCtxID (const int mapid)
{
    if (CHECK_INITIALIZED())
        return CF_ERROR_LOG_NOT_INITIALIZE;
    if (CHECK_INVALID_MAPID(mapid))
        return CF_ERROR_LOG_INVALID_MAPID;
    if (!CHECK_MAPPED_ID(mapid))
        return CF_ERROR_LOG_NOT_MAPPED_ID;

    CF_Log_DestroyCtx (gLogEnvironment.ctxPool[mapid]);

    free (gLogEnvironment.ctxPool[mapid]);
    gLogEnvironment.ctxPool[mapid] = NULL;

    return CF_OK;
}

/**
 * 아이디 넘버에 해당하는 로그 컨텍스트를 얻기
 *
 * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
 *
 * @param mapid 로그의 아이디 넘버
 */
CF_Log_Ctx
CF_Log_GetMappedCtx (const int mapid)
{
    if (CHECK_INITIALIZED())
        return NULL;
    if (CHECK_INVALID_MAPID(mapid))
        return NULL;
    if (!CHECK_MAPPED_ID(mapid))
        return NULL;

    return gLogEnvironment.ctxPool[mapid];
}