slog.h

Go to the documentation of this file.

 
#ifndef __SLOG_H__
#define __SLOG_H__
 
#if defined(_WIN32)
#ifndef _SLOG_FUNC
#define _SLOG_FUNC _declspec(dllexport)
#endif /* _SLOG_FUNC */
#elif defined(__unix) || defined(_AIX) || defined(__linux__) || defined(__hpux)
#ifndef _SLOG_FUNC
#define _SLOG_FUNC
#endif /* _SLOG_FUNC */
#endif /* _WIN32 */
 
#if defined(_WIN32)
#include <fcntl.h>
#include <io.h>
#include <share.h>
#include <windows.h>
#elif defined(__unix) || defined(_AIX) || defined(__linux__) || defined(__hpux)
#include <fcntl.h>
#include <pthread.h>
#include <sys/time.h>
#include <syslog.h>
#include <unistd.h>
#endif /* _WIN32 */
 
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>

 
#ifdef __cplusplus
extern "C"
{
#endif


#define SLOG_ERROR_ALLOC               -11 
#define SLOG_ERROR_INTERNAL            -12 
#define SLOG_ERROR_ALLOC_MAX           -13 
#define SLOG_ERROR_PARAMETER           -14 
#define SLOG_ERROR_NOTSUPPORT          -17 
#define SLOG_ERROR_CREATEFILE          -21 
#define SLOG_ERROR_OPENFILE            -22 
#define SLOG_ERROR_WRITEFILE           -23 
#define SLOG_ERROR_TOO_MANY_STYLES     -31 
#define SLOG_ERROR_CONFIGFILE_NOTFOUND -51 
#define SLOG_ERROR_CONFIGFILE_INVALID  -52 

#define SLOG_OUTPUT_INVALID  -1 
#define SLOG_OUTPUT_STDOUT   1  
#define SLOG_OUTPUT_STDERR   2  
#define SLOG_OUTPUT_SYSLOG   3  
#define SLOG_OUTPUT_FILE     11 
#define SLOG_OUTPUT_CALLBACK 21 

#define SLOG_LEVEL_INVALID -1               
#define SLOG_LEVEL_DEBUG   0                
#define SLOG_LEVEL_INFO    1                
#define SLOG_LEVEL_NOTICE  2                
#define SLOG_LEVEL_WARN    3                
#define SLOG_LEVEL_ERROR   4                
#define SLOG_LEVEL_FATAL   5                
#define SLOG_LEVEL_NOLOG   6                
#define SLOG_LEVEL_DEFAULT SLOG_LEVEL_NOLOG 

#define SLOG_STYLE_INVALID        -1      
#define SLOG_STYLE_DATE           0x00001 
#define SLOG_STYLE_DATETIME       0x00002 
#define SLOG_STYLE_DATETIMEMS     0x00004 
#define SLOG_STYLE_LOGLEVEL       0x00008 
#define SLOG_STYLE_PID            0x00010 
#define SLOG_STYLE_TID            0x00020 
#define SLOG_STYLE_SOURCE         0x00040 
#define SLOG_STYLE_FORMAT         0x00080 
#define SLOG_STYLE_NEWLINE        0x00100 
#define SLOG_STYLE_CUSTLABEL1     0x00200 
#define SLOG_STYLE_CUSTLABEL2     0x00400 
#define SLOG_STYLE_CUSTLABEL3     0x00800 
#define SLOG_STYLE_CUSTLABEL4     0x01000 
#define SLOG_STYLE_CUSTLABEL5     0x02000 
#define SLOG_STYLE_CALLBACK       0x10000 
#define SLOG_STYLE_COLORFUL       0x20000 
#define SLOG_STYLE_LOGLEVEL_SHORT 0x40008 
#define SLOG_STYLES_DEFAULT       0       

 
#ifndef SLOG_MAX_FILE_NAME
#define SLOG_MAX_FILE_NAME 256 
#endif
 
#ifndef SLOG_MAX_FILE_TYPE
#define SLOG_MAX_FILE_TYPE 8 
#endif



 
typedef struct tagSLOG    SLOG;    
typedef struct tagSLOGBUF SLOGBUF; 
 
typedef int funcOpenLog(SLOG* g, char* file, void** open_handle);
 
typedef int funcWriteLog(SLOG* g, void** open_handle, int log_level, const void* buf, long len, long* writelen);
 
typedef int funcChangeTest(SLOG* g, void** test_handle);
 
typedef int funcCloseLog(SLOG* g, void** open_handle);
 
typedef int funcLogStyle(SLOG* g, SLOGBUF* logbuf, char* c_filename, long c_fileline, int log_level, const char* format,
                         va_list valist);
 
#define SLOG_NO_OUTPUTFUNC NULL, NULL, NULL, NULL, NULL, NULL
 
#define SLOG_NO_STYLEFUNC NULL


 
_SLOG_FUNC SLOG* CreateLogHandle();
 
_SLOG_FUNC void DestroyLogHandle(SLOG* g);
 
_SLOG_FUNC int GetLogOutput(SLOG* g);
 
_SLOG_FUNC int SetLogOutput(SLOG* g, int output, const char* log_pathfilename, funcOpenLog* pfuncOpenLogPrepare,
                            funcOpenLog* pfuncOpenLog, funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest,
                            funcCloseLog* pfuncCloseLog, funcCloseLog* pfuncCloseLogEnd);

_SLOG_FUNC int SetLogFileType(SLOG* g, const char* file_type);
 
_SLOG_FUNC int SetLogOutput2(SLOG* g, int output, funcOpenLog* pfuncOpenLogPrepare, funcOpenLog* pfuncOpenLog,
                             funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest, funcCloseLog* pfuncCloseLog,
                             funcCloseLog* pfuncCloseLogEnd, char* log_pathfilename_format, ...);
 
_SLOG_FUNC int ReOpenLogOutput(SLOG* g);
 
_SLOG_FUNC int SetLogLevel(SLOG* g, int log_level);
 
_SLOG_FUNC int SetLogStyles(SLOG* g, long log_styles, funcLogStyle* pfuncLogStyle);
 
_SLOG_FUNC int SetLogStylesEx(SLOG* g, long log_styles, funcLogStyle* pfuncLogStyle, funcLogStyle* pfuncLogStylePrefix);
 
_SLOG_FUNC int WriteLevelLog(SLOG* g, char* c_filename, long c_fileline, int log_level, const char* format, ...);
 
_SLOG_FUNC int WriteDebugLog(SLOG* g, char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteInfoLog(SLOG* g, char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteNoticeLog(SLOG* g, char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteWarnLog(SLOG* g, char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteErrorLog(SLOG* g, char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteFatalLog(SLOG* g, char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteHexLog(SLOG* g, char* c_filename, long c_fileline, int log_level, const void* buffer, long buflen,
                           const char* format, ...);
 
_SLOG_FUNC int WriteDebugHexLog(SLOG* g, char* c_filename, long c_fileline, const void* buffer, long buflen,
                                const char* format, ...);
 
_SLOG_FUNC int WriteInfoHexLog(SLOG* g, char* c_filename, long c_fileline, const void* buffer, long buflen,
                               const char* format, ...);
 
_SLOG_FUNC int WriteNoticeHexLog(SLOG* g, char* c_filename, long c_fileline, const void* buffer, long buflen,
                                 const char* format, ...);
 
_SLOG_FUNC int WriteWarnHexLog(SLOG* g, char* c_filename, long c_fileline, const void* buffer, long buflen,
                               const char* format, ...);
 
_SLOG_FUNC int WriteErrorHexLog(SLOG* g, char* c_filename, long c_fileline, const void* buffer, long buflen,
                                const char* format, ...);
 
_SLOG_FUNC int WriteFatalHexLog(SLOG* g, char* c_filename, long c_fileline, const void* buffer, long buflen,
                                const char* format, ...);

 
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)

#define WRITELOG(_g_, _log_level_, ...) WriteLevelLog(_g_, __FILE__, __LINE__, _log_level_, __VA_ARGS__)
#define DEBUGLOG(_g_, ...)              WriteDebugLog(_g_, __FILE__, __LINE__, __VA_ARGS__)
#define INFOLOG(_g_, ...)               WriteInfoLog(_g_, __FILE__, __LINE__, __VA_ARGS__)
#define NOTICELOG(_g_, ...)             WriteNoticeLog(_g_, __FILE__, __LINE__, __VA_ARGS__)
#define WARNLOG(_g_, ...)               WriteWarnLog(_g_, __FILE__, __LINE__, __VA_ARGS__)
#define ERRORLOG(_g_, ...)              WriteErrorLog(_g_, __FILE__, __LINE__, __VA_ARGS__)
#define FATALLOG(_g_, ...)              WriteFatalLog(_g_, __FILE__, __LINE__, __VA_ARGS__)
 
#define WRITEHEXLOG(_g_, _log_level_, _buf_, _buf_size_, ...)                                                          \
    WriteHexLog(_g_, __FILE__, __LINE__, _log_level_, _buf_, _buf_size_, __VA_ARGS__)
#define DEBUGHEXLOG(_g_, _buf_, _buf_size_, ...)                                                                       \
    WriteDebugHexLog(_g_, __FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define INFOHEXLOG(_g_, _buf_, _buf_size_, ...) WriteInfoHexLog(_g_, __FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define NOTICEHEXLOG(_g_, _buf_, _buf_size_, ...)                                                                      \
    WriteNoticeHexLog(_g_, __FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define WARNHEXLOG(_g_, _buf_, _buf_size_, ...) WriteWarnHexLog(_g_, __FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define ERRORHEXLOG(_g_, _buf_, _buf_size_, ...)                                                                       \
    WriteErrorHexLog(_g_, __FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define FATALHEXLOG(_g_, _buf_, _buf_size_, ...)                                                                       \
    WriteFatalHexLog(_g_, __FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#endif /* __STDC_VERSION__ && (__STDC_VERSION__ >= 199901) */

#define create_log_handle  CreateLogHandle  
#define destroy_log_handle DestroyLogHandle 
 
#define func_open_log    funcOpenLog    
#define func_write_log   funcWriteLog   
#define func_change_test funcChangeTest 
#define func_close_log   funcCloseLog   
 
#define func_log_style funcLogStyle 
 
#define set_log_output    SetLogOutput   
#define set_log_file_type SetLogFileType 
#define set_log_output2   SetLogOutput2  
#define set_log_level     SetLogLevel    
#define set_log_styles    SetLogStyles   
 
#define write_level_log  WriteLevelLog  
#define write_debug_log  WriteDebugLog  
#define write_info_log   WriteInfoLog   
#define write_notice_log WriteNoticeLog 
#define write_warn_log   WriteWarnLog   
#define write_error_log  WriteErrorLog  
#define write_fatal_log  WriteFatalLog  
 
#define write_hex_log        WriteHexLog       
#define write_debug_hex_log  WriteDebugHexLog  
#define write_info_hex_log   WriteInfoHexLog   
#define write_notice_hex_log WriteNoticeHexLog 
#define write_warn_hex_log   WriteWarnHexLog   
#define write_error_hex_log  WriteErrorHexLog  
#define write_fatal_hex_log  WriteFatalHexLog  
 
#if defined(_WIN32) || defined(__linux__) || defined(_AIX) || defined(__hpux)


 
_SLOG_FUNC SLOG* CreateLogHandleG();
 
_SLOG_FUNC void DestroyLogHandleG();
 
_SLOG_FUNC SLOG* GetLogHandleG();
 
_SLOG_FUNC void GetLogHandlePtrG(SLOG** pp_g);
 
_SLOG_FUNC void SetLogHandleG(SLOG* g);
 
_SLOG_FUNC int SetLogOutputG(int output, const char* log_pathfilename, funcOpenLog* pfuncOpenLogPrepare,
                             funcOpenLog* pfuncOpenLog, funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest,
                             funcCloseLog* pfuncCloseLog, funcCloseLog* pfuncCloseLogEnd);
 
_SLOG_FUNC int SetLogFileTypeG(const char* file_type);
 
_SLOG_FUNC int SetLogLevelG(int log_level);
 
_SLOG_FUNC int SetLogStylesG(long log_styles, funcLogStyle* pfuncLogStyles);
 
_SLOG_FUNC int SetLogStylesExG(long log_styles, funcLogStyle* pfuncLogStyles, funcLogStyle* pfuncLogStylePrefix);
 
_SLOG_FUNC int SetLogOutput2V(SLOG* g, int output, funcOpenLog* pfuncOpenLogPrepare, funcOpenLog* pfuncOpenLog,
                              funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest, funcCloseLog* pfuncCloseLog,
                              funcCloseLog* pfuncCloseLogEnd, char* log_pathfilename_format, va_list valist);
 
_SLOG_FUNC int SetLogOutput2G(int output, funcOpenLog* pfuncOpenLogPrepare, funcOpenLog* pfuncOpenLog,
                              funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest, funcCloseLog* pfuncCloseLog,
                              funcCloseLog* pfuncCloseLogEnd, char* log_pathfilename_format, ...);
 
_SLOG_FUNC int ReOpenLogOutputG();
 
_SLOG_FUNC int WriteLevelLogG(char* c_filename, long c_fileline, int log_level, const char* format, ...);
 
_SLOG_FUNC int WriteDebugLogG(char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteInfoLogG(char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteNoticeLogG(char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteWarnLogG(char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteErrorLogG(char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteFatalLogG(char* c_filename, long c_fileline, const char* format, ...);
 
_SLOG_FUNC int WriteHexLogG(char* c_filename, long c_fileline, int log_level, const void* buffer, long buflen,
                            const char* format, ...);
 
_SLOG_FUNC int WriteDebugHexLogG(char* c_filename, long c_fileline, const void* buffer, long buflen, const char* format,
                                 ...);
 
_SLOG_FUNC int WriteInfoHexLogG(char* c_filename, long c_fileline, const void* buffer, long buflen, const char* format,
                                ...);
 
_SLOG_FUNC int WriteNoticeHexLogG(char* c_filename, long c_fileline, const void* buffer, long buflen,
                                  const char* format, ...);
 
_SLOG_FUNC int WriteWarnHexLogG(char* c_filename, long c_fileline, const void* buffer, long buflen, const char* format,
                                ...);
 
_SLOG_FUNC int WriteErrorHexLogG(char* c_filename, long c_fileline, const void* buffer, long buflen, const char* format,
                                 ...);
 
_SLOG_FUNC int WriteFatalHexLogG(char* c_filename, long c_fileline, const void* buffer, long buflen, const char* format,
                                 ...);

 
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)

 
#define WRITELOGG(_log_level_, ...) WriteLevelLogG(__FILE__, __LINE__, _log_level_, __VA_ARGS__)
#define DEBUGLOGG(...)              WriteDebugLogG(__FILE__, __LINE__, __VA_ARGS__)
#define INFOLOGG(...)               WriteInfoLogG(__FILE__, __LINE__, __VA_ARGS__)
#define NOTICELOGG(...)             WriteNoticeLogG(__FILE__, __LINE__, __VA_ARGS__)
#define WARNLOGG(...)               WriteWarnLogG(__FILE__, __LINE__, __VA_ARGS__)
#define ERRORLOGG(...)              WriteErrorLogG(__FILE__, __LINE__, __VA_ARGS__)
#define FATALLOGG(...)              WriteFatalLogG(__FILE__, __LINE__, __VA_ARGS__)
 
#define WRITEHEXLOGG(_log_level_, _buf_, _buf_size_, ...)                                                              \
    WriteLevelHexLogG(__FILE__, __LINE__, _log_level_, _buf_, _buf_size_, __VA_ARGS__)
#define DEBUGHEXLOGG(_buf_, _buf_size_, ...)  WriteDebugHexLogG(__FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define INFOHEXLOGG(_buf_, _buf_size_, ...)   WriteInfoHexLogG(__FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define NOTICEHEXLOGG(_buf_, _buf_size_, ...) WriteNoticeHexLogG(__FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define WARNHEXLOGG(_buf_, _buf_size_, ...)   WriteWarnHexLogG(__FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define ERRORHEXLOGG(_buf_, _buf_size_, ...)  WriteErrorHexLogG(__FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)
#define FATALHEXLOGG(_buf_, _buf_size_, ...)  WriteFatalHexLogG(__FILE__, __LINE__, _buf_, _buf_size_, __VA_ARGS__)

 
#endif /* __STDC_VERSION__ */

 
#define create_log_handle_g  CreateLogHandleG  
#define destroy_log_handle_g DestroyLogHandleG 
 
#define set_log_output_g    SetLogOutputG   
#define set_log_file_type_g SetLogFileTypeG 
#define set_log_level_g     SetLogLevelG    
#define set_log_styles_g    SetLogStylesG   
#define set_log_output2_g   SetLogOutput2G  
 
#define write_level_log_g  WriteLevelLogG  
#define write_debug_log_g  WriteDebugLogG  
#define write_info_log_g   WriteInfoLogG   
#define write_notice_log_g WriteNoticeLogG 
#define write_warn_log_g   WriteWarnLogG   
#define write_error_log_g  WriteErrorLogG  
#define write_fatal_log_g  WriteFatalLogG  
 
#define write_hex_log_g        WriteHexLogG       
#define write_debug_hex_log_g  WriteDebugHexLogG  
#define write_info_hex_log_g   WriteInfoHexLogG   
#define write_notice_hex_log_g WriteNoticeHexLogG 
#define write_warn_hex_log_g   WriteWarnHexLogG   
#define write_error_hex_log_g  WriteErrorHexLogG  
#define write_fatal_hex_log_g  WriteFatalHexLogG  

 
#endif /* _WIN32 || __linux__ || _AIX || __hpux */

 
typedef int funcFilterLog(SLOG* g, void** open_handle, int log_level, char* buf, long len);
 
typedef int funcEncryptLog(SLOG* g, const char* plaintext, char* ciphertext, long len);
 
#define func_filter_log  funcFilterLog
#define func_encrypt_log funcEncryptLog
 
#define SLOG_MAXCNT_CUST_LABEL 5
#define SLOG_MAXLEN_CUST_LABEL 64
 
#define SLOG_OPTION_INVALID                -1
#define SLOG_OPTION_OPEN_AND_CLOSE         0x1
#define SLOG_OPTION_CHANGE_TEST            0x2
#define SLOG_OPTION_OPEN_ONCE              0x4
#define SLOG_OPTION_SET_OUTPUT_BY_FILENAME 0x8
#define SLOG_OPTION_ENCRYPT                0x10
 
#define SLOG_OPTION_OPEN_DEFAULT SLOG_OPTION_CHANGE_TEST
 
#define SLOG_CUST_LABELS_COUNT   30
#define SLOG_ROTATEMODE_INVALID  -1
#define SLOG_ROTATEMODE_NONE     0
#define SLOG_ROTATEMODE_SIZE     1
#define SLOG_ROTATEMODE_PER_DAY  2
#define SLOG_ROTATEMODE_PER_HOUR 3
 
#define SLOG_ROTATE_SIZE_FILE_COUNT_DEFAULT      99999999
#define SLOG_ROTATE_SIZE_PRESSURE_FACTOR_DEFAULT 0
#define SLOG_FSYNC_PERIOD                        10000
 
typedef int funcBeforeRotateFile(SLOG* g, char* rotate_log_pathfilename);
typedef int funcAfterRotateFile(SLOG* g, char* rotate_log_pathfilename);
 
#define func_before_rotate_file funcBeforeRotateFile
#define func_after_rotate_file  funcAfterRotateFile
 
#define SLOG_BUFSIZE_DEFAULT        (1024)
#define SLOG_BUFSIZE_MAX            (1024 * 1024)
#define SLOG_HEXLOG_BUFSIZE_DEFAULT (16 * 1024)
#define SLOG_HEXLOG_BUFSIZE_MAX     (10 * 1024 * 1024)
 
_SLOG_FUNC int SetLogOptions(SLOG* g, int log_options);
 
_SLOG_FUNC int SetLogFileChangeTest(SLOG* g, long interval);
 
_SLOG_FUNC int SetLogFsyncPeriod(SLOG* g, long period);
 
_SLOG_FUNC int SetLogCustLabel(SLOG* g, int index, char* cust_label);
 
_SLOG_FUNC int SetLogRotateMode(SLOG* g, int rotate_mode);
 
_SLOG_FUNC int SetLogRotateSize(SLOG* g, long log_rotate_size);
 
_SLOG_FUNC int SetLogRotatePressureFactor(SLOG* g, long pressure_factor);
 
_SLOG_FUNC int SetLogRotateFileCount(SLOG* g, long rotate_file_count);
 
_SLOG_FUNC int SetLogRotateFileNo(SLOG* g, long rotate_file_no);
 
_SLOG_FUNC long GetLogRotateFileNo(SLOG* g);
 
_SLOG_FUNC int SetBeforeRotateFileFunc(SLOG* g, funcAfterRotateFile* pfuncAfterRotateFile);
 
_SLOG_FUNC int SetAfterRotateFileFunc(SLOG* g, funcAfterRotateFile* pfuncAfterRotateFile);
 
_SLOG_FUNC int SetFilterLogFunc(SLOG* g, funcFilterLog* pfuncFilterLog);
 
_SLOG_FUNC int SetEncryptLogFunc(SLOG* g, funcEncryptLog* pfuncEncryptLog);
 
_SLOG_FUNC int SetLogBufferSize(SLOG* g, long log_bufsize, long max_log_bufsize);
 
_SLOG_FUNC int SetHexLogBufferSize(SLOG* g, long hexlog_bufsize, long max_log_hexbufsize);
 
_SLOG_FUNC int SetLogOutputFuncDirectly(SLOG* g, funcOpenLog* pfuncOpenLogPrepare, funcOpenLog* pfuncOpenLog,
                                        funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest,
                                        funcCloseLog* pfuncCloseLog, funcCloseLog* pfuncCloseLogEnd);
 
_SLOG_FUNC int SetLogStyleFuncDirectly(SLOG* g, funcLogStyle* pfuncLogStyle);

#define set_log_options                SetLogOptions
#define set_log_file_change_test       SetLogFileChangeTest
#define set_log_fsync_period           SetLogFsyncPeriod
#define set_log_cust_label             SetLogCustLabel
#define set_log_rotate_mode            SetLogRotateMode
#define set_log_rotate_size            SetLogRotateSize
#define set_log_rotate_pressure_factor SetLogRotatePressureFactor
#define set_log_rotate_file_count      SetLogRotateFileCount
#define set_log_rotate_file_no         SetLogRotateFileNo
#define get_log_rotate_file_no         GetLogRotateFileNo
#define set_before_rotate_file_func    SetBeforeRotateFileFunc
#define set_after_rotate_file_func     SetAfterRotateFileFunc
#define set_filter_log_func            SetFilterLogFunc
#define set_encrypt_log_func           SetEncryptLogFunc
#define set_log_buffer_size            SetLogBufferSize
#define set_hex_log_buffer_size        SetHexLogBufferSize
#define set_log_output_func_directly   SetLogOutputFuncDirectly
#define set_log_stlye_func_directly    SetLogStyleFuncDirectly
 
#if defined(_WIN32) || defined(__linux__) || defined(_AIX) || defined(__hpux)
 
_SLOG_FUNC int SetLogOptionsG(int log_options);
 
_SLOG_FUNC int SetLogFileChangeTestG(long interval);
 
_SLOG_FUNC int SetLogFsyncPeriodG(long period);
 
_SLOG_FUNC int SetLogCustLabelG(int index, char* cust_label);
 
_SLOG_FUNC int SetLogRotateModeG(int rotate_mode);
 
_SLOG_FUNC int SetLogRotateSizeG(long log_rotate_size);
 
_SLOG_FUNC int SetLogRotatePressureFactorG(long pressure_factor);
 
_SLOG_FUNC int SetLogRotateFileCountG(long rotate_file_count);
 
_SLOG_FUNC int SetLogRotateFileNoG(long rotate_file_no);
 
_SLOG_FUNC long GetLogRotateFileNoG(void);
 
_SLOG_FUNC int SetBeforeRotateFileFuncG(funcAfterRotateFile* pfuncAfterRotateFile);
 
_SLOG_FUNC int SetAfterRotateFileFuncG(funcAfterRotateFile* pfuncAfterRotateFile);
 
_SLOG_FUNC int SetFilterLogFuncG(funcFilterLog* pfuncFilterLog);
 
_SLOG_FUNC int SetEncryptLogFuncG(funcEncryptLog* pfuncEncryptLog);
 
_SLOG_FUNC int SetLogBufferSizeG(long log_bufsize, long max_log_bufsize);
 
_SLOG_FUNC int SetHexLogBufferSizeG(long hexlog_bufsize, long max_log_hexbufsize);
 
_SLOG_FUNC int SetLogOutputFuncDirectlyG(funcOpenLog* pfuncOpenLogPrepare, funcOpenLog* pfuncOpenLog,
                                         funcWriteLog* pfuncWriteLog, funcChangeTest* pfuncChangeTest,
                                         funcCloseLog* pfuncCloseLog, funcCloseLog* pfuncCloseLogEnd);
 
_SLOG_FUNC int SetLogStyleFuncDirectlyG(funcLogStyle* pfuncLogStyle);
 
#endif /* _WIN32 || __linux__ || _AIX || __hpux */

#define set_log_options_g                SetLogOptionsG
#define set_log_file_change_test_g       SetLogFileChangeTestG
#define set_log_fsync_period_g           SetLogFsyncPeriodG
#define set_log_cust_label_g             SetLogCustLabelG
#define set_log_rotate_mode_g            SetLogRotateModeG
#define set_log_rotate_size_g            SetLogRotateSizeG
#define set_log_rotate_pressure_factor_g SetLogRotatePressureFactorG
#define set_log_rotate_file_count_g      SetLogRotateFileCountG
#define set_log_rotate_file_no_g         SetLogRotateFileNoG
#define get_log_rotate_file_no_g         GetLogRotateFileNoG
#define set_before_rotate_file_func_g    SetBeforeRotateFileFuncG
#define set_after_rotate_file_func_g     SetAfterRotateFileFuncG
#define set_filter_log_func_g            SetFilterLogFuncG
#define set_log_buffer_size_g            SetLogBufferSizeG
#define set_hex_log_buffer_size_g        SetHexLogBufferSizeG
#define set_log_output_func_directly_g   SetLogOutputFuncDirectlyG
#define set_log_stlye_func_directly_g    SetLogStyleFuncDirectlyG

 
#define TEST_LOGLEVEL_NOTENOUGH(_log_level_, _g_) ((_log_level_) < GetLogLevel(_g_))
 
#define SET_ATTRIBUTE(_param_, _attr_)     ((_param_) = (_attr_))
#define ADD_ATTRIBUTE(_param_, _attr_)     ((_param_) |= (_attr_))
#define REMOVE_ATTRIBUTE(_param_, _attr_)  ((_param_) &= ~(_attr_))
#define TEST_ATTRIBUTE(_param_, _attr_)    (((_param_) & (_attr_)) == (_attr_))
#define TEST_NO_ATTRIBUTE(_param_, _attr_) (((_param_) & (_attr_)) != (_attr_))
 
#define TEST_STDSTREAM(_fd_) ((_fd_) != FD_NULL && ((_fd_) == STDOUT_HANDLE || (_fd_) == STDERR_HANDLE))
#define TEST_FILEFD(_fd_)    ((_fd_) != FD_NULL && (_fd_) != STDOUT_HANDLE && (_fd_) != STDERR_HANDLE)
 
#if defined(_WIN32) || defined(__linux__) || defined(_AIX) || defined(__hpux)
 
_SLOG_FUNC SLOG* GetGlobalLOG();
 
_SLOG_FUNC void SetGlobalLOG(SLOG* g);

#define get_global_log GetGlobalLOG
#define set_global_log SetGlobalLOG
 
#endif /* _WIN32 || __linux__ || _AIX || __hpux */

 
#if defined(_WIN32)
 
#define LOG_NEWLINE     "\r\n"     
#define LOG_NEWLINE_LEN 2          
#define SNPRINTF        _snprintf  
#define VSNPRINTF       _vsnprintf 
#define STDOUT_HANDLE   1          
#define STDERR_HANDLE   2          
#define FD_NULL         -1         
#define WRITE           _write     
#define STAT            _stat      
#define FSTAT           _fstat     
#define ACCESS          _access    
#define ACCESS_OK       00         
#define RENAME          rename     
#define UNLINK          unlink     
 
#elif defined(__unix) || defined(_AIX) || defined(__linux__) || defined(__hpux)
 
#define LOG_NEWLINE     "\n"          
#define LOG_NEWLINE_LEN 1             
#define SNPRINTF        snprintf      
#define VSNPRINTF       vsnprintf     
#define STDOUT_HANDLE   STDOUT_FILENO 
#define STDERR_HANDLE   STDERR_FILENO 
#define FD_NULL         -1            
#define WRITE           write         
#define STAT            stat          
#define FSTAT           fstat         
#define ACCESS          access        
#define ACCESS_OK       F_OK          
#define RENAME          rename        
#define UNLINK          unlink        
 
#endif /* _WIN32 */
 
#if defined(_WIN32)
 
#define SYSTEMTIME2TIMEVAL_USEC(_syst_, _tv_) (_tv_).tv_usec = (_syst_).wMilliseconds * 1000;
 
#define SYSTEMTIME2TM(_syst_, _stime_)                                                                                 \
    (_stime_).tm_year = (_syst_).wYear - 1900;                                                                         \
    (_stime_).tm_mon  = (_syst_).wMonth - 1;                                                                           \
    (_stime_).tm_mday = (_syst_).wDay;                                                                                 \
    (_stime_).tm_hour = (_syst_).wHour;                                                                                \
    (_stime_).tm_min  = (_syst_).wMinute;                                                                              \
    (_stime_).tm_sec  = (_syst_).wSecond;
 
#define LOCALTIME(_tt_, _stime_)                                                                                       \
    {                                                                                                                  \
        SYSTEMTIME stNow;                                                                                              \
        GetLocalTime(&stNow);                                                                                          \
        SYSTEMTIME2TM(stNow, (_stime_));                                                                               \
    }
 
#elif defined(__unix) || defined(_AIX) || defined(__linux__) || defined(__hpux)
 
#define LOCALTIME(_tt_, _stime_) localtime_r(&(_tt_), &(_stime_));
 
#endif /* _WIN32 */
 
#ifndef STRCMP
#define STRCMP(_a_, _C_, _b_)       (strcmp(_a_, _b_) _C_ 0)
#define STRNCMP(_a_, _C_, _b_, _n_) (strncmp(_a_, _b_, _n_) _C_ 0)
#endif /* STRCMP */

 
#define OFFSET_BUFPTR(_logbuf_, _offset_len_)                                                                          \
    if (_offset_len_ > 0 && _offset_len_ <= (_logbuf_)->buf_remain_len && (_logbuf_)->bufptr[0])                       \
    {                                                                                                                  \
        (_logbuf_)->bufptr += _offset_len_;                                                                            \
        (_logbuf_)->buf_remain_len -= _offset_len_;                                                                    \
    }
 
#define OFFSET_BUFPTR_IN_LOOP(_logbuf_, _offset_len_)                                                                  \
    if (_offset_len_ > 0 && _offset_len_ <= (_logbuf_)->buf_remain_len && (_logbuf_)->bufptr[0])                       \
    {                                                                                                                  \
        (_logbuf_)->bufptr += _offset_len_;                                                                            \
        (_logbuf_)->buf_remain_len -= _offset_len_;                                                                    \
    }                                                                                                                  \
    else                                                                                                               \
    {                                                                                                                  \
        break;                                                                                                         \
    }
 
_SLOG_FUNC char* GetLogPathfilename(SLOG* g);
_SLOG_FUNC int   SetOpenFlag(SLOG* g, char open_flag);
_SLOG_FUNC char  IsLogOpened(SLOG* g);
_SLOG_FUNC void* GetLogOpenHandle(SLOG* g);
_SLOG_FUNC void  SetLogOpenHandle(SLOG* g, void* open_handle);
 
_SLOG_FUNC int GetLogLevel(SLOG* g);
 
_SLOG_FUNC SLOGBUF* GetLogBuffer(SLOG* g);
_SLOG_FUNC SLOGBUF* GetHexLogBuffer(SLOG* g);
 
_SLOG_FUNC void CleanLogBuffer(SLOG* g, SLOGBUF* logbuf);
_SLOG_FUNC long FormatLogBuffer(SLOG* g, SLOGBUF* logbuf, const char* format, ...);
_SLOG_FUNC long FormatLogBufferV(SLOG* g, SLOGBUF* logbuf, const char* format, va_list valist);
_SLOG_FUNC long MemcatLogBuffer(SLOG* g, SLOGBUF* logbuf, char* append, long len);

#define set_open_flag SetOpenFlag
#define is_log_opened IsLogOpened
 
#define get_log_level GetLogLevel
 
#define get_log_buffer     GetLogBuffer
#define get_hex_log_buffer GetHexLogBuffer
 
#define format_log_buffer   FormatLogBuffer
#define format_log_buffer_v FormatLogBufferV
#define memcat_log_buffer   MemcatLogBuffer
 
_SLOG_FUNC int         ConvertLogOutput_atoi(char* output_desc);
_SLOG_FUNC int         ConvertLogLevel_atoi(char* log_level_desc);
_SLOG_FUNC int         ConvertLogLevels_atoi(char log_level_desc);
_SLOG_FUNC const char* ConvertLogLevel_itoa(int log_level);
_SLOG_FUNC const char  ConvertLogLevels_itoa(int log_level);
_SLOG_FUNC long        ConvertLogStyle_atol(char* line_style_desc);
_SLOG_FUNC long        ConvertLogOption_atol(char* log_option_desc);
_SLOG_FUNC int         ConvertLogRotateMode_atoi(char* rotate_mode_desc);
_SLOG_FUNC long        ConvertBufferSize_atol(char* bufsize_desc);

#define convert_log_output_atoi      ConvertLogOutput_atoi
#define convert_log_level_atoi       ConvertLogLevel_atoi
#define convert_log_levels_atoi      ConvertLogLevels_atoi
#define convert_log_level_itoa       ConvertLogLevel_itoa
#define convert_log_levels_itoa      ConvertLogLevels_itoa
#define convert_log_style_atol       ConvertLogStyle_atol
#define cnovert_log_option_atol      ConvertLogOption_atol
#define convert_log_rotate_mode_atoi ConvertLogRotateMode_atoi
#define convert_buffer_size_atol     ConvertBufferSize_atol
 
_SLOG_FUNC int ExpandPathFilename(char* pathfilename, long pathfilename_bufsize);
 
#ifdef __cplusplus
}
#endif

 
#endif /* __SLOG_H__ */