Changeset 35 in libcf


Ignore:
Timestamp:
02/05/13 18:18:37 (11 years ago)
Author:
cheese
Message:

#1 separate example code and doxygen comment and fix logging push logic by vfire

Location:
trunk
Files:
6 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/docs/doxyfile

    r33 r35  
    441441# function's detailed documentation block.
    442442
    443 HIDE_IN_BODY_DOCS      = NO
     443HIDE_IN_BODY_DOCS      = YES
    444444
    445445# The INTERNAL_DOCS tag determines if documentation
    … …  
    679679
    680680INPUT                  = ../include \
    681 #                         ../src
     681                         ../src
    682682
    683683# This tag can be used to specify the character encoding of the source files
    … …  
    740740# the \include command).
    741741
    742 EXAMPLE_PATH           =
     742EXAMPLE_PATH           = ../test
    743743
    744744# If the value of the EXAMPLE_PATH tag contains directories, you can use the

  • trunk/include/cf_debug.h

    r34 r35  
    1212 * (단, 콜스택의 푸시/팝은 컨텍스트를 이용해야만 사용 가능)
    1313 *
    14  * @section 샘플코드
    15  * @code
    16 
    17 #include "cf_debug.h"
    18 
    19 CF_Debug_Ctx gDebugCtx;
    20 
    21 void callee (void) {
    22     CF_Debug_CallStack callstack;
    23    
    24     CF_DEBUG_CALLSTACK_PUSH (gDebugCtx);
    25     CF_DEBUG_CALLSTACK_POP (gDebugCtx, &callstack);
    26 }
    27 
    28 int main (void) {
    29     int fd = 0;
    30     gDebugCtx = CF_Debug_CreateCtx ();
    31 
    32     CF_DEBUG_CALLSTACK_PUSH (gDebugCtx);
    33 
    34     CF_DEBUG_TRACE (gDebugCtx, "print trace message with context to stderr\n");
    35 
    36     fd = CF_File_Create ("debug.txt");
    37     if (fd < 0) {
    38         CF_DEBUG_PRINT (stderr, "error ...\n");
    39         // error
    40     }
    41     CF_Debug_SetOutputFD (gDebugCtx, fd);
    42 
    43     CF_DEBUG_TRACE (gDebugCtx, "print trace message with context to debug.txt\n");
    44 
    45     CF_DEBUG_CALLSTACK_POP (gDebugCtx, NULL);
    46 
    47     CF_Debug_DestroyCtx (gDebugCtx);
    48 
    49     return 0;
    50 }
    51 
    52  * @endcode
     14 * @example debug.c
    5315 */
    5416#ifndef __CF_DEBUG_H__
    … …  
    186148#endif
    187149
    188 /**
    189  * 디버그 컨텍스트를 생성
    190  *
    191  * @return 성공 시, CF_Debug_Ctx 형태의 컨텍스트; 실패 시, NULL
    192  * @see CF_DEBUG_CREATE_CTX
    193  */
    194150CF_EXPORT CF_Debug_Ctx
    195151CF_Debug_CreateCtx      (void);
    196152
    197 /**
    198  * 디버그 컨텍스트를 해제
    199  *
    200  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    201  *
    202  * @param ctx 디버그 컨텍스트
    203  *
    204  * @see CF_DEBUG_DESTROY_CTX
    205  */
    206153CF_EXPORT int
    207154CF_Debug_DestroyCtx     (CF_Debug_Ctx ctx);
    208155
    209 /**
    210  * 디버그 컨텍스트에 출력할 파일 디스크립터를 설정
    211  *
    212  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    213  *
    214  * @param ctx   디버그 컨텍스트
    215  * @param fd    파일 디스크립터
    216  *
    217  * @see CF_File_Open, CF_File_Create
    218  */
    219156CF_EXPORT int
    220157CF_Debug_SetOutputFD    (CF_Debug_Ctx   ctx,
    221158                         int            fd);
    222159
    223 /**
    224  * 디버그 메시지를 지정된 파일 포인터로 출력
    225  *
    226  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    227  *
    228  * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
    229  * @param file  파일 경로
    230  * @param func  함수 이름
    231  * @param line  라인 넘버
    232  * @param fmt   포맷 스트링
    233  * @param ...   가변 인자
    234  *
    235  * @see CF_DEBUG_PRINT
    236  */
    237160CF_EXPORT int
    238161CF_Debug_Print          (FILE       * fp,
    … …  
    242165                         const char * fmt, ...);
    243166
    244 /**
    245  * 바이너리 데이터를 디버그 메시지와 함께 지정된 파일 포인터로 출력
    246  *
    247  * @return CF_OK 반환
    248  *
    249  * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
    250  * @param file  파일 경로
    251  * @param func  함수 이름
    252  * @param line  라인 넘버
    253  * @param bin   라인 넘버
    254  * @param len   바이너리 길이
    255  * @param fmt   포맷 스트링
    256  * @param ...   가변 인자
    257  *
    258  * @see CF_DEBUG_PRINT_BIN
    259  */
    260167CF_EXPORT int
    261168CF_Debug_PrintBin       (FILE                   * fp,
    … …  
    267174                         const char             * fmt, ...);
    268175
    269 /**
    270  * 컨텍스트를 업데이트하고 디버그 메시지를 출력
    271  *
    272  * @return CF_OK 반환
    273  *
    274  * @param ctx   디버그 컨텍스트
    275  * @param file  파일 경로
    276  * @param func  함수 이름
    277  * @param line  라인 넘버
    278  * @param fmt   포맷 스트링
    279  * @param ...   가변 인자
    280  *
    281  * @see CF_DEBUG_UPDATE_CTX, CF_Debug_Trace
    282  */
    283176CF_EXPORT int
    284177CF_Debug_Trace          (CF_Debug_Ctx   ctx,
    … …  
    288181                         const char     * fmt, ...);
    289182
    290 /**
    291  * 컨텍스트를 업데이트하고 바이너리 데이터를 디버그 메시지와 함께 출력
    292  *
    293  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    294  *
    295  * @param ctx   디버그 컨텍스트
    296  * @param file  파일 경로
    297  * @param func  함수 이름
    298  * @param line  라인 넘버
    299  * @param bin   바이너리 데이터
    300  * @param len   바이너리 길이
    301  * @param fmt   포맷 스트링
    302  * @param ...   가변 인자
    303  *
    304  * @see CF_DEBUG_UPDATE_CTX, CF_DEBUG_TRACE_BIN
    305  */
    306183CF_EXPORT int
    307184CF_Debug_TraceBin       (CF_Debug_Ctx           ctx,
    … …  
    313190                         const char             * fmt, ...);
    314191
    315 /**
    316  * 컨텍스트에 콜스택 푸시
    317  *
    318  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    319  *
    320  * @param ctx   디버그 컨텍스트
    321  * @param file  파일 경로
    322  * @param func  함수 이름
    323  * @param line  라인 넘버
    324  *
    325  * @see CF_DEBUG_CALLSTACK_PUSH
    326  */
    327192CF_EXPORT int
    328193CF_Debug_CallStackPush  (CF_Debug_Ctx   ctx,
    … …  
    331196                         const int      line);
    332197
    333 /**
    334  * 컨텍스트에서 콜스택 팝
    335  *
    336  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    337  *
    338  * @param ctx       디버그 컨텍스트
    339  * @param callstack 콜스택 정보를 가져올 콜스택 데이터 구조체 포인터
    340  *
    341  * @see CF_Debug_CallStackPop, CF_Debug_CallStack
    342  */
    343198CF_EXPORT int
    344199CF_Debug_CallStackPop   (CF_Debug_Ctx       ctx,

  • trunk/include/cf_file.h

    r34 r35  
    44 * @version 0.1
    55 *
    6  * @section 샘플코드
    7  * @code
    8 
    9 #include "cf_file.h"
    10 
    11 int main (void) {
    12     int fd = 0;
    13     char *name = "file.txt";
    14     char buffer[128] = {0x00,};
    15 
    16     fd = CF_File_Create (name);
    17     if (fd < 0) {
    18         // error
    19     }
    20     if (CF_File_Write (fd, "file test", 9) < 0) {
    21         // error
    22     }
    23     CF_File_Close (fd);
    24 
    25     fd = CF_File_Open (name, CF_FILE_RO);
    26     if (fd < 0) {
    27         // error
    28     }
    29     printf ("file size : %d\n", CF_File_GetSize (fd));
    30     if (CF_File_Read (fd, buffer, sizeof (buffer)) < 0) {
    31         // error
    32     }
    33     CF_File_Close (fd);
    34 
    35     return 0;
    36 }
    37 
    38  * @endcode
     6 * @example file.c
    397 */
    408#ifndef __CF_FILE_H__
    … …  
    6634#endif
    6735
    68 /**
    69  * 파일 열기
    70  *
    71  * @return 성공 시, 파일 디스크립터; 실패 시, 오류 코드
    72  *
    73  * @param path  파일 경로
    74  * @param flag  파일 열기 플래그
    75  *
    76  * @see CF_FILE_FLAG
    77  */
    7836CF_EXPORT int
    7937CF_File_Open            (const char         * path,
    8038                         const CF_FILE_FLAG flag);
    8139
    82 /**
    83  * 파일 닫기
    84  *
    85  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    86  *
    87  * @param fd 파일 디스크립터
    88  */
     40CF_EXPORT int
     41CF_File_Create          (const char * path);
     42
    8943CF_EXPORT int
    9044CF_File_Close           (const int fd);
    9145
    92 /**
    93  * 파일 생성
    94  *
    95  * @return 성공 시, 파일 디스크립터; 실패 시, 오류 코드
    96  *
    97  * @param path  파일 경로
    98  */
    99 CF_EXPORT int
    100 CF_File_Create          (const char * path);
    101 
    102 /**
    103  * 파일 읽기
    104  *
    105  * @return 성공 시, 읽은 바이트 수; 실패 시, 오류 코드
    106  *
    107  * @param fd    파일 디스크립터
    108  * @param buf   데이터를 저장할 메모리
    109  * @param len   데이터를 저장할 메모리의 크기
    110  */
    11146CF_EXPORT int
    11247CF_File_Read            (const int      fd,
    … …  
    11449                         const size_t   len);
    11550
    116 /**
    117  * 파일 쓰기
    118  *
    119  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    120  *
    121  * @param fd    파일 디스크립터
    122  * @param buf   데이터가 저장된 메모리
    123  * @param len   쓸 데이터의 길이
    124  */
    12551CF_EXPORT int
    12652CF_File_Write           (const int      fd,
    … …  
    12854                         const size_t   len);
    12955
    130 /**
    131  * 파일 크기 얻기
    132  *
    133  * @return 성공 시, 파일 크기; 실패 시, 오류 코드
    134  *
    135  * @param fd    파일 디스크립터
    136  */
    13756CF_EXPORT int
    13857CF_File_GetSize         (const int fd);

  • trunk/include/cf_log.h

    r34 r35  
    44 * @version 0.1
    55 *
    6  * @section 샘플코드
    7  * @code
    8 
    9 #include "cf_log.h"
    10 
    11 CF_Log_Ctx gLogCtx;
    12 
    13 void main (const char * message)
    14 {
    15     int         i, j;
    16     char        logname[16] = {0x00,};
    17 
    18     CF_DEBUG_CALLSTACK_PUSH (gDebugCtx);
    19 
    20     CF_Log_Initialize (10);
    21 
    22     // with context
    23     gLogCtx = CF_Log_CreateCtx (file, CF_LOG_BUFFER_DEFAULT);
    24     if (gLogCtx == NULL)
    25         CF_DEBUG_PRINT (stderr, "create log ctx error\n");
    26 
    27     for (i = 0 ; i < 10000 ; i++)
    28         CF_Log_Write (gLogCtx, "LOG_TEST", "turn %d\n", i);
    29 
    30     CF_DEBUG_CALLSTACK_POP (gDebugCtx, &gDebugCallstack);
    31 
    32     CF_Log_Write (gLogCtx, message,
    33                             "here is the end of function [file:%s line:%d func:%s]\n",
    34                             gDebugCallstack.file,
    35                             gDebugCallstack.line,
    36                             gDebugCallstack.function);
    37 
    38     CF_Log_DestroyCtx (gLogCtx);
    39 
    40     // with id number
    41     for (i = 0 ; i < 10 ; i++)
    42     {
    43         sprintf (logname, "logid%d.txt", i);
    44         CF_LOG_OPEN (i, logname, CF_LOG_BUFFER_NO);
    45     }
    46 
    47     for (i = 0 ; i < 10 ; i++)
    48     {
    49         for (j = 0 ; j < 10000 ; j++)
    50             CF_LOG_WRITE (i, "LOG_ID_TEST", "turn %d\n", j);
    51 
    52         CF_LOG_CLOSE (i);
    53     }
    54 
    55     CF_Log_Finalize ();
    56 }
    57 
    58  * @endcode
     6 * @example log.c
    597 */
    608#ifndef __CF_LOG_H__
    … …  
    13078#endif
    13179
    132 /**
    133  * 로그를 사용하기 위해 초기화
    134  *
    135  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    136  *
    137  * @param logPool 아이디 넘버 최대 값
    138  */
    13980CF_EXPORT int
    14081CF_Log_Initialize       (const int logPool);
    14182
    142 /**
    143  * 로그가 모두 사용된 후 자원 해제
    144  *
    145  * @return CF_OK 반환
    146  */
    14783CF_EXPORT int
    14884CF_Log_Finalize         (void);
    14985
    150 /**
    151  * 로그 컨텍스트 생성
    152  *
    153  * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
    154  *
    155  * @param path      로그 파일 경로
    156  * @param memsize   로그 버퍼 크기
    157  *
    158  * @see CF_LOG_BUFFER_DEFAULT, CF_LOG_BUFFER_NO
    159  */
    16086CF_EXPORT CF_Log_Ctx
    16187CF_Log_CreateCtx        (const char * path,
    16288                         const int  memsize);
    16389
    164 /**
    165  * 로그 컨텍스트 해제
    166  *
    167  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    168  *
    169  * @param ctx 로그 컨텍스트
    170  */
    17190CF_EXPORT int
    17291CF_Log_DestroyCtx       (CF_Log_Ctx ctx);
    17392
    174 /**
    175  * 로그 컨텍스트에 멀티쓰레드 모드 설정
    176  *
    177  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    178  *
    179  * @param ctx 로그 컨텍스트
    180  */
    18193CF_EXPORT int
    18294CF_Log_SetMultiThread   (CF_Log_Ctx ctx);
    18395
    184 /**
    185  * 로그 컨텍스트에 멀티쓰레드 모드 설정 해제
    186  *
    187  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    188  *
    189  * @param ctx 로그 컨텍스트
    190  */
    19196CF_EXPORT int
    19297CF_Log_UnsetMultiThread (CF_Log_Ctx ctx);
    19398
    194 /**
    195  * 로그 컨텍스트에 따라 로그 쓰기
    196  *
    197  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    198  *
    199  * @param ctx       로그 컨텍스트
    200  * @param prefix    로그의 프리픽스 문자열
    201  * @param fmt       포맷 스트링
    202  * @param ...       가변 인자
    203  */
    20499CF_EXPORT int
    205100CF_Log_Write            (CF_Log_Ctx ctx,
    … …  
    207102                         const char * fmt, ...);
    208103
    209 /**
    210  * 로그 버퍼의 데이터를 즉시 로그 파일에 쓰기
    211  *
    212  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    213  *
    214  * @param ctx 로그 컨텍스트
    215  */
    216104CF_EXPORT int
    217105CF_Log_Flush            (CF_Log_Ctx ctx);
    218106
    219 /**
    220  * 로그 컨텍스트에 아이디 넘버 할당<br />
    221  * 로그 기록 시, 아이디 넘버를 사용하면 해당 로그로 기록할 수 있음
    222  *
    223  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    224  *
    225  * @param mapid 부여할 아이디 넘버
    226  * @param ctx   로그 컨텍스트
    227  *
    228  * @remark 반드시 먼저 초기화 해야하며, 초기화 시에 주어진 번호보다 작은 아이디 넘버를 사용해야 함
    229  *
    230  * @see CF_LOG_OPEN, CF_Log_CreateCtx
    231  */
    232107CF_EXPORT int
    233108CF_Log_MapCtxID         (const int          mapid,
    234109                         const CF_Log_Ctx   ctx);
    235110
    236 /**
    237  * 아이디 넘버에 해당하는 로그를 닫고 해당하는 컨텍스트를 해제
    238  *
    239  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    240  *
    241  * @param mapid 로그의 아이디 넘버
    242  *
    243  * @remark 아이디 넘버에 해당하는 컨텍스트가 해제되므로 주의
    244  *
    245  * @see CF_LOG_CLOSE, CF_Log_DestroyCtx
    246  */
    247111CF_EXPORT int
    248112CF_Log_UnmapCtxID       (const int mapid);
    249113
    250 /**
    251  * 아이디 넘버에 해당하는 로그 컨텍스트를 얻기
    252  *
    253  * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
    254  *
    255  * @param mapid 로그의 아이디 넘버
    256  */
    257114CF_EXPORT CF_Log_Ctx
    258115CF_Log_GetMappedCtx     (const int mapid);

  • trunk/include/cf_socket.h

    r34 r35  
    66 * @remark TCP 소켓만 지원됨
    77 *
    8  * @section 샘플코드(서버)
    9  * @code
    10 
    11 #include "cf_socket.h"
    12 
    13 int main (void) {
    14     int srvsock = 0;
    15     int clntsock = 0;
    16     short port = 12345;
    17     int recvd = 0;
    18     char buf[1024] = {0x00,};
    19 
    20     if (CF_Socket_Initialize () < 0) {
    21         // error
    22     }
    23     srvsock = CF_Socket_Server (port, 5);
    24     if (srvsock < 0) {
    25         // error
    26     }
    27     clntsock = CF_Socket_Accept (srvsock, NULL);
    28     if (clntsock < 0) {
    29         // error
    30     }
    31     if ((recvd = CF_Socket_Recv (clntsock, buf, sizeof (buf))) < 0) {
    32         // error
    33     }
    34     if (CF_Socket_Send (clntsock, buf, recvd) < 0) {
    35         // error
    36     }
    37     CF_Socket_Close (srvsock);
    38     CF_Socket_Finalize ();
    39 
    40     return 0;
    41 }
    42 
    43  * @endcode
    44  *
    45  * @section 샘플코드(클라이언트)
    46  * @code
    47 
    48 #include "cf_socket.h"
    49 
    50 int main (void) {
    51     int sock = 0;
    52     int recvd = 0;
    53     char buf[1024] = {0x00,};
    54     short port = 12345;
    55 
    56     if (CF_Socket_Initialize () < 0) {
    57         // error
    58     }
    59     sock = CF_Socket_Connect ("localhost", port);
    60     if (sock < 0) {
    61         // error
    62     }
    63     if (CF_Socket_Send (sock, buf, sizeof (buf)) < 0) {
    64         // error
    65     }
    66     if ((recvd = CF_Socket_Recv (sock, buf, sizeof (buf))) < 0) {
    67         // error
    68     }
    69     CF_Socket_Close (sock);
    70     CF_Socket_Finalize ();
    71 
    72     return 0;
    73 }
    74 
    75  * @endcode
     8 * @example socket_server.c
     9 * @example socket_client.c
    7610 */
    7711#ifndef __CF_SOCKET_H__
    … …  
    11751#endif
    11852
    119 /**
    120  * 소켓이 초기화 상태 확인
    121  *
    122  * @return 초기화 된 경우, CF_TRUE; 그렇지 않은 경우, CF_FALSE
    123  */
    12453CF_EXPORT CF_BOOL
    12554CF_Socket_IsInitialized (void);
    12655
    127 /**
    128  * 소켓 초기화
    129  *
    130  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    131  */
    13256CF_EXPORT int
    13357CF_Socket_Initialize    (void);
    13458
    135 /**
    136  * 소켓 해제
    137  *
    138  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    139  */
    14059CF_EXPORT int
    14160CF_Socket_Finalize      (void);
    14261
    143 /**
    144  * 소켓 닫기
    145  *
    146  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    147  *
    148  * @param sock 소켓
    149  */
    15062CF_EXPORT int
    15163CF_Socket_Close         (const int sock);
    15264
    153 /**
    154  * 소켓 옵션 설정
    155  *
    156  * @return 성공 시 CF_OK; 실패 시, 오류 코드
    157  *
    158  * @param sock      소켓
    159  * @param optname   옵션 이름
    160  * @param optval    설정할 옵션 값의 메모리
    161  * @param optlen    설정할 옵션의 길이
    162  */
    16365CF_EXPORT int
    16466CF_Socket_SetOption     (const int      sock,
    … …  
    16769                         const size_t   optlen);
    16870
    169 /**
    170  * 소켓 옵션 얻기
    171  *
    172  * @return 성공 시 CF_OK; 실패 시, 오류 코드
    173  *
    174  * @param sock      소켓
    175  * @param optname   옵션 이름
    176  * @param optval    옵션 값을 가져올 메모리
    177  * @param optlen    옵션 길이를 가져올 메모리
    178  */
    17971CF_EXPORT int
    18072CF_Socket_GetOption     (const int  sock,
    … …  
    18375                         size_t     * optlen);
    18476
    185 /**
    186  * 소켓에 타임아웃 설정
    187  *
    188  * @return 성공 시 CF_OK; 실패 시, 오류 코드
    189  *
    190  * @param sock      소켓
    191  * @param timeout   타임아웃(sec)
    192  */
    19377CF_EXPORT int
    19478CF_Socket_SetTimeout    (const int  sock,
    19579                         const int  timeout);
    19680
    197 /**
    198  * 소켓 연결
    199  *
    200  * @return 성공 시, 연결된 소켓; 실패 시, 오류 코드
    201  *
    202  * @param ip    연결할 호스트의 주소 (도메인 이름 가능)
    203  * @param port  연결할 호스트의 포트번호
    204  */
    20581CF_EXPORT int
    20682CF_Socket_Connect       (const char             * ip,
    20783                         const unsigned short   port);
    20884
    209 /**
    210  * 서버 열기
    211  *
    212  * @return 성공 시, 서버 소켓; 실패 시, 오류 코드
    213  *
    214  * @param port      서버 포트
    215  * @param backlog   listen 시의 backlog 수
    216  */
    21785CF_EXPORT int
    21886CF_Socket_Server        (const unsigned short   port,
    21987                         const int              backlog);
    22088
    221 /**
    222  * 소켓 연결
    223  *
    224  * @return 성공 시, 연결된 소켓; 실패 시, 오류 코드
    225  *
    226  * @param sock      서버 소켓
    227  * @param address   [옵션] 클라이언트 정보를 담을 sockaddr_in 구조체 포인터
    228  */
    22989CF_EXPORT int
    23090CF_Socket_Accept        (const int          sock,
    23191                         struct sockaddr_in * address);
    23292
    233 /**
    234  * 데이터 송신
    235  *
    236  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    237  *
    238  * @param sock  소켓
    239  * @param buf   송신할 데이터
    240  * @param len   송신할 데이터의 길이
    241  */
    24293CF_EXPORT int
    24394CF_Socket_Send          (const int  sock,
    … …  
    24596                         const int  len);
    24697
    247 /**
    248  * 데이터 수신
    249  *
    250  * @return 성공 시, 수신한 데이터의 길이; 실패 시, 오류 코드
    251  *
    252  * @param sock  소켓
    253  * @param buf   데이터를 수신할 버퍼
    254  * @param len   데이터를 수신할 버퍼의 최대 크기
    255  */
    25698CF_EXPORT int
    25799CF_Socket_Recv          (const int  sock,

  • trunk/include/cf_thread.h

    r34 r35  
    66 * @remark 멀티스레드 및 뮤텍스 지원
    77 *
    8  * @section 샘플코드
    9  * @code
    10 
    11 #include "cf_thread.h"
    12 
    13 CF_Mutex globalMutex;
    14 
    15 CF_THREAD_RETURN CF_THREAD_CALL worker (void * arg) {
    16     if (CF_Mutex_Create (&globalMutex) < 0) {
    17         // error
    18     }
    19 
    20     if (CF_Mutex_Lock (&globalMutex) < 0) { // for critical section
    21         // error
    22     }
    23 
    24     // critical section
    25 
    26     if (CF_Mutex_Unlock (&globalMutex) < 0) { // for critical section
    27         // error
    28     }
    29 
    30     if (CF_Mutex_Destory (&globalMutex) < 0) {
    31         // error
    32     }
    33 }
    34 
    35 int main (void) {
    36     CF_Thread tid;
    37     if (CF_Thread_Create (&tid, worker, NULL) < 0) {
    38         // error
    39     }
    40 
    41     if (CF_Thread_Join (&tid) < 0) { // block
    42         // error
    43     }
    44 
    45     if (CF_Thread_Release (&tid) < 0) {
    46         // error
    47     }
    48     return 0;
    49 }
    50 
    51  * @endcode
     8 * @example thread.c
    529 */
    5310#ifndef __CF_THREAD_H__
    … …  
    8340#endif
    8441
    85 /**
    86  * 스레드를 생성
    87  *
    88  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    89  *
    90  * @param threadID  스레드 아이디 주소
    91  * @param callback  스레드 워커 함수 이름
    92  * @param arg       스레드 함수로 전달할 인자
    93  */
    9442CF_EXPORT int
    9543CF_Thread_Create    (CF_Thread          * threadID,
    … …  
    9745                     void               * arg);
    9846
    99 /**
    100  * 스레드 아이디를 해제
    101  *
    102  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    103  *
    104  * @param threadID 스레드 아이디 주소
    105  *
    106  * @remark 스레드 아이디를 해제하는 것이며 워커 스레드가 종료되지 않음
    107  */
    10847CF_EXPORT int
    10948CF_Thread_Release   (CF_Thread * threadID);
    11049
    111 /**
    112  * 스레드가 종료될 때 까지 대기
    113  *
    114  * @return CF_OK 반환
    115  *
    116  * @param threadID 스레드 아이디 주소
    117  */
    11850CF_EXPORT int
    11951CF_Thread_Join      (CF_Thread * threadID);
    12052
    121 /**
    122  * 뮤텍스 생성
    123  *
    124  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    125  *
    126  * @param mutex 뮤텍스 아이디 주소
    127  *
    128  * @see CF_Thread_Create
    129  */
    13053CF_EXPORT int
    13154CF_Mutex_Create     (CF_Mutex * mutex);
    13255
    133 /**
    134  * 뮤텍스 해제
    135  *
    136  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    137  *
    138  * @param mutex 뮤텍스 아이디 주소
    139  */
    14056CF_EXPORT int
    14157CF_Mutex_Destory    (CF_Mutex * mutex);
    14258
    143 /**
    144  * 뮤텍스 잠금
    145  *
    146  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    147  *
    148  * @param mutex 뮤텍스 아이디 주소
    149  */
    15059CF_EXPORT int
    15160CF_Mutex_Lock       (CF_Mutex * mutex);
    15261
    153 /**
    154  * 뮤텍스 잠금 해제
    155  *
    156  * @return 성공 시, CF_OK; 실패 시, 오류 코드
    157  *
    158  * @param mutex 뮤텍스 아이디 주소
    159  */
    16062CF_EXPORT int
    16163CF_Mutex_Unlock     (CF_Mutex * mutex);

  • trunk/src/cf_debug.c

    r34 r35  
    115115}
    116116
     117/**
     118 * 디버그 컨텍스트를 생성
     119 *
     120 * @return 성공 시, CF_Debug_Ctx 형태의 컨텍스트; 실패 시, NULL
     121 * @see CF_DEBUG_CREATE_CTX
     122 */
    117123CF_Debug_Ctx
    118124CF_Debug_CreateCtx (void)
    … …  
    125131}
    126132
     133/**
     134 * 디버그 컨텍스트를 해제
     135 *
     136 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     137 *
     138 * @param ctx 디버그 컨텍스트
     139 *
     140 * @see CF_DEBUG_DESTROY_CTX
     141 */
    127142int
    128143CF_Debug_DestroyCtx (CF_Debug_Ctx ctx)
    … …  
    148163}
    149164
     165/**
     166 * 디버그 컨텍스트에 출력할 파일 디스크립터를 설정
     167 *
     168 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     169 *
     170 * @param ctx   디버그 컨텍스트
     171 * @param fd    파일 디스크립터
     172 *
     173 * @see CF_File_Open, CF_File_Create
     174 */
    150175int
    151176CF_Debug_SetOutputFD (CF_Debug_Ctx  ctx,
    … …  
    187212}
    188213
     214/**
     215 * 디버그 메시지를 지정된 파일 포인터로 출력
     216 *
     217 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     218 *
     219 * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
     220 * @param file  파일 경로
     221 * @param func  함수 이름
     222 * @param line  라인 넘버
     223 * @param fmt   포맷 스트링
     224 * @param ...   가변 인자
     225 *
     226 * @see CF_DEBUG_PRINT
     227 */
    189228int
    190229CF_Debug_Print (FILE        * fp,
    … …  
    203242}
    204243
     244/**
     245 * 바이너리 데이터를 디버그 메시지와 함께 지정된 파일 포인터로 출력
     246 *
     247 * @return CF_OK 반환
     248 *
     249 * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
     250 * @param file  파일 경로
     251 * @param func  함수 이름
     252 * @param line  라인 넘버
     253 * @param bin   라인 넘버
     254 * @param len   바이너리 길이
     255 * @param fmt   포맷 스트링
     256 * @param ...   가변 인자
     257 *
     258 * @see CF_DEBUG_PRINT_BIN
     259 */
    205260int
    206261CF_Debug_PrintBin (FILE                 * fp,
    … …  
    223278}
    224279
     280/**
     281 * 컨텍스트를 업데이트하고 디버그 메시지를 출력
     282 *
     283 * @return CF_OK 반환
     284 *
     285 * @param ctx   디버그 컨텍스트
     286 * @param file  파일 경로
     287 * @param func  함수 이름
     288 * @param line  라인 넘버
     289 * @param fmt   포맷 스트링
     290 * @param ...   가변 인자
     291 *
     292 * @see CF_DEBUG_UPDATE_CTX, CF_Debug_Trace
     293 */
    225294int
    226295CF_Debug_Trace (CF_Debug_Ctx    ctx,
    … …  
    248317}
    249318
     319/**
     320 * 컨텍스트를 업데이트하고 바이너리 데이터를 디버그 메시지와 함께 출력
     321 *
     322 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     323 *
     324 * @param ctx   디버그 컨텍스트
     325 * @param file  파일 경로
     326 * @param func  함수 이름
     327 * @param line  라인 넘버
     328 * @param bin   바이너리 데이터
     329 * @param len   바이너리 길이
     330 * @param fmt   포맷 스트링
     331 * @param ...   가변 인자
     332 *
     333 * @see CF_DEBUG_UPDATE_CTX, CF_DEBUG_TRACE_BIN
     334 */
    250335int
    251336CF_Debug_TraceBin (CF_Debug_Ctx         ctx,
    … …  
    281366}
    282367
     368/**
     369 * 컨텍스트에 콜스택 푸시
     370 *
     371 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     372 *
     373 * @param ctx   디버그 컨텍스트
     374 * @param file  파일 경로
     375 * @param func  함수 이름
     376 * @param line  라인 넘버
     377 *
     378 * @see CF_DEBUG_CALLSTACK_PUSH
     379 */
    283380int
    284381CF_Debug_CallStackPush (CF_Debug_Ctx    ctx,
    … …  
    308405}
    309406
     407/**
     408 * 컨텍스트에서 콜스택 팝
     409 *
     410 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     411 *
     412 * @param ctx       디버그 컨텍스트
     413 * @param callstack 콜스택 정보를 가져올 콜스택 데이터 구조체 포인터
     414 *
     415 * @see CF_Debug_CallStackPop, CF_Debug_CallStack
     416 */
    310417int
    311418CF_Debug_CallStackPop (CF_Debug_Ctx         ctx,

  • trunk/src/cf_file.c

    r29 r35  
    2727#define FILE_MODE       S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH
    2828
     29/**
     30 * 파일 열기
     31 *
     32 * @return 성공 시, 파일 디스크립터; 실패 시, 오류 코드
     33 *
     34 * @param path  파일 경로
     35 * @param flag  파일 열기 플래그
     36 *
     37 * @see CF_FILE_FLAG
     38 */
    2939int
    3040CF_File_Open (const char            * path,
    … …  
    3949}
    4050
     51/**
     52 * 파일 생성
     53 *
     54 * @return 성공 시, 파일 디스크립터; 실패 시, 오류 코드
     55 *
     56 * @param path  파일 경로
     57 */
    4158int
    4259CF_File_Create (const char * path)
    … …  
    5067}
    5168
     69/**
     70 * 파일 닫기
     71 *
     72 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     73 *
     74 * @param fd 파일 디스크립터
     75 */
    5276int
    5377CF_File_Close (const int fd)
    … …  
    6690}
    6791
     92/**
     93 * 파일 읽기
     94 *
     95 * @return 성공 시, 읽은 바이트 수; 실패 시, 오류 코드
     96 *
     97 * @param fd    파일 디스크립터
     98 * @param buf   데이터를 저장할 메모리
     99 * @param len   데이터를 저장할 메모리의 크기
     100 */
    68101int
    69102CF_File_Read (const int     fd,
    … …  
    79112}
    80113
     114/**
     115 * 파일 쓰기
     116 *
     117 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     118 *
     119 * @param fd    파일 디스크립터
     120 * @param buf   데이터가 저장된 메모리
     121 * @param len   쓸 데이터의 길이
     122 */
    81123int
    82124CF_File_Write (const int    fd,
    … …  
    92134}
    93135
     136/**
     137 * 파일 크기 얻기
     138 *
     139 * @return 성공 시, 파일 크기; 실패 시, 오류 코드
     140 *
     141 * @param fd    파일 디스크립터
     142 */
    94143int
    95144CF_File_GetSize (const int fd)

  • trunk/src/cf_log.c

    r34 r35  
    161161
    162162static int
    163 CF_Log_Local_Push (CF_LOG_CTX   * ctx,
    164                    const char   * buffer)
    165 {
    166     strncat (ctx->buffer + ctx->length,
    167              buffer,
    168              ctx->size - ctx->length);
    169     ctx->length = strlen (ctx->buffer);
    170 
    171     return CF_OK;
    172 }
    173 
    174 static int
    175163CF_Log_Local_Flush (CF_LOG_CTX * ctx)
    176164{
    … …  
    184172}
    185173
     174/**
     175 * 로그 데이터 처리
     176 *
     177 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     178 *
     179 * @param ctx           로그 컨텍스트
     180 * @param buffer        로그 데이터
     181 * @param demandSize    로그 데이터 길이
     182 *
     183 * @author vfire
     184 */
     185/* static */int
     186CF_Log_Local_Push (CF_LOG_CTX   * ctx,
     187                   const char   * buffer,
     188                   const size_t demandSize)
     189{
     190    if( ctx->size > 0 ) /* 버퍼단위 버퍼링.... */
     191    {
     192        size_t writeSize;
     193        size_t remainSize;
     194
     195        remainSize = demandSize;
     196        while (remainSize)
     197        {
     198            writeSize = (ctx->size - ctx->length) < remainSize ? (ctx->size - ctx->length) : remainSize;
     199
     200            memcpy (ctx->buffer + ctx->length, buffer + demandSize - remainSize, writeSize);
     201            ctx->length += writeSize;
     202
     203            if (ctx->length == ctx->size)
     204                CF_Log_Local_Flush (ctx);
     205
     206            remainSize -= writeSize;
     207        }
     208    }
     209    else /* flush되어야 함. */
     210    {
     211        if (CF_File_Write (ctx->fd, buffer, demandSize) < 0)
     212            return CF_ERROR_LOG_FLUSH;
     213    }
     214
     215    return CF_OK;
     216}
     217
     218/**
     219 * 로그를 사용하기 위해 초기화
     220 *
     221 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     222 *
     223 * @param logPool 아이디 넘버 최대 값
     224 */
    186225int
    187226CF_Log_Initialize (const int logPool)
    … …  
    201240}
    202241
     242/**
     243 * 로그가 모두 사용된 후 자원 해제
     244 *
     245 * @return CF_OK 반환
     246 */
    203247int
    204248CF_Log_Finalize (void)
    … …  
    219263}
    220264
     265/**
     266 * 로그 컨텍스트 생성
     267 *
     268 * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
     269 *
     270 * @param path      로그 파일 경로
     271 * @param memsize   로그 버퍼 크기
     272 *
     273 * @see CF_LOG_BUFFER_DEFAULT, CF_LOG_BUFFER_NO
     274 */
    221275CF_Log_Ctx
    222276CF_Log_CreateCtx (const char    * path,
    … …  
    269323}
    270324
     325/**
     326 * 로그 컨텍스트 해제
     327 *
     328 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     329 *
     330 * @param ctx 로그 컨텍스트
     331 */
    271332int
    272333CF_Log_DestroyCtx (CF_Log_Ctx ctx)
    … …  
    300361}
    301362
     363/**
     364 * 로그 컨텍스트에 멀티쓰레드 모드 설정
     365 *
     366 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     367 *
     368 * @param ctx 로그 컨텍스트
     369 */
    302370int
    303371CF_Log_SetMultiThread (CF_Log_Ctx ctx)
    … …  
    314382}
    315383
     384/**
     385 * 로그 컨텍스트에 멀티쓰레드 모드 설정 해제
     386 *
     387 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     388 *
     389 * @param ctx 로그 컨텍스트
     390 */
    316391int
    317392CF_Log_UnsetMultiThread (CF_Log_Ctx ctx)
    … …  
    328403}
    329404
     405/**
     406 * 로그 컨텍스트에 따라 로그 쓰기
     407 *
     408 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     409 *
     410 * @param ctx       로그 컨텍스트
     411 * @param prefix    로그의 프리픽스 문자열
     412 * @param fmt       포맷 스트링
     413 * @param ...       가변 인자
     414 */
    330415int
    331416CF_Log_Write (CF_Log_Ctx    ctx,
    … …  
    335420    CF_LOG_CTX  * context = (CF_LOG_CTX *) ctx;
    336421    va_list     valist;
    337     char        buffer[4096] = {0x00,};
     422    char        buffer[16 * 1024] = {0x00,};
    338423    char        datetime[CF_LOG_DATETIME_LENGTH + 1] = {0x00,};
    339     size_t      length = 0;
    340424
    341425    if (CHECK_INVALID_CTX (ctx))
    … …  
    349433    vsprintf (buffer + strlen (buffer), fmt, valist);
    350434
    351     if (context->size == CF_LOG_BUFFER_NO)
    352     {
    353         context->buffer = buffer;
    354         context->length = strlen (buffer);
    355 
    356         CF_Log_Local_Flush (context);
    357 
    358         context->buffer = NULL;
    359         /* context->length = 0; // already did this in flush */
    360     }
    361     else /* (context->size > 0) */
    362     {
    363         length = context->size - context->length;
    364         CF_Log_Local_Push (context, buffer);
    365 
    366         if (context->length == context->size)
    367         {
    368             CF_Log_Local_Flush (context);
    369             CF_Log_Local_Push (context, buffer + length);
    370         }
    371     }
     435    CF_Log_Local_Push (context, buffer, strlen (buffer));
    372436
    373437    va_end (valist);
    … …  
    377441}
    378442
     443/**
     444 * 로그 버퍼의 데이터를 즉시 로그 파일에 쓰기
     445 *
     446 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     447 *
     448 * @param ctx 로그 컨텍스트
     449 */
    379450int
    380451CF_Log_Flush (CF_Log_Ctx ctx)
    … …  
    392463}
    393464
     465/**
     466 * 로그 컨텍스트에 아이디 넘버 할당<br />
     467 * 로그 기록 시, 아이디 넘버를 사용하면 해당 로그로 기록할 수 있음
     468 *
     469 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     470 *
     471 * @param mapid 부여할 아이디 넘버
     472 * @param ctx   로그 컨텍스트
     473 *
     474 * @remark 반드시 먼저 초기화 해야하며, 초기화 시에 주어진 번호보다 작은 아이디 넘버를 사용해야 함
     475 *
     476 * @see CF_LOG_OPEN, CF_Log_CreateCtx
     477 */
    394478int
    395479CF_Log_MapCtxID (const int          mapid,
    … …  
    427511}
    428512
     513/**
     514 * 아이디 넘버에 해당하는 로그를 닫고 해당하는 컨텍스트를 해제
     515 *
     516 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     517 *
     518 * @param mapid 로그의 아이디 넘버
     519 *
     520 * @remark 아이디 넘버에 해당하는 컨텍스트가 해제되므로 주의
     521 *
     522 * @see CF_LOG_CLOSE, CF_Log_DestroyCtx
     523 */
    429524int
    430525CF_Log_UnmapCtxID (const int mapid)
    … …  
    445540}
    446541
     542/**
     543 * 아이디 넘버에 해당하는 로그 컨텍스트를 얻기
     544 *
     545 * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
     546 *
     547 * @param mapid 로그의 아이디 넘버
     548 */
    447549CF_Log_Ctx
    448550CF_Log_GetMappedCtx (const int mapid)

  • trunk/src/cf_socket.c

    r29 r35  
    2626static CF_BOOL gInitialized = CF_FALSE;
    2727
     28/**
     29 * 소켓의 초기화 상태 확인
     30 *
     31 * @return 초기화 된 경우, CF_TRUE; 그렇지 않은 경우, CF_FALSE
     32 */
    2833CF_BOOL
    2934CF_Socket_IsInitialized (void)
    … …  
    3237}
    3338
     39/**
     40 * 소켓 초기화
     41 *
     42 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     43 */
    3444int
    3545CF_Socket_Initialize (void)
    … …  
    4959}
    5060
     61/**
     62 * 소켓 해제
     63 *
     64 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     65 */
    5166int
    5267CF_Socket_Finalize (void)
    … …  
    6580}
    6681
     82/**
     83 * 소켓 닫기
     84 *
     85 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     86 *
     87 * @param sock 소켓
     88 */
    6789int
    6890CF_Socket_Close (const int sock)
    … …  
    80102}
    81103
     104/**
     105 * 소켓 옵션 설정
     106 *
     107 * @return 성공 시 CF_OK; 실패 시, 오류 코드
     108 *
     109 * @param sock      소켓
     110 * @param optname   옵션 이름
     111 * @param optval    설정할 옵션 값의 메모리
     112 * @param optlen    설정할 옵션의 길이
     113 */
    82114int
    83115CF_Socket_SetOption (const int      sock,
    … …  
    105137}
    106138
     139/**
     140 * 소켓 옵션 얻기
     141 *
     142 * @return 성공 시 CF_OK; 실패 시, 오류 코드
     143 *
     144 * @param sock      소켓
     145 * @param optname   옵션 이름
     146 * @param optval    옵션 값을 가져올 메모리
     147 * @param optlen    옵션 길이를 가져올 메모리
     148 */
    107149int
    108150CF_Socket_GetOption (const int  sock,
    … …  
    130172}
    131173
     174/**
     175 * 소켓에 타임아웃 설정
     176 *
     177 * @return 성공 시 CF_OK; 실패 시, 오류 코드
     178 *
     179 * @param sock      소켓
     180 * @param timeout   타임아웃(sec)
     181 */
    132182int
    133183CF_Socket_SetTimeout (const int sock,
    … …  
    160210    if (result < 0)
    161211        return CF_ERROR_SOCKET_SET_TIMEOUT;
    162     /*----------------------------------------------------------------*/
    163 
    164     return CF_OK;
    165 }
    166 
     212
     213    return CF_OK;
     214}
     215
     216/**
     217 * 소켓 연결
     218 *
     219 * @return 성공 시, 연결된 소켓; 실패 시, 오류 코드
     220 *
     221 * @param ip    연결할 호스트의 주소 (도메인 이름 가능)
     222 * @param port  연결할 호스트의 포트번호
     223 */
    167224int
    168225CF_Socket_Connect (const char           * ip,
    … …  
    215272}
    216273
     274/**
     275 * 서버 열기
     276 *
     277 * @return 성공 시, 서버 소켓; 실패 시, 오류 코드
     278 *
     279 * @param port      서버 포트
     280 * @param backlog   listen 시의 backlog 수
     281 */
    217282int
    218283CF_Socket_Server (const unsigned short  port,
    … …  
    257322}
    258323
     324/**
     325 * 소켓 연결
     326 *
     327 * @return 성공 시, 연결된 소켓; 실패 시, 오류 코드
     328 *
     329 * @param sock      서버 소켓
     330 * @param address   [옵션] 클라이언트 정보를 담을 sockaddr_in 구조체 포인터
     331 */
    259332int
    260333CF_Socket_Accept (const int             sock,
    … …  
    277350}
    278351
     352/**
     353 * 데이터 송신
     354 *
     355 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     356 *
     357 * @param sock  소켓
     358 * @param buf   송신할 데이터
     359 * @param len   송신할 데이터의 길이
     360 */
    279361int
    280362CF_Socket_Send (const int   sock,
    … …  
    293375}
    294376
     377/**
     378 * 데이터 수신
     379 *
     380 * @return 성공 시, 수신한 데이터의 길이; 실패 시, 오류 코드
     381 *
     382 * @param sock  소켓
     383 * @param buf   데이터를 수신할 버퍼
     384 * @param len   데이터를 수신할 버퍼의 최대 크기
     385 */
    295386int
    296387CF_Socket_Recv (const int   sock,

  • trunk/src/cf_thread.c

    r28 r35  
    4040}
    4141
     42/**
     43 * 스레드를 생성
     44 *
     45 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     46 *
     47 * @param threadID  스레드 아이디 주소
     48 * @param callback  스레드 워커 함수 이름
     49 * @param arg       스레드 함수로 전달할 인자
     50 */
    4251int
    4352CF_Thread_Create (CF_Thread             * threadID,
    … …  
    6473}
    6574
     75/**
     76 * 스레드 아이디를 해제
     77 *
     78 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     79 *
     80 * @param threadID 스레드 아이디 주소
     81 *
     82 * @remark 스레드 아이디를 해제하는 것이며 워커 스레드가 종료되지 않음
     83 */
    6684int
    6785CF_Thread_Release (CF_Thread * threadID)
    … …  
    7492}
    7593
     94/**
     95 * 스레드가 종료될 때 까지 대기
     96 *
     97 * @return CF_OK 반환
     98 *
     99 * @param threadID 스레드 아이디 주소
     100 */
    76101int
    77102CF_Thread_Join (CF_Thread * threadID)
    … …  
    89114}
    90115
     116/**
     117 * 뮤텍스 생성
     118 *
     119 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     120 *
     121 * @param mutex 뮤텍스 아이디 주소
     122 *
     123 * @see CF_Thread_Create
     124 */
    91125int
    92126CF_Mutex_Create (CF_Mutex * mutex)
    … …  
    111145}
    112146
     147/**
     148 * 뮤텍스 해제
     149 *
     150 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     151 *
     152 * @param mutex 뮤텍스 아이디 주소
     153 */
    113154int
    114155CF_Mutex_Destory (CF_Mutex * mutex)
    … …  
    121162}
    122163
     164/**
     165 * 뮤텍스 잠금
     166 *
     167 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     168 *
     169 * @param mutex 뮤텍스 아이디 주소
     170 */
    123171int
    124172CF_Mutex_Lock (CF_Mutex * mutex)
    … …  
    135183}
    136184
     185/**
     186 * 뮤텍스 잠금 해제
     187 *
     188 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     189 *
     190 * @param mutex 뮤텍스 아이디 주소
     191 */
    137192int
    138193CF_Mutex_Unlock (CF_Mutex * mutex)

  • trunk/test/makefile

    r19 r35  
    6767# label
    6868#----------------------------------------------------------
    69 all: $(OBJ_PATH) $(TARGET_PATH) $(LIB_CF) $(TARGET)
     69all: dep $(TARGET)
    7070    @echo ========== Complete CHEROXY compilation ==========
     71dep: $(OBJ_PATH) $(TARGET_PATH) $(LIB_CF)
     72
    7173$(TARGET_PATH): dummy
    7274    @if [ ! -d $@ ] ; then mkdir $@ ; fi
    … …  
    7678    cd ../src; make all;
    7779
    78 # link
    79 $(TARGET_PATH)/%.$(EXT_EXECUTE): $(OBJS)
    80     $(LD) $(LDFLAGS) $(LIBS) -o $@ $?
    81 
    82 $(TARGET_PATH)/%.$(EXT_SHARED): $(OBJS)
    83     $(LD) $(SHARED_FLAGS) -o $@ $?
    84 
    85 $(TARGET_PATH)/%.$(EXT_STATIC): $(OBJS)
    86     $(AR) $(ARFLAGS) -o $@ $?
    87 
    88 # compile
    89 $(OBJ_PATH)/%.o: %.$(SOURCE_TYPE)
    90     $(CC) $(CFLAGS) $(CDEFS) $(INCLUDES) -o $@ -c $?
     80%: %.c
     81    make dep
     82    $(LD) $(LDFLAGS) $(LIBS) $(CDEFS) $(CFLAGS) $(INCLUDES) -o $(TARGET_PATH)/$@.$(EXT_EXECUTE) $?
     83    LD_LIBRARY_PATH=$(TARGET_PATH) $(TARGET_PATH)/$@.$(EXT_EXECUTE)
    9184
    9285clean: dummy
    … …  
    9588
    9689dummy:
    97 
    98 test: all
    99     LD_LIBRARY_PATH=$(TARGET_PATH) $(TARGET)

  • trunk/test/test.c

    r27 r35  
    11/**
    2  * test.c
     2 * @file    test.c
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
    35 */
    46#include "cf_file.h"
Note: See TracChangeset for help on using the changeset viewer.