source: libcf/trunk/src/cf_debug.c@ 53

/**
 * @file    cf_debug.c
 * @author  myusgun <myusgun@gmail.com>
 * @version 0.1
 */
#include "cf_debug.h"
#include "cf_local.h"
#include "cf_error.h"
#include "cf_thread.h"

#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#include <string.h>

#if defined(_WIN32) || defined(_WIN64)
# include <io.h>
#else
# include <unistd.h>
#endif

#define IS_READABLE_CHAR(__c)       (' ' <= __c && __c <= '~')

#define CHECK_INVALID_CTX(__ctx)            \
    if (__ctx == NULL)                      \
        return CF_ERROR_DEBUG_INVALID_CTX

#define GET_CTX_OSTREAM(__ctx)              \
    ((((CF_DEBUG_CTX *)__ctx)->fp == NULL)  \
     ? stderr                               \
     : ((CF_DEBUG_CTX *)__ctx)->fp)

/**
 * 디버그 컨텍스트
 * 
 * @remark change from public to private
 */
typedef void *  CF_Debug_Ctx;

/* *
 * 콜스택 데이터
 * 
 * @remark change from public to private
 */
typedef struct cf_debug_callStack {
    char    file[NAME_LENGTH + 1];      /* *< 파일 이름 */
    char    function[NAME_LENGTH + 1];  /* *< 함수 이름 */
    int     line;                       /* *< 라인 넘버 */
} CF_Debug_CallStack;

typedef struct __cf_debug_callstack__
{
    char    file[NAME_LENGTH + 1];
    char    func[NAME_LENGTH + 1];
    int     line;

    int     frameIndex;

    struct __cf_debug_callstack__   * caller;
} S_CF_DEBUG_CALLSTACK, CF_DEBUG_CALLSTACK;

typedef struct __cf_debug_ctx__
{
    char        file[NAME_LENGTH + 1];
    char        func[NAME_LENGTH + 1];
    int         line;

    FILE        * fp;
    CF_Mutex    mutex;

    CF_DEBUG_CALLSTACK  callstack;
} S_CF_DEBUG_CTX, CF_DEBUG_CTX;

CF_Debug_Ctx    gDebugSingleCtx = NULL;

static int
CF_Debug_Local_UpdateCtx (CF_Debug_Ctx  ctx,
                          const char    * file,
                          const char    * func,
                          const int     line)
{
    CF_DEBUG_CTX * context = (CF_DEBUG_CTX *) ctx;

    CHECK_INVALID_CTX (ctx);

    strncpy (context->file, file, strlen (file));
    strncpy (context->func, func, strlen (func));
    context->line = line;

    return CF_OK;
}

static int
CF_Debug_Local_Print (FILE          * fp,
                      const char    * file,
                      const char    * func,
                      const int     line,
                      const char    * fmt,
                      va_list       valist)
{
    fprintf (fp, "[DEBUG][%s:%d][%s] ", file, line, func);
    vfprintf (fp, fmt, valist);

    return CF_OK;
}

static int
CF_Debug_Local_PrintBin (FILE                   * fp,
                         const char             * file,
                         const char             * func,
                         const int              line,
                         const unsigned char    * bin,
                         const int              len)
{
    int i, j;

    for (i = 0 ; i < len ; i += 16)
    {
        fprintf (fp, "[DEBUG][%s:%d][%s] ", file, line, func);
        fprintf (fp, "%06x : ", i);

        for (j = 0 ; j < 16 ; j++)
        {
            if (i+j < len)
                fprintf (fp, "%02x ", bin[i+j]);
            else
                fprintf (fp, "   ");
        }
        fprintf (fp, " ");

        for (j = 0 ; j < 16 ; j++)
        {
            if (i+j < len)
                fprintf (fp, "%c", IS_READABLE_CHAR(bin[i+j]) ? bin[i+j] : '.');
        }
        fprintf (fp, "\n");
    }

    return CF_OK;
}

/**
 * 디버그 컨텍스트를 해제
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx 디버그 컨텍스트
 *
 * @see CF_DEBUG_DESTROY_CTX
 */
static int
CF_Debug_DestroyCtx (CF_Debug_Ctx ctx)
{
    CF_DEBUG_CTX        * context = (CF_DEBUG_CTX *) ctx;
    CF_DEBUG_CALLSTACK  * pop = NULL;
    CF_DEBUG_CALLSTACK  * next = NULL;

    CHECK_INVALID_CTX (ctx);

    if (context->fp != NULL)
        fclose (context->fp);

    for (pop = next = context->callstack.caller ; pop ; pop = next)
    {
        next = next->caller;
        free (pop);
    }

    if (context->mutex)
        CF_Mutex_Destory (&context->mutex);

    free (context);

    return CF_OK;
}

/**
 * 디버그 컨텍스트를 생성
 *
 * @return 성공 시, CF_Debug_Ctx 형태의 컨텍스트; 실패 시, NULL
 * @see CF_DEBUG_CREATE_CTX
 */
static int
CF_Debug_CreateCtx (CF_Debug_Ctx * ctx)
{
    int             result = 0;
    CF_DEBUG_CTX    * context = NULL;

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

        result = CF_Mutex_Create (&context->mutex);
        if (result < 0)
        {
            TRY_BREAK;
        }

        *ctx = (CF_Debug_Ctx) context;
    }
    CATCH_IF (result < 0)
    {
        CF_Debug_DestroyCtx (context);
    }

    return CF_OK;
}

/**
 * 디버그 메시지를 지정된 파일 포인터로 출력
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
 * @param file  파일 경로
 * @param func  함수 이름
 * @param line  라인 넘버
 * @param fmt   포맷 스트링
 * @param ...   가변 인자
 *
 * @see CF_DEBUG_PRINT
 */
int
CF_Debug_Print (FILE        * fp,
                const char  * file,
                const char  * func,
                const int   line,
                const char  * fmt, ...)
{
    va_list valist;

    va_start (valist, fmt);
    CF_Debug_Local_Print (fp, file, func, line, fmt, valist);
    va_end (valist);

    return CF_OK;
}

/**
 * 바이너리 데이터를 디버그 메시지와 함께 지정된 파일 포인터로 출력
 *
 * @return CF_OK 반환
 *
 * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
 * @param file  파일 경로
 * @param func  함수 이름
 * @param line  라인 넘버
 * @param bin   라인 넘버
 * @param len   바이너리 길이
 * @param fmt   포맷 스트링
 * @param ...   가변 인자
 *
 * @see CF_DEBUG_PRINT_BIN
 */
int
CF_Debug_PrintBin (FILE                 * fp,
                   const char           * file,
                   const char           * func,
                   const int            line,
                   const unsigned char  * bin,
                   const int            len,
                   const char           * fmt, ...)
{
    va_list valist;

    va_start (valist, fmt);
    CF_Debug_Local_Print (fp, file, func, line, fmt, valist);
    va_end (valist);

    CF_Debug_Local_PrintBin (fp, file, func, line, bin, len);

    return CF_OK;
}

/**
 * 컨텍스트에 콜스택 푸시
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx   디버그 컨텍스트
 * @param file  파일 경로
 * @param func  함수 이름
 * @param line  라인 넘버
 */
static int
CF_Debug_CallStackPush (CF_Debug_Ctx    ctx,
                        const char      * file,
                        const char      * func,
                        const int       line)
{
    CF_DEBUG_CTX        * context = (CF_DEBUG_CTX *) ctx;
    CF_DEBUG_CALLSTACK  * push = NULL;

    CHECK_INVALID_CTX (ctx);

    push = (CF_DEBUG_CALLSTACK *) calloc (sizeof (CF_DEBUG_CALLSTACK), 1);
    if (push == NULL)
        return CF_ERROR_DEBUG_PUSH_CALLSTACK;

    /* push to callstack */
    sprintf (push->file, "%s", file);
    sprintf (push->func, "%s", func);
    push->line = line;
    push->caller = context->callstack.caller;
    push->frameIndex = push->caller == NULL
                     ? 0
                     : push->caller->frameIndex + 1;
    context->callstack.caller = push;

    CF_Debug_Local_UpdateCtx (ctx, file, func, line);

    return CF_OK;
}

/**
 * 컨텍스트에서 콜스택에서 TOP을 제거하지 않고 가져옴
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx       디버그 컨텍스트
 * @param callstack 콜스택 정보를 가져올 콜스택 데이터 구조체 포인터
 *
 * @see CF_Debug_CallStack
 */
static int
CF_Debug_CallStackPeek (CF_Debug_Ctx        ctx,
                        CF_Debug_CallStack  * callstack)
{
    CF_DEBUG_CTX        * context = (CF_DEBUG_CTX *) ctx;
    CF_DEBUG_CALLSTACK  * pop = NULL;

    pop = context->callstack.caller;
    if (pop == NULL)
        return CF_ERROR_DEBUG_PEEK_CALLSTACK;

    if (callstack != NULL)
    {
        sprintf (callstack->file    , "%s", pop->file);
        sprintf (callstack->function, "%s", pop->func);
        callstack->line = pop->line;
    }

    return CF_OK;
}

/**
 * 컨텍스트에서 콜스택 팝
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param ctx       디버그 컨텍스트
 * @param callstack 콜스택 정보를 가져올 콜스택 데이터 구조체 포인터
 *
 * @see CF_Debug_CallStack
 */
static int
CF_Debug_CallStackPop (CF_Debug_Ctx         ctx,
                       CF_Debug_CallStack   * callstack)
{
    CF_DEBUG_CTX        * context = (CF_DEBUG_CTX *) ctx;
    CF_DEBUG_CALLSTACK  * pop = NULL;

    CHECK_INVALID_CTX (ctx);

    pop = context->callstack.caller;
    if (pop == NULL)
        return CF_ERROR_DEBUG_POP_CALLSTACK;

    if (CF_Debug_CallStackPeek (ctx, callstack) < 0)
        return CF_ERROR_DEBUG_PEEK_CALLSTACK;

    memset (context->file, 0x00, sizeof (context->file));
    memset (context->func, 0x00, sizeof (context->func));
    context->line = 0;

    /* restore current context */
    if (pop->caller != NULL)
    {
        CF_Debug_Local_UpdateCtx (ctx,
                                  pop->caller->file,
                                  pop->caller->func, 
                                  pop->caller->line);
    }

    context->callstack.caller = pop->caller;
    free (pop);

    return CF_OK;
}

/**
 * 현재 콜스택을 출력
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param fp 출력 할 파일 포인터
 */
int
CF_Debug_PrintCallStack (FILE * fp)
{
    int iter = 0;

    CF_DEBUG_CTX        * ctx = gDebugSingleCtx;
    CF_DEBUG_CALLSTACK  * callstack = NULL;

    if (ctx == NULL)
        return CF_ERROR_DEBUG_INVALID_CTX;

    for ( callstack = ctx->callstack.caller
        ; callstack
        ; callstack = callstack->caller)
    {
        fprintf (fp, "#%-4d %s <%s:%d>\n",
                     iter++,
                     callstack->func,
                     callstack->file,
                     callstack->line);
    }

    return CF_OK;
}

/**
 * 함수 진입을 명시
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @param file  파일 경로
 * @param func  함수 이름
 * @param line  라인 넘버
 *
 * @see CF_Debug_LeaveFunction
 */
int
CF_Debug_EnterFunction (const char  * file,
                        const char  * func,
                        const int   line)
{
    int             result = 0;
    CF_DEBUG_CTX    * ctx = NULL;

    if (gDebugSingleCtx == NULL)
    {
        result = CF_Debug_CreateCtx (&gDebugSingleCtx);
        if (result != CF_OK)
            return result;
    }
    ctx = (CF_DEBUG_CTX *)gDebugSingleCtx;

    CF_Mutex_Lock (&ctx->mutex);
    CF_Debug_CallStackPush (gDebugSingleCtx, file, func, line);
    CF_Mutex_Unlock (&ctx->mutex);

    return CF_OK;
}

/**
 * 함수 종료를 명시
 *
 * @return 성공 시, CF_OK; 실패 시, 오류 코드
 *
 * @see CF_Debug_EnterFunction
 */
int
CF_Debug_LeaveFunction (void)
{
    CF_DEBUG_CTX * ctx = (CF_DEBUG_CTX *)gDebugSingleCtx;

    if (ctx == NULL)
        return CF_ERROR_DEBUG_INVALID_CTX;

    CF_Mutex_Lock (&ctx->mutex);
    CF_Debug_CallStackPop (gDebugSingleCtx, NULL);
    CF_Mutex_Unlock (&ctx->mutex);

    return CF_OK;
}