🐎 ci(add aarch64 jobs): aarch64 + el9

snapshot目录更新至/tmp/MESA_handle_logger,同时增加按1小时回收文件的脚本，rpm安装后将安装至/usr/lib/tmpfiles.d/目录

.gitignore

@@ -11,7 +11,7 @@ build/
 core.*
 version.txt
 demo/test_handle_logger
-cmake-build-debug
+cmake-build-*
 build-*/
 GPATH
 GRTAGS

.gitlab-ci.yml

@@ -1,42 +1,180 @@
-image: "git.mesalab.cn:7443/mesa_framework/framework-build-env:master"
+variables:
+  GIT_STRATEGY: "clone"
+  BUILD_IMAGE_X86_64_ROCKY8: "git.mesalab.cn:7443/mesa_platform/build-env:rockylinux"
+  BUILD_IMAGE_AARCH64_ROCKY9: "git.mesalab.cn:7443/mesa_platform/build-env:rocky9-aarch64"
+  BUILD_PADDING_PREFIX: /tmp/padding_for_CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX_PREFIX_PREFIX_PREFIX_PREFIX_PREFIX/
+  INSTALL_DEPENDENCY_LIBRARY:  libasan
+
 stages:
 - build
-#- test
-#- package
-- release
+- test
 
-variables:
-  ARTIFACTS_JOB: "build"
-  
-build:
+.build_before_script:
+  before_script:
+  - mkdir -p $BUILD_PADDING_PREFIX/$CI_PROJECT_NAMESPACE/
+  - ln -s $CI_PROJECT_DIR $BUILD_PADDING_PREFIX/$CI_PROJECT_PATH
+  - cd $BUILD_PADDING_PREFIX/$CI_PROJECT_PATH
+  - chmod +x ./ci/travis.sh
+
+
+###############################################################################
+# build on x86_64 Rocky8
+###############################################################################
+
+.build_by_travis_for_x86_64_rocky8:
   stage: build
+  image: $BUILD_IMAGE_X86_64_ROCKY8
+  extends: .build_before_script
   script:
-    - mkdir -p build
+    - ./ci/travis.sh
+  tags:
+    - tsg-os-builder-el8
+
+
+run_test_for_x86_64_rocky8:
+  stage: test
+  image: $BUILD_IMAGE_X86_64_ROCKY8
+  extends: .build_by_travis_for_x86_64_rocky8
+  script:
+    - ./ci/travis.sh
     - cd build
-    - cmake .. -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_PREFIX_PATH=$BUILD_PREFIX
-    - make
-    - make package
-  tags:
-    - share
+    - ctest --verbose
+
+
+branch_build_debug_for_x86_64_rocky8:
+  stage: build
+  extends: .build_by_travis_for_x86_64_rocky8
   variables:
-    BUILD_TYPE: "Debug"
-    BUILD_PREFIX: "/opt/MESA/"
-  only:
+    BUILD_TYPE: Debug
+  except:
+    - /^develop.*$/i
+    - /^master.*$/i
+    - /^dev*.*$/i
+    - /^rel*.*$/i
     - tags
-    - pushes
-    - master
 
+branch_build_release_for_x86_64_rocky8:
+  stage: build
+  variables:
+    BUILD_TYPE: RelWithDebInfo
+  extends: .build_by_travis_for_x86_64_rocky8
+  except:
+    - /^develop.*$/i
+    - /^master.*$/i
+    - /^dev*.*$/i
+    - /^rel*.*$/i
+    - tags
+
+release_build_debug_for_x86_64_rocky88:
+  stage: build
+  variables:
+    BUILD_TYPE: Debug
+    PACKAGE: 1
+    UPLOAD_RPM: 1
+    PULP3_REPO_NAME: framework-stable-x86_64.el8
+    PULP3_DIST_NAME: framework-stable-x86_64.el8
+  extends: .build_by_travis_for_x86_64_rocky8
   artifacts:
-    name: "$CI_JOB_NAME-$CI_COMMIT_REF_NAME-debug"
+    name: "MESA_handle_logger-$CI_COMMIT_REF_NAME-debug"
     paths:
-      -  ./build/*.rpm
-
-release:
-  stage: release
-  tags:
-    - share
+      - build/*.rpm
   only:
     - tags
-    - master
+
+release_build_release_for_x86_64_rocky8:
+  stage: build
+  variables:
+    BUILD_TYPE: RelWithDebInfo
+    PACKAGE: 1
+    UPLOAD_RPM: 1
+    SYMBOL_TARGET: libMESA_handle_logger
+    PULP3_REPO_NAME: framework-stable-x86_64.el8
+    PULP3_DIST_NAME: framework-stable-x86_64.el8
+  extends: .build_by_travis_for_x86_64_rocky8
+  artifacts:
+    name: "MESA_handle_logger-$CI_COMMIT_REF_NAME-release"
+    paths:
+      - build/*.rpm
+  only:
+    - tags
+
+###############################################################################
+# build on aarch64 Rocky9
+###############################################################################
+
+.build_by_travis_for_aarch64_rocky9:
+  stage: build
+  image: $BUILD_IMAGE_AARCH64_ROCKY9
+  extends: .build_before_script
   script:
-     - /bin/bash -x ./autorelease.sh $CI_API_V4_URL $CI_PROJECT_URL $CI_PROJECT_ID $CI_TOKEN $CI_COMMIT_TAG $ARTIFACTS_JOB $CI_PROJECT_NAME
+    - ./ci/travis.sh
+  tags:
+    - tsg-os-builder-aarch64
+
+
+run_test_for_aarch64_rocky9:
+  stage: test
+  image: $BUILD_IMAGE_AARCH64_ROCKY9
+  extends: .build_by_travis_for_aarch64_rocky9
+  script:
+    - ./ci/travis.sh
+    - cd build
+    - ctest --verbose
+
+
+branch_build_debug_for_aarch64_rocky9:
+  stage: build
+  extends: .build_by_travis_for_aarch64_rocky9
+  variables:
+    BUILD_TYPE: Debug
+  except:
+    - /^develop.*$/i
+    - /^master.*$/i
+    - /^dev*.*$/i
+    - /^rel*.*$/i
+    - tags
+
+branch_build_release_for_aarch64_rocky9:
+  stage: build
+  variables:
+    BUILD_TYPE: RelWithDebInfo
+  extends: .build_by_travis_for_aarch64_rocky9
+  except:
+    - /^develop.*$/i
+    - /^master.*$/i
+    - /^dev*.*$/i
+    - /^rel*.*$/i
+    - tags
+
+release_build_debug_for_aarch64_rocky9:
+  stage: build
+  variables:
+    BUILD_TYPE: Debug
+    PACKAGE: 1
+    UPLOAD_RPM: 1
+    PULP3_REPO_NAME: framework-stable-aarch64.el9
+    PULP3_DIST_NAME: framework-stable-aarch64.el9
+  extends: .build_by_travis_for_aarch64_rocky9
+  artifacts:
+    name: "MESA_handle_logger-$CI_COMMIT_REF_NAME-debug"
+    paths:
+      - build/*.rpm
+  only:
+    - tags
+
+release_build_release_for_aarch64_rocky9:
+  stage: build
+  variables:
+    BUILD_TYPE: RelWithDebInfo
+    PACKAGE: 1
+    UPLOAD_RPM: 1
+    SYMBOL_TARGET: libMESA_handle_logger
+    PULP3_REPO_NAME: framework-stable-aarch64.el9
+    PULP3_DIST_NAME: framework-stable-aarch64.el9
+  extends: .build_by_travis_for_aarch64_rocky9
+  artifacts:
+    name: "MESA_handle_logger-$CI_COMMIT_REF_NAME-release"
+    paths:
+      - build/*.rpm
+  only:
+    - tags

CMakeLists.txt

@@ -4,6 +4,9 @@ set(lib_name MESA_handle_logger)
 
 project (${lib_name})
 
+set(LIB_MAJOR_VERSION 2)
+set(LIB_MINOR_VERSION 0)
+
 set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 include(Version)
 
@@ -29,46 +32,46 @@ endif()
 # end of for ASAN
 
 include_directories(${PROJECT_SOURCE_DIR}/inc/)
-include_directories(${PROJECT_SOURCE_DIR}/zlog/)
 
 add_subdirectory(zlog)
 
-file(GLOB SRC
-    "src/*.c"
-    "src/*.cpp"
-)
-
 # Shared Library Output
-add_library(${lib_name}_shared SHARED ${SRC})
-target_link_libraries(${lib_name}_shared  -Wl,--whole-archive zlog_static -Wl,--no-whole-archive)
+add_library(${lib_name}_shared SHARED src/MESA_handle_logger.c)
+target_link_libraries(${lib_name}_shared  zlog_static)
 set_target_properties(${lib_name}_shared PROPERTIES LINK_FLAGS
     "-Wl,--version-script=${PROJECT_SOURCE_DIR}/src/version.map")
+target_link_libraries(${lib_name}_shared pthread)
+
 if(DEFINED MESA_SHARED_INSTALL_DIR)
 	set_target_properties(${lib_name}_shared PROPERTIES OUTPUT_NAME ${lib_name} LIBRARY_OUTPUT_DIRECTORY ${MESA_SHARED_INSTALL_DIR})
 else()
 	set_target_properties(${lib_name}_shared PROPERTIES OUTPUT_NAME ${lib_name})
 endif()
 
+set_target_properties(${lib_name}_shared PROPERTIES VERSION ${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION})
+set_target_properties(${lib_name}_shared PROPERTIES SOVERSION ${LIB_MAJOR_VERSION})
+
 # static Library Output
-add_library(${lib_name}_static STATIC ${SRC})
-target_link_libraries(${lib_name}_static  -Wl,--whole-archive zlog_static -Wl,--no-whole-archive)
+add_library(${lib_name}_static STATIC src/MESA_handle_logger.c)
+target_link_libraries(${lib_name}_static  zlog_static)
 set_target_properties(${lib_name}_static PROPERTIES OUTPUT_NAME ${lib_name})
 
 set(CMAKE_INSTALL_PREFIX /opt/MESA)
 
-install(TARGETS ${lib_name}_shared  LIBRARY DESTINATION
-    ${CMAKE_INSTALL_PREFIX}/lib)
-install(FILES inc/${lib_name}.h   DESTINATION
+install(FILES inc/MESA_handle_logger.h   DESTINATION
     ${CMAKE_INSTALL_PREFIX}/include/MESA COMPONENT devel)
+install(TARGETS ${lib_name}_shared  LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib COMPONENT LIBRARIES)
+install(FILES inc/MESA_handle_logger.h   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/MESA COMPONENT HEADER)
+install(FILES conf/MESA_handle_logger.conf DESTINATION /usr/lib/tmpfiles.d/ COMPONENT PROFILE)
 
 
 
-file(GLOB DEMO
-    "demo/*.c"
-    "demo/*.cpp"
-)
+add_executable(${lib_name}_demo demo/test_handle_logger.c)
+target_link_libraries(${lib_name}_demo pthread ${lib_name}_shared)
 
-add_executable(${lib_name}_demo ${DEMO})
-target_link_libraries(${lib_name}_demo  rt pthread ${lib_name}_static)
+enable_testing()
+
+add_test(NAME test_compatible_mode COMMAND MESA_handle_logger_demo 1 ./demo_zlog.conf 1 100 0)
+add_test(NAME test_perf COMMAND MESA_handle_logger_demo 2 ./demo_zlog.conf 1 1000 0)
 
 include(Package)

README

@@ -4,13 +4,19 @@
  *Author:yangwei@iie.ac.cn
  *History:
 		2014-03-24 created by yw
-		1)first version
+		1)第一个动态库版本
 		
 		2014-04-16 modified by yw
-		1)strict inspection parameters, compatible with g++ 4.4.4
+		1) 支持g++ 4.4.4编译
 		
 		2014-05-29 update by yw
-		1)create  directory is supported
+		1)支持创建用户指定的日志目录
+
+		2019-2-18 update by yw
+		1)性能优化，句柄中存储文件fp，定期flush至文件
+
+		2020-09-07 update to libMESA_handle_logger2 by yw
+		1)内部使用zlog实现，行为变更，更新库为libMESA_handle_logger2
 ------------------------------------------------------------------------------------- 		
  NOTICE:
 		1)compatible with g++, extern with c;

ci/get-nprocessors.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# Copyright 2017 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# This file is typically sourced by another script.
+# if possible, ask for the precise number of processors,
+# otherwise take 2 processors as reasonable default; see
+# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization
+if [ -x /usr/bin/getconf ]; then
+    NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN)
+else
+    NPROCESSORS=2
+fi
+
+# as of 2017-09-04 Travis CI reports 32 processors, but GCC build
+# crashes if parallelized too much (maybe memory consumption problem),
+# so limit to 4 processors for the time being.
+if [ $NPROCESSORS -gt 4 ] ; then
+	echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4."
+	NPROCESSORS=4
+fi

ci/perpare_pulp3_netrc.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+set -evx
+echo "machine ${PULP3_SERVER_URL}\nlogin ${PULP3_SERVER_LOGIN}\npassword ${PULP3_SERVER_PASSWORD}\n" > ~/.netrc

ci/travis.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env sh
+set -evx
+
+chmod +x ci/get-nprocessors.sh
+. ci/get-nprocessors.sh
+
+# if possible, ask for the precise number of processors,
+# otherwise take 2 processors as reasonable default; see
+# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization
+if [ -x /usr/bin/getconf ]; then
+    NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN)
+else
+    NPROCESSORS=2
+fi
+
+# as of 2017-09-04 Travis CI reports 32 processors, but GCC build
+# crashes if parallelized too much (maybe memory consumption problem),
+# so limit to 4 processors for the time being.
+if [ $NPROCESSORS -gt 4 ] ; then
+	echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4."
+	NPROCESSORS=4
+fi
+
+# Tell make to use the processors. No preceding '-' required.
+MAKEFLAGS="j${NPROCESSORS}"
+export MAKEFLAGS
+
+env | sort
+
+# Set default values to OFF for these variables if not specified.
+: "${NO_EXCEPTION:=OFF}"
+: "${NO_RTTI:=OFF}"
+: "${COMPILER_IS_GNUCXX:=OFF}"
+
+# Install dependency from YUM
+if [ -n "${INSTALL_DEPENDENCY_LIBRARY}" ]; then
+      yum install -y $INSTALL_DEPENDENCY_LIBRARY
+fi
+
+mkdir build || true
+cd build
+
+cmake3 -DCMAKE_CXX_FLAGS=$CXX_FLAGS \
+      -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
+      -DCMAKE_INSTALL_PREFIX=$INSTALL_PREFIX \
+      -DENABLE_DEVEL=$ENABLE_DEVEL_SWITCH \
+      -DASAN_OPTION=$ASAN_OPTION \
+      -DVERSION_DAILY_BUILD=$TESTING_VERSION_BUILD \
+      ..
+
+make
+
+if [ -n "${PACKAGE}" ]; then
+	make package
+fi
+
+if [ -n "${UPLOAD_RPM}" ]; then	
+	cp ~/rpm_upload_tools.py ./
+	python3 rpm_upload_tools.py ${PULP3_REPO_NAME} ${PULP3_DIST_NAME} *.rpm
+fi

cmake/Package.cmake

@@ -1,36 +1,57 @@
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    set(CPACK_PACKAGE_NAME "${lib_name}-debug")
+    set(MY_RPM_NAME_PREFIX "lib${lib_name}-debug")
 else()
-    set(CPACK_PACKAGE_NAME ${lib_name})
+    set(MY_RPM_NAME_PREFIX "lib${lib_name}")
 endif()
 
-message(STATUS "Package: ${CPACK_PACKAGE_NAME}")
+message(STATUS "Package: ${MY_RPM_NAME_PREFIX}")
 
 set(CPACK_PACKAGE_VECDOR "MESA")
 set(CPACK_PACKAGE_VERSION_MAJOR "${VERSION_MAJOR}")
 set(CPACK_PACKAGE_VERSION_MINOR "${VERSION_MINOR}")
 set(CPACK_PACKAGE_VERSION_PATCH "${VERSION_PATCH}.${VERSION_BUILD}")
 set(CPACK_PACKAGING_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
+set(CPACK_PACKAGE_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}.${VERSION_BUILD}")
 
-set(CPACK_RPM_PACKAGE_DEBUG 1)
+execute_process(COMMAND sh changelog.sh ${CMAKE_BINARY_DIR} WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/cmake)
+SET(CPACK_RPM_CHANGELOG_FILE ${CMAKE_BINARY_DIR}/changelog.txt)
 
 # RPM Build
 set(CPACK_GENERATOR "RPM")
 set(CPACK_RPM_AUTO_GENERATED_FILE_NAME ON)
 set(CPACK_RPM_FILE_NAME "RPM-DEFAULT")
 set(CPACK_RPM_PACKAGE_VENDOR "MESA")
-set(CPACK_RPM_PACKAGE_AUTOREQPROV "no")
-set(CPACK_RPM_PACKAGE_RELEASE_DIST on)
-set(CPACK_RPM_DEBUGINFO_PACKAGE on)
+set(CPACK_RPM_PACKAGE_AUTOREQPROV "yes")
+set(CPACK_RPM_PACKAGE_RELEASE_DIST "on")
+set(CPACK_RPM_DEBUGINFO_PACKAGE "on")
+
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+set(CPACK_COMPONENTS_IGNORE_GROUPS 1)
+set(CPACK_COMPONENTS_GROUPING ONE_PER_GROUP)
+set(CPACK_COMPONENT_HEADER_DISPLAY_NAME "develop")
+
+set(CPACK_COMPONENT_LIBRARIES_REQUIRED TRUE)
+set(CPACK_RPM_LIBRARIES_PACKAGE_NAME ${MY_RPM_NAME_PREFIX})
+set(CPACK_COMPONENT_LIBRARIES_GROUP "LIBRARIES")
+set(CPACK_COMPONENT_EXECUTABLE_GROUP "LIBRARIES")
+set(CPACK_COMPONENT_PROFILE_GROUP "LIBRARIES")
+
+set(CPACK_COMPONENT_HEADER_REQUIRED TRUE)
+set(CPACK_RPM_HEADER_PACKAGE_NAME "${MY_RPM_NAME_PREFIX}-devel")
+set(CPACK_COMPONENT_HEADER_GROUP "header")
+
+set(CPACK_RPM_HEADER_PACKAGE_REQUIRES_PRE ${CPACK_RPM_LIBRARIES_PACKAGE_NAME})
+set(CPACK_RPM_HEADER_PACKAGE_CONFLICTS ${CPACK_RPM_HEADER_PACKAGE_NAME})
+
+set(CPACK_COMPONENTS_ALL LIBRARIES HEADER EXECUTABLE PROFILE)
+
+set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE ${CMAKE_SOURCE_DIR}/cmake/PostInstall.in)
+set(CPACK_RPM_POST_UNINSTALL_SCRIPT_FILE ${CMAKE_SOURCE_DIR}/cmake/PostInstall.in)
 
 set(CPACK_BUILD_SOURCE_DIRS "${CMAKE_SOURCE_DIR}")
 
 # Must uninstall the debug package before install release package
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    set(CPACK_RPM_PACKAGE_CONFLICTS "${lib_name}-debug")
-else()
-    set(CPACK_RPM_PACKAGE_CONFLICTS ${lib_name})
-    #    set(CPACK_STRIP_FILES TRUE)
-endif()
+set(CPACK_RPM_PACKAGE_CONFLICTS ${MY_RPM_NAME_PREFIX})
 
+#    set(CPACK_STRIP_FILES TRUE)
 include(CPack)

cmake/PostInstall.in

@@ -0,0 +1,2 @@
+#!/bin/sh
+ldconfig

cmake/Version.cmake

@@ -3,7 +3,7 @@
 
 set(__SOURCE_AUTORESIVISION ${CMAKE_SOURCE_DIR}/autorevision.sh)
 set(__AUTORESIVISION ${CMAKE_BINARY_DIR}/autorevision.sh)
-set(__VERSION_CACHE ${CMAKE_SOURCE_DIR}/version.txt)
+set(__VERSION_CACHE ${CMAKE_BINARY_DIR}/version.txt)
 set(__VERSION_CONFIG ${CMAKE_BINARY_DIR}/version.cmake)
 
 file(COPY ${__SOURCE_AUTORESIVISION} DESTINATION ${CMAKE_BINARY_DIR}
@@ -36,13 +36,14 @@ set(VERSION "${VERSION_MAJOR}_${VERSION_MINOR}_${VERSION_PATCH}")
 set(VERSION_BUILD "${VCS_SHORT_HASH}")
 
 # print information
-message(STATUS "VERSION: ${VERSION}-${VERSION_BUILD}")
+message(STATUS "Version: ${VERSION}-${VERSION_BUILD}")
 
-set(GIT_VERSION
-    "${VERSION}-${CMAKE_BUILD_TYPE}-${VERSION_BUILD}-${VCS_BRANCH}-${VCS_DATE}")
+option(DEFINE_GIT_VERSION "Set DEFINE_GIT_VERSION to TRUE or FALSE" TRUE)
 
-string(REGEX REPLACE "[-:+/\\.]" "_" GIT_VERSION ${GIT_VERSION})
+if(DEFINE_GIT_VERSION)
+	set(GIT_VERSION
+			"${VERSION}-${CMAKE_BUILD_TYPE}-${VERSION_BUILD}-${VCS_BRANCH}-${VCS_TAG}-${VCS_DATE}")
+	string(REGEX REPLACE "[-:+/\\.]" "_" GIT_VERSION ${GIT_VERSION})
 
-add_definitions(-DGIT_VERSION=${GIT_VERSION})
-
-message(STATUS "add GIT_VERSION: ${GIT_VERSION}")
+	add_definitions(-DGIT_VERSION=${GIT_VERSION})
+endif()

cmake/changelog.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+work_path=$1
+branch=`git status | grep branch | awk '{print $NF}'`
+git log --branches=$branch --no-merges --date=local --show-signature --pretty="* %ad %an %ae %nhash: %H%ncommit:%n%B"  | awk -F"-" '{print "- "$0}' | sed 's/- \*/\*/g' | sed 's/- $//g' | sed 's/-/  -/g' | sed 's/[0-9]\{2\}:[0-9]\{2\}:[0-9]\{2\}//g' > $work_path/changelog.txt

conf/MESA_handle_logger.conf

@@ -0,0 +1,2 @@
+#Type Path        Mode User Group Age Argument
+d /tmp/MESA_handle_logger/        	    0755 - -   1h -

demo/demo_zlog.conf

@@ -0,0 +1,13 @@
+[global]
+default format = "%d(%c), %V, %U, %m%n"
+[levels]
+DEBUG=10
+INFO=20
+FATAL=30
+[formats]
+other = "%d(%c), %V, %F, %U, %m%n"
+[rules]
+*.=debug    "./log/runtimelog_debug.%d(%F)"
+*.=info    "./log/runtimelog_info.%d(%F)"
+*.=fatal    "./log/runtimelog_fatal.%d(%F)"
+!.*    "./log/runtimelog_other.%d(%F)"; other

demo/test_handle_logger.c

@@ -1,9 +1,10 @@
 #include "MESA_handle_logger.h"
 
-#include <stdio.h>
-#include <stdlib.h>
+#include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <time.h>
 
 void *sample_handle = NULL;
@@ -12,8 +13,11 @@ void *test_handle = NULL;
 #define LOG_NUM 100000
 #define MAX_THREAD_NUM 65535
 
+int g_mode = 0;
 int g_log_num = 0;
 int g_thread_num = 0;
+int g_sleep_interval = 0;
+const char *g_zlog_conf = NULL;
 volatile long g_start_time = 0;
 volatile long g_end_time = 0;
 
@@ -37,11 +41,15 @@ void call_logger(int log_num, int thread_num)
 		}	
 		for(i = 0; i < log_num; i++)
 		{
-				MESA_handle_runtime_log(sample_handle, RLOG_LV_INFO, "sample", "sample_handle MESA_handle_runtime_log, i = %d, thread_num = %d", i, thread_num);
+				MESA_handle_runtime_log(sample_handle, RLOG_LV_DEBUG, "sample", "sample_handle MESA_handle_runtime_log, i = %d, thread_num = %d", i, thread_num);
 				//sleep(1);
 				MESA_handle_runtime_log(test_handle, RLOG_LV_INFO, "test", "test_handle MESA_handle_runtime_log, i = %d, thread_num = %d", i, thread_num);
 				//MESA_HANDLE_RUNTIME_LOG(sample_handle, RLOG_LV_FATAL, "sample", "sample_handle RUNTIEM_LOG test, i = %d, thread_num = %d", i, thread_num);
-				////sleep(1);
+				if(g_sleep_interval > 0)
+				{
+					printf("MESA_handle_runtime_log_level_enabled(%d) return %d\n", RLOG_LV_DEBUG, MESA_handle_runtime_log_level_enabled(test_handle, RLOG_LV_DEBUG));
+					sleep(g_sleep_interval);
+				}
 				//MESA_HANDLE_RUNTIME_LOG(test_handle, RLOG_LV_FATAL, "test", "test_handle RUNTIEM_LOG test, i = %d, thread_num = %d", i, thread_num);
 		}
 		clock_gettime(CLOCK_MONOTONIC, &end);
@@ -57,8 +65,9 @@ void call_logger(int log_num, int thread_num)
 				g_end_time = end_time;
 			}
 		}	
-		time_cost = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000 ;
+		time_cost = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000  - g_sleep_interval * 1000000 ;
 		printf("THREAD %d write %d log using %ld us, avg speed %f /s, %ld -> %ld\n", thread_num, log_num, time_cost, ((float)log_num/(float)time_cost)*1000000, start_time, end_time);
+		printf("MESA_handle_runtime_log_level_enabled(%d) return %d\n", RLOG_LV_DEBUG, MESA_handle_runtime_log_level_enabled(test_handle, RLOG_LV_DEBUG));
 		return;
 }
 
@@ -72,59 +81,91 @@ void *thread_logger(void *arg)
 		return NULL;
 }
 
-void sig_handler(int sig)
+void sig_int_handler(int sig)
 {
 		printf("ctrl+c recviced!\n");
 		MESA_destroy_runtime_log_handle(sample_handle);
 		MESA_destroy_runtime_log_handle(test_handle);
 		sample_handle = NULL;
 		test_handle = NULL;
-		printf("%d thread write %d log using %ld us, avg speed %f /s, %ld -> %ld\n", g_thread_num, g_thread_num*g_log_num, g_end_time-g_start_time, ((float)(g_thread_num*g_log_num)/(float)(g_end_time-g_start_time))*1000000, g_start_time, g_end_time);
+		if (g_mode == 2)
+		{
+			MESA_handle_runtime_log_destruction();
+		}
+		printf("%d thread write %d log using %ld us, avg speed %f /s, %ld -> %ld\n", g_thread_num, g_thread_num * g_log_num, g_end_time - g_start_time, ((float)(g_thread_num * g_log_num) / (float)(g_end_time - g_start_time)) * 1000000, g_start_time, g_end_time);
 		exit(0);
 }
 
+void sig_hup_handler(int sig)
+{
+	printf("SIGHUP recviced!\n");
+	MESA_handle_runtime_log_reconstruction(g_zlog_conf);
+}
+
 int main(int argc, char ** args)
 {
 	pthread_t t[MAX_THREAD_NUM];
 	int i = 0;
+	int ret =0;
 
-	if(argc != 3)
+	if (argc != 6)
 	{
-		printf("Usage: ./($app) $thread_num $log_num \n");
+		printf("Usage: ./($app) $version_mode[1 or 2] $zlog_conf_path $thread_num $log_num $sleep_interval\n");
 		return -1;
 	}
-	g_thread_num = atoi(args[1]);
-	g_log_num = atoi(args[2]);
+	g_mode = atoi(args[1]);
+	g_zlog_conf = args[2];
+	g_thread_num = atoi(args[3]);
+	g_log_num = atoi(args[4]);
+	g_sleep_interval = atoi(args[5]);
 
 	if(g_thread_num <= 0 || g_log_num <= 0)
 	{
 		printf("Error, wrong parameter!\n");
 		return -1;
 	}
+	if (g_mode == 2)
+	{
+		if (0 != MESA_handle_runtime_log_creation(g_zlog_conf))
+		{
+			printf("MESA_handle_runtime_log_creation return error\n");
+			return -1;
+		}
+	}
 	sample_handle = MESA_create_runtime_log_handle("./log/sample_log", RLOG_LV_DEBUG);
 	if (sample_handle == NULL)
 	{
 		printf("get log sample_handle error\n");
 		return -1;
-		}
+	}
 
-		test_handle = MESA_create_runtime_log_handle("./log/test_log", RLOG_LV_DEBUG);
-		if(test_handle == NULL)
-		{
-				printf("get log test_handle error\n");
-				return -1;
-		}
+	test_handle = MESA_create_runtime_log_handle("./log/test_log", RLOG_LV_DEBUG);
+	if (test_handle == NULL)
+	{
+		printf("get log test_handle error\n");
+		return -1;
+	}
 
-		for(i = 0; i < g_thread_num; i++)
-		{	
-				pthread_create(&t[i], NULL, thread_logger, (void *)(unsigned long)(i));
-		}
-		signal(SIGINT, sig_handler);
-		while(1)
-		;
-		//MESA_destroy_runtime_log_handle(sample_handle);
-		//MESA_destroy_runtime_log_handle(test_handle);
-		//sample_handle = NULL;
-		//test_handle = NULL;
-		return 0;
+	for (i = 0; i < g_thread_num; i++)
+	{
+		pthread_create(&t[i], NULL, thread_logger, (void *)(unsigned long)(i));
+	}
+	signal(SIGINT, sig_int_handler);
+	signal(SIGHUP, sig_hup_handler);
+
+    // 等待所有线程结束并回收
+    for (i = 0; i < g_thread_num; ++i) {
+        ret = pthread_join(t[i], NULL);
+        if (ret != 0) {
+            fprintf(stderr, "Failed to join thread %d\n", i);
+            return 1;
+        }
+    }
+
+    printf("All threads finished\n");
+	// MESA_destroy_runtime_log_handle(sample_handle);
+	// MESA_destroy_runtime_log_handle(test_handle);
+	// sample_handle = NULL;
+	// test_handle = NULL;
+	return 0;
 }

inc/MESA_handle_logger.h

@@ -19,11 +19,22 @@ extern "C"
 #define RLOG_LV_FATAL       30
 
 
-#define MESA_HANDLE_RUNTIME_LOG(handle, lv, mod, fmt, args...)   \
-    MESA_handle_runtime_log((handle), (lv), (mod), "file %s, line %d, " fmt, \
-                       __FILE__, __LINE__, ##args)
+int MESA_handle_runtime_log_creation(const char *conf_path);
+int MESA_handle_runtime_log_reconstruction(const char *conf_path);
+void MESA_handle_runtime_log_destruction();
 
-/*
+#define MESA_HANDLE_RUNTIME_LOG(handle, level, module, format, ...)                 \
+do                                                                                  \
+{                                                                                   \
+    if (MESA_handle_runtime_log_level_enabled(handle, level))                       \
+    {                                                                               \
+        MESA_handle_runtime_log(handle, level, module, "file %s, line %d, " format, \
+                                __FILE__, __LINE__, ##__VA_ARGS__);                 \
+    }                                                                               \
+} while (0)
+
+int MESA_handle_runtime_log_level_enabled(void *handle, const int level);
+    /*
  * name: MESA_create_runtime_log_handle
  * functionality: get runtime_log handle;
  * params:

src/MESA_handle_logger.c

@@ -6,20 +6,21 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-
-static int g_zlog_conf_fp = -1;
-char tmp_conf_filepath[1024] = "";
+#include <time.h>
 
 #define MAX_HANDLE_LOG_PATH 4096
-#define GLOB_ZLOG_CONF "GLOB_ZLOG_CONF"
+static int g_zlog_inited = 0;
+static int g_zlog_conf_fp = -1;
+static char global_conf_filepath[MAX_HANDLE_LOG_PATH] = "";
+static char tmp_conf_filepath[MAX_HANDLE_LOG_PATH] = "";
 
-typedef struct log_handle_t
+struct log_handle_t
 {
     int runtime_log_level;
     zlog_category_t *zc;
     const char *global_conf_path;
     char runtime_log_file[MAX_HANDLE_LOG_PATH];
-} log_handle_t;
+};
 
 
 
@@ -89,46 +90,17 @@ static int create_path(const char *path, int path_len)
     return 0;
 }
 
-static zlog_category_t *init_zlog(const char *conf_path, const char *category)
-{
-    zlog_category_t *zc = NULL;
-    if (access(conf_path, R_OK) != -1)
-    {
-
-        int rc = zlog_init(conf_path);
-        if (rc)
-        {
-            rc = zlog_reload(conf_path);
-            if(rc)
-            {
-                printf("init zlog by %s failed\n", conf_path);
-                return NULL;
-            }
-        }
-
-        zc = zlog_get_category(category);
-        if (!zc)
-        {
-            printf("get zlog category %s in %s fail\n", category, conf_path);
-            zlog_fini();
-            return NULL;
-        }
-    }
-    return zc;
-}
-
 static int get_filepath(int fp, char *buf, int buflen)
 {
     if(buf == NULL || buflen <=0)return -1;
     char proclnk[0xFFF] = "";
-    //int fno = fileno(fp);
     int fno = fp;
     sprintf(proclnk, "/proc/self/fd/%d", fno);
     int r = readlink(proclnk, buf, buflen);
     return r;
 }
 
-static char tmp_template[] = "/tmp/handle_loggger.XXXXXX";
+//static char tmp_template[] = "/tmp/MESA_handle_loggger/handle_loggger.XXXXXX";
 
 static void escape_for_zlog(char *in_buf, int buflen)
 {
@@ -144,6 +116,53 @@ static void escape_for_zlog(char *in_buf, int buflen)
     return;
 }
 
+static const char *loglevel_to_name(int level)
+{
+    if (level <= RLOG_LV_DEBUG)
+        return "DEBUG";
+    if (level > RLOG_LV_DEBUG && level <= RLOG_LV_INFO)
+        return "INFO";
+    return "FATAL";
+}
+
+static void snapshot_handle_info(const char *handle_name, const char *log_path, int level)
+{
+    char zlog_rule_conf_content[MAX_HANDLE_LOG_PATH + 1] = "";
+    static char *tmp_prefix = "/tmp/MESA_handle_logger/";
+    static char *zlog_conf_init_buff = "[global]\ndefault format = \"%d(%c), %V, %F, %U, %m%n\" \n[levels]\nDEBUG=10\nINFO=20\nFATAL=30\n[rules]";
+    if (g_zlog_conf_fp == -1)
+    {
+	    if (create_path("/tmp/MESA_handle_logger/", strlen(tmp_prefix)) < 0)
+		    return;
+        char temp_filename[1024] = "";
+        sprintf(temp_filename, "/tmp/MESA_handle_logger/MESA_logger_snapshot_%d.XXXXXX", getpid());
+        g_zlog_conf_fp = mkstemp(temp_filename);
+        if (g_zlog_conf_fp == -1)
+        {
+            return ;
+        }
+        if (get_filepath(g_zlog_conf_fp, tmp_conf_filepath, sizeof(tmp_conf_filepath)) < 0)
+        {
+            return;
+        }
+        write(g_zlog_conf_fp, zlog_conf_init_buff, strlen(zlog_conf_init_buff));
+        fsync(g_zlog_conf_fp);
+    }
+    snprintf(zlog_rule_conf_content, sizeof(zlog_rule_conf_content),
+             "\n%s.%s    \"%s.%%d(%%F)\"",
+             handle_name, loglevel_to_name(level), log_path);
+    write(g_zlog_conf_fp, zlog_rule_conf_content, strlen(zlog_rule_conf_content));
+    fsync(g_zlog_conf_fp);
+
+    if(g_zlog_inited == 0)
+    {
+        fprintf(stderr,"[snapshot_handle_info], Nobody call MESA_handle_runtime_log_creation before, Using (%s) to init zlog, handle_name(%s), log_path(%s), log_level(%d)!!!\n", tmp_conf_filepath, handle_name, log_path, level);
+        zlog_init(tmp_conf_filepath);
+        zlog_reload(NULL);
+    }
+    return;
+}
+
 void *MESA_create_runtime_log_handle(const char *file_path, int level)
 {
 	if(file_path == NULL)
@@ -152,115 +171,41 @@ void *MESA_create_runtime_log_handle(const char *file_path, int level)
     int rc = -1;
     zlog_category_t *zc = NULL;
     FILE *fp  = NULL;
-    log_handle_t *p_handle = NULL;
+    struct log_handle_t *handle = NULL;
 
-    char zlog_rule_conf_content[MAX_HANDLE_LOG_PATH + 1];
     char handle_name[MAX_HANDLE_LOG_PATH];
     char *p_path_end = rindex(file_path, '/');
-    char *pathvar = getenv(GLOB_ZLOG_CONF);
-
-    char *p_name = p_path_end+1;
+    char *p_name;
 
     strcpy(handle_name, file_path);
     escape_for_zlog(handle_name, strlen(handle_name));
     p_name = handle_name;
 
-    if (pathvar == NULL)
-    {
-        //creating file_path failed, return NULL
-        if (create_path(file_path, p_path_end - file_path) < 0)
-            return NULL;
-        if (g_zlog_conf_fp == -1)
-        {
 
-            //g_zlog_conf_fp = tmpfile();
-            char temp_filename[1024]="";
-            sprintf(temp_filename, "/tmp/MESA_handle_logger_%d.XXXXXX", getpid());
-            g_zlog_conf_fp = mkstemp(temp_filename);
-            if (g_zlog_conf_fp == -1)
-            {
-                return NULL;
-            }
-            if (get_filepath(g_zlog_conf_fp, tmp_conf_filepath, sizeof(tmp_conf_filepath)) < 0)
-            {
-                goto error;
-            }
-            snprintf(zlog_rule_conf_content, sizeof(zlog_rule_conf_content),
-                     "[global]\ndefault format = \"%%d(%%c), %%V, %%m%%n\" \n[levels]\nDEBUG=10\nINFO=20\nFATAL=30\n[rules]\n%s.*    \"%s.%%d(%%F)\"",
-                     p_name, file_path);
-            write(g_zlog_conf_fp, zlog_rule_conf_content, strlen(zlog_rule_conf_content));
-            fsync(g_zlog_conf_fp);
-            int rc = zlog_init(tmp_conf_filepath);
-            if(rc)
-            {
-                goto error;
-            }
-            zc = zlog_get_category(p_name);
-            if (!zc)
-            {
-                printf("get zlog category %s in %s fail\n", file_path, tmp_conf_filepath);
-            error:
-                unlink(tmp_conf_filepath);
-                close(g_zlog_conf_fp);
-                g_zlog_conf_fp = -1;
-                memset(tmp_conf_filepath, 0, sizeof(tmp_conf_filepath));
-                zlog_fini();
-                return NULL;
-            }
-        }
-        else
-        {
-            zc = zlog_get_category(p_name);
-            if (!zc)
-            {
-                printf("get zlog category %s in %s fail\n", file_path, tmp_conf_filepath);
-                return NULL;
-            }
-            else
-            {
-                //if (get_filepath(g_zlog_conf_fp, tmp_conf_filepath, sizeof(tmp_conf_filepath)) < 0)
-                //    return NULL;
-                snprintf(zlog_rule_conf_content, sizeof(zlog_rule_conf_content),
-                         "\n%s.*    \"%s.%%d(%%F)\"",
-                         p_name, file_path);
-                write(g_zlog_conf_fp, zlog_rule_conf_content, strlen(zlog_rule_conf_content));
-                fsync(g_zlog_conf_fp);
-                int rc = zlog_reload(tmp_conf_filepath);
-                if (rc)return NULL;
-                zc = zlog_get_category(p_name);
-                if (!zc)
-                {
-                    printf("get zlog category %s in %s fail\n", file_path, tmp_conf_filepath);
-                    return NULL;
-                }
-            }
-        }
-    }
-    else
+    if(p_path_end != NULL && p_path_end > file_path)
     {
-        zc = init_zlog(pathvar, p_name);
-        if (zc == NULL)
-            goto error;
+	    //creating file_path failed, return NULL
+	    if (create_path(file_path, p_path_end-file_path) < 0)
+		    return NULL;
     }
-    p_handle = (log_handle_t *)calloc(sizeof(log_handle_t), 1);
-    strncpy(p_handle->runtime_log_file, file_path, sizeof(p_handle->runtime_log_file) - 1);
-    p_handle->runtime_log_level = level;
-    p_handle->zc = zc;
-    p_handle->global_conf_path = pathvar;
-    return (void *)p_handle;
+    snapshot_handle_info(p_name, file_path, level);
+    zlog_reload(NULL);
+    zc = zlog_get_category(p_name);
+    if (!zc)
+    {
+        fprintf(stderr,"[MESA_create_runtime_log_handle], get zlog category (%s) in global_conf_filepath(%s) fail\n", p_name, global_conf_filepath);
+    }
+    handle = (struct log_handle_t *)calloc(sizeof(struct log_handle_t), 1);
+    strncpy(handle->runtime_log_file, file_path, sizeof(handle->runtime_log_file) - 1);
+    handle->runtime_log_level = level;
+    handle->zc = zc;
+    return (void *)handle;
 }
 
 void MESA_destroy_runtime_log_handle(void *handle)
 {
     if(handle != NULL)
     {
-        log_handle_t *p_handle = (log_handle_t *)handle;
-        zlog_fini();
-        if(g_zlog_conf_fp != -1)
-        {
-            unlink(tmp_conf_filepath);
-            close(g_zlog_conf_fp);
-        }
         free(handle);
         handle = NULL;
     }
@@ -268,19 +213,136 @@ void MESA_destroy_runtime_log_handle(void *handle)
     return;
 }
 
-void MESA_handle_runtime_log(void *handle, int level, const char *module, const char *fmt, ...)
+
+int MESA_handle_runtime_log_level_enabled(void *v_handle, const int level)
 {
-    
-    log_handle_t *p_handle = (log_handle_t *)handle;
+    struct log_handle_t *handle = (struct log_handle_t *)v_handle;
+    if(handle == NULL || handle->runtime_log_file == NULL)return;
+    if(handle->zc == NULL) return;
+    return zlog_level_enabled(handle->zc, level);
+}
 
-    if(p_handle == NULL || p_handle->runtime_log_file == NULL)return;
+void MESA_handle_runtime_log(void *v_handle, int level, const char *module, const char *fmt, ...)
+{
+    struct log_handle_t *handle = (struct log_handle_t *)v_handle;
+    if(handle == NULL || handle->runtime_log_file == NULL)return;
 
-    if(level < p_handle->runtime_log_level) return;
-    
-    va_list ap;
-    va_start(ap, fmt);
-    vzlog(p_handle->zc, __FILE__, sizeof(__FILE__) - 1, __func__, sizeof(__func__) - 1, __LINE__, level, fmt, ap);
-    va_end(ap);
+    if(handle->zc == NULL)return;
+
+    if (zlog_level_enabled(handle->zc, level))
+    {
+        va_list ap;
+        va_start(ap, fmt);
+        vzlog(handle->zc, handle->runtime_log_file, strlen(handle->runtime_log_file), module, strlen(module), __LINE__, level, fmt, ap);
+        va_end(ap);
+    }
     return ;
 }
 
+
+int MESA_handle_runtime_log_creation(const char *conf_path)
+{
+    char *env = getenv("ZLOG_CONF_PATH");
+    int rc = 0;
+    
+    if(g_zlog_inited == 1)
+    {
+       rc = zlog_reload(conf_path);
+       zlog_profile();
+       return rc;
+    }
+
+    if (conf_path == NULL || (access(conf_path, R_OK) != 0))
+    {
+        fprintf(stderr,"[MESA_handle_runtime_log_creation],  PATH (%s) unable to access, will output log to STDOUT or Using ZLOG_CONF_PATH (%s) !\n", conf_path, env);
+        rc = zlog_init(NULL);
+        if (rc)
+        {
+            fprintf(stderr,"[MESA_handle_runtime_log_creation], INIT zlog by (NULL) or (%s) failed !!! \n", env);
+            return -1;
+        }
+        else
+        {
+            if (env != NULL)
+            {
+                strcpy(global_conf_filepath, env);
+            }
+        }
+    }
+    else
+    {
+        rc = zlog_init(conf_path);
+        if (rc)
+        {
+            fprintf(stderr,"[MESA_handle_runtime_log_creation], INIT zlog by (%s) failed , using [NULL] retry !\n", conf_path);
+            rc = zlog_init(NULL);
+            if (rc)
+            {
+                fprintf(stderr,"[MESA_handle_runtime_log_creation], INIT zlog by (NULL) or (%s) failed \n", env);
+                return -1;
+            }
+            else
+            {
+                if(env != NULL)
+                {
+                    strcpy(global_conf_filepath, env);
+                }
+            }
+            
+        }
+        else
+        {
+            strcpy(global_conf_filepath, conf_path);
+        }
+        
+    }
+    fprintf(stderr,"[MESA_handle_runtime_log_creation], INIT zlog finish, Using (%s). \n", global_conf_filepath);
+    g_zlog_inited = 1;
+    zlog_profile();
+
+    return rc;
+}
+
+int MESA_handle_runtime_log_reconstruction(const char *conf_path)
+{
+    int rc = zlog_reload(conf_path);
+ #ifdef DEBUG
+    char zlog_rule_conf_content[MAX_HANDLE_LOG_PATH + 1];
+    time_t t;
+    struct tm local_time;
+    static unsigned char weekday_str[7][4] =
+        {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+
+    static unsigned char month_str[12][4] = {"Jan", "Feb", "Mar", "Apr",
+                                             "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+    if (!rc)
+    {
+        strcpy(global_conf_filepath, conf_path);
+        zlog_profile();
+        if (g_zlog_conf_fp != -1)
+        {
+            time(&t);
+            if (NULL != (localtime_r(&t, &local_time)))
+            {
+                snprintf(zlog_rule_conf_content, sizeof(zlog_rule_conf_content),
+                         "\n%s %s %d %02d:%02d:%02d %d, RECONSTRUCTION to %s\n", weekday_str[local_time.tm_wday],
+                         month_str[local_time.tm_mon], local_time.tm_mday, local_time.tm_hour, local_time.tm_min, local_time.tm_sec, local_time.tm_year + 1900, conf_path);
+                write(g_zlog_conf_fp, zlog_rule_conf_content, strlen(zlog_rule_conf_content));
+                fsync(g_zlog_conf_fp);
+            }
+        }
+    }
+#endif        
+        return rc;
+}
+
+void MESA_handle_runtime_log_destruction()
+{
+    zlog_fini();
+    if (g_zlog_conf_fp != -1)
+    {
+        unlink(tmp_conf_filepath);
+        close(g_zlog_conf_fp);
+    }
+    g_zlog_inited=0;
+}

src/version.map

@@ -1,4 +1,4 @@
 {
-  global: MESA*runtime_log*;
+  global: MESA*runtime_log*;GIT_VERSION_*;
   local: *;
-};
+};

zlog/CMakeLists.txt

@@ -1,11 +1,28 @@
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION 3.5)
 
-set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
+include(ExternalProject)
 
-set(CMAKE_MACOSX_RPATH 0)
+ExternalProject_Add(zlog PREFIX zlog
+	URL ${CMAKE_CURRENT_SOURCE_DIR}/zlog-1.2.16.tar.gz
+    URL_MD5 4dcfe75a1acbb5c4513bbe168f935993  
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND make
+    INSTALL_COMMAND ""
+	BUILD_IN_SOURCE 1)
 
-add_compile_options(-fPIC)
+ExternalProject_Get_Property(zlog SOURCE_DIR)
+file(MAKE_DIRECTORY ${SOURCE_DIR}/src/)
 
-# static Library Output
-add_library(zlog_static STATIC buf.c category.c category_table.c conf.c event.c format.c level.c level_list.c mdc.c record.c record_table.c rotater.c rule.c spec.c thread.c zc_arraylist.c zc_hashtable.c zc_profile.c zc_util.c zlog.c)
-set_target_properties(zlog_static PROPERTIES OUTPUT_NAME zlog)
+
+add_library(zlog_static STATIC IMPORTED GLOBAL)
+add_dependencies(zlog_static  zlog)
+set_property(TARGET zlog_static  PROPERTY IMPORTED_LOCATION ${SOURCE_DIR}/src/libzlog.a)
+set_property(TARGET zlog_static  PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${SOURCE_DIR}/src)
+
+add_library(zlog_shared SHARED IMPORTED GLOBAL)
+add_dependencies(zlog_shared  zlog)
+set_property(TARGET zlog_shared  PROPERTY IMPORTED_LOCATION ${SOURCE_DIR}/src/libzlog.so.1.2)
+set_property(TARGET zlog_shared  PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${SOURCE_DIR}/src)
+
+install(FILES ${SOURCE_DIR}/src/libzlog.so.1.2 DESTINATION lib COMPONENT LIBRARIES)
+install(FILES ${SOURCE_DIR}/src/zlog-chk-conf DESTINATION bin COMPONENT EXECUTABLE)

zlog/buf.c

@@ -1,649 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <pthread.h>
-#include <errno.h>
-#include <stdint.h>
-
-#include "zc_defs.h"
-#include "buf.h"
-/*******************************************************************************/
-/* Author's Note
- * This buf.c is base on C99, that is, if buffer size is not enough,
- * the return value of vsnprintf(3) is a number tell how many character should
- * be output.  vsnprintf in glibc 2.1 conforms to C99 , but glibc 2.0 doesn't.
- * see manpage of vsnprintf(3) on you platform for more detail.
-
- * So, what should you do if you want to using zlog on the platform that doesn't
- * conform C99? My Answer is, crack zlog with a portable C99-vsnprintf, like this
- * http://sourceforge.net/projects/ctrio/
- * http://www.jhweiss.de/software/snprintf.html
- * If you can see this note, you can fix it yourself? Aren't you? ^_^
-
- * Oh, I put the snprintf in C99 standard here,
- * vsnprintf is the same on return value.
-
-       7.19.6.5  The snprintf function
-
-       Synopsis
-
-       [#1]
-
-               #include <stdio.h>
-               int snprintf(char * restrict s, size_t n,
-                       const char * restrict format, ...);
-
-       Description
-
-       [#2]  The snprintf function is equivalent to fprintf, except
-       that the output is  written  into  an  array  (specified  by
-       argument  s) rather than to a stream.  If n is zero, nothing
-       is written, and s may be a null pointer.  Otherwise,  output
-       characters  beyond the n-1st are discarded rather than being
-       written to the array, and a null character is written at the
-       end  of  the characters actually written into the array.  If
-       copying  takes  place  between  objects  that  overlap,  the
-       behavior is undefined.
-
-       Returns
-
-       [#3]  The snprintf function returns the number of characters
-       that would have been written had n been sufficiently  large,
-       not  counting  the terminating null character, or a negative
-       value if  an  encoding  error  occurred.   Thus,  the  null-
-       terminated output has been completely written if and only if
-       the returned value is nonnegative and less than n.
- */
-
-/*******************************************************************************/
-void zlog_buf_profile(zlog_buf_t * a_buf, int flag)
-{
-	//zc_assert(a_buf,);
-	zc_profile(flag, "---buf[%p][%ld-%ld][%ld][%s][%p:%ld]---",
-			a_buf,
-			a_buf->size_min, a_buf->size_max,
-			a_buf->size_real,
-			a_buf->truncate_str,
-			a_buf->start, a_buf->tail - a_buf->start);
-	return;
-}
-/*******************************************************************************/
-void zlog_buf_del(zlog_buf_t * a_buf)
-{
-	//zc_assert(a_buf,);
-	if (a_buf->start) free(a_buf->start);
-	zc_debug("zlog_buf_del[%p]", a_buf);
-    free(a_buf);
-	return;
-}
-
-zlog_buf_t *zlog_buf_new(size_t buf_size_min, size_t buf_size_max, const char *truncate_str)
-{
-	zlog_buf_t *a_buf;
-
-	if (buf_size_min == 0) {
-		zc_error("buf_size_min == 0, not allowed");
-		return NULL;
-	}
-
-	if (buf_size_max != 0 && buf_size_max < buf_size_min) {
-		zc_error("buf_size_max[%lu] < buf_size_min[%lu] && buf_size_max != 0",
-			 (unsigned long)buf_size_max, (unsigned long)buf_size_min);
-		return NULL;
-	}
-
-	a_buf = calloc(1, sizeof(*a_buf));
-	if (!a_buf) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	if (truncate_str) {
-		if (strlen(truncate_str) > sizeof(a_buf->truncate_str) - 1) {
-			zc_error("truncate_str[%s] overflow", truncate_str);
-			goto err;
-		} else {
-			strcpy(a_buf->truncate_str, truncate_str);
-		}
-		a_buf->truncate_str_len = strlen(truncate_str);
-	}
-
-	a_buf->size_min = buf_size_min;
-	a_buf->size_max = buf_size_max;
-	a_buf->size_real = a_buf->size_min;
-
-	a_buf->start = calloc(1, a_buf->size_real);
-	if (!a_buf->start) {
-		zc_error("calloc fail, errno[%d]", errno);
-		goto err;
-	}
-
-	a_buf->tail = a_buf->start;
-	a_buf->end_plus_1 = a_buf->start + a_buf->size_real;
-	a_buf->end = a_buf->end_plus_1 - 1;
-
-	//zlog_buf_profile(a_buf, ZC_DEBUG);
-	return a_buf;
-
-err:
-	zlog_buf_del(a_buf);
-	return NULL;
-}
-
-/*******************************************************************************/
-static void zlog_buf_truncate(zlog_buf_t * a_buf)
-{
-	char *p;
-	size_t len;
-
-	if ((a_buf->truncate_str)[0] == '\0') return;
-	p = (a_buf->tail - a_buf->truncate_str_len);
-	if (p < a_buf->start) p = a_buf->start;
-	len = a_buf->tail - p;
-	memcpy(p, a_buf->truncate_str, len);
-	return;
-}
-
-/*******************************************************************************/
-/* return 0:	success
- * return <0:	fail, set size_real to -1;
- * return >0:	by conf limit, can't extend size
- * increment must > 0
- */
-static int zlog_buf_resize(zlog_buf_t * a_buf, size_t increment)
-{
-	int rc = 0;
-	size_t new_size = 0;
-	size_t len = 0;
-	char *p = NULL;
-
-	if (a_buf->size_max != 0 && a_buf->size_real >= a_buf->size_max) {
-		zc_error("a_buf->size_real[%ld] >= a_buf->size_max[%ld]",
-			 a_buf->size_real, a_buf->size_max);
-		return 1;
-	}
-
-	if (a_buf->size_max == 0) {
-		/* unlimit */
-		new_size = a_buf->size_real + 1.5 * increment;
-	} else {
-		/* limited  */
-		if (a_buf->size_real + increment <= a_buf->size_max) {
-			new_size = a_buf->size_real + increment;
-		} else {
-			new_size = a_buf->size_max;
-			rc = 1;
-		}
-	}
-
-	len = a_buf->tail - a_buf->start;
-	p = realloc(a_buf->start, new_size);
-	if (!p) {
-		zc_error("realloc fail, errno[%d]", errno);
-		free(a_buf->start);
-		a_buf->start = NULL;
-		a_buf->tail = NULL;
-		a_buf->end = NULL;
-		a_buf->end_plus_1 = NULL;
-		return -1;
-	} else {
-		a_buf->start = p;
-		a_buf->tail = p + len;
-		a_buf->size_real = new_size;
-		a_buf->end_plus_1 = a_buf->start + new_size;
-		a_buf->end = a_buf->end_plus_1 - 1;
-	}
-
-	return rc;
-}
-
-int zlog_buf_vprintf(zlog_buf_t * a_buf, const char *format, va_list args)
-{
-	va_list ap;
-	size_t size_left;
-	int nwrite;
-
-	if (!a_buf->start) {
-		zc_error("pre-use of zlog_buf_resize fail, so can't convert");
-		return -1;
-	}
-
-	va_copy(ap, args);
-	size_left = a_buf->end_plus_1 - a_buf->tail;
-	nwrite = vsnprintf(a_buf->tail, size_left, format, ap);
-	if (nwrite >= 0 && nwrite < size_left) {
-		a_buf->tail += nwrite;
-		//*(a_buf->tail) = '\0';
-		return 0;
-	} else if (nwrite < 0) {
-		zc_error("vsnprintf fail, errno[%d]", errno);
-		zc_error("nwrite[%d], size_left[%ld], format[%s]", nwrite, size_left, format);
-		return -1;
-	} else if (nwrite >= size_left) {
-		int rc;
-		//zc_debug("nwrite[%d]>=size_left[%ld],format[%s],resize", nwrite, size_left, format);
-		rc = zlog_buf_resize(a_buf, nwrite - size_left + 1);
-		if (rc > 0) {
-			zc_error("conf limit to %ld, can't extend, so truncate", a_buf->size_max);
-			va_copy(ap, args);
-			size_left = a_buf->end_plus_1 - a_buf->tail;
-			vsnprintf(a_buf->tail, size_left, format, ap);
-			a_buf->tail += size_left - 1;
-			//*(a_buf->tail) = '\0';
-			zlog_buf_truncate(a_buf);
-			return 1;
-		} else if (rc < 0) {
-			zc_error("zlog_buf_resize fail");
-			return -1;
-		} else {
-			//zc_debug("zlog_buf_resize succ, to[%ld]", a_buf->size_real);
-
-			va_copy(ap, args);
-			size_left = a_buf->end_plus_1 - a_buf->tail;
-			nwrite = vsnprintf(a_buf->tail, size_left, format, ap);
-			if (nwrite < 0) {
-				zc_error("vsnprintf fail, errno[%d]", errno);
-				zc_error("nwrite[%d], size_left[%ld], format[%s]", nwrite, size_left, format);
-				return -1;
-			} else {
-				a_buf->tail += nwrite;
-				//*(a_buf->tail) = '\0';
-				return 0;
-			}
-		}
-	}
-
-	return 0;
-}
-
-/*******************************************************************************/
-/* if width > num_len, 0 padding, else output num */
-int zlog_buf_printf_dec32(zlog_buf_t * a_buf, uint32_t ui32, int width)
-{
-	unsigned char *p;
-	char *q;
-	unsigned char tmp[ZLOG_INT32_LEN + 1];
-	size_t num_len, zero_len, out_len;
-
-	if (!a_buf->start) {
-		zc_error("pre-use of zlog_buf_resize fail, so can't convert");
-		return -1;
-	}
-
-	p = tmp + ZLOG_INT32_LEN;
-	do {
-		*--p = (unsigned char) (ui32 % 10 + '0');
-	} while (ui32 /= 10);
-
-	/* zero or space padding */
-	num_len = (tmp + ZLOG_INT32_LEN) - p;
-
-	if (width > num_len) {
-		zero_len = width - num_len;
-		out_len = width;
-	} else {
-		zero_len = 0;
-		out_len = num_len;
-	}
-
-	if ((q = a_buf->tail + out_len) > a_buf->end) {
-		int rc;
-		//zc_debug("size_left not enough, resize");
-		rc = zlog_buf_resize(a_buf, out_len - (a_buf->end - a_buf->tail));
-		if (rc > 0) {
-			size_t len_left;
-			zc_error("conf limit to %ld, can't extend, so output", a_buf->size_max);
-			len_left = a_buf->end - a_buf->tail;
-			if (len_left <= zero_len) {
-				zero_len = len_left;
-				num_len = 0;
-			} else if (len_left > zero_len) {
-				/* zero_len not changed */
-				num_len = len_left - zero_len;
-			}
-			if (zero_len) memset(a_buf->tail, '0', zero_len);
-			memcpy(a_buf->tail + zero_len, p, num_len);
-			a_buf->tail += len_left;
-			//*(a_buf->tail) = '\0';
-			zlog_buf_truncate(a_buf);
-			return 1;
-		} else if (rc < 0) {
-			zc_error("zlog_buf_resize fail");
-			return -1;
-		} else {
-			//zc_debug("zlog_buf_resize succ, to[%ld]", a_buf->size_real);
-			q = a_buf->tail + out_len; /* re-calculate p*/
-		}
-	}
-
-	if (zero_len) memset(a_buf->tail, '0', zero_len);
-	memcpy(a_buf->tail + zero_len, p, num_len);
-	a_buf->tail = q;
-	//*(a_buf->tail) = '\0';
-	return 0;
-}
-/*******************************************************************************/
-int zlog_buf_printf_dec64(zlog_buf_t * a_buf, uint64_t ui64, int width)
-{
-	unsigned char *p;
-	char *q;
-	unsigned char tmp[ZLOG_INT64_LEN + 1];
-	size_t num_len, zero_len, out_len;
-	uint32_t ui32;
-
-	if (!a_buf->start) {
-		zc_error("pre-use of zlog_buf_resize fail, so can't convert");
-		return -1;
-	}
-
-	p = tmp + ZLOG_INT64_LEN;
-	if (ui64 <= ZLOG_MAX_UINT32_VALUE) {
-		/*
-		* To divide 64-bit numbers and to find remainders
-		* on the x86 platform gcc and icc call the libc functions
-		* [u]divdi3() and [u]moddi3(), they call another function
-		* in its turn.  On FreeBSD it is the qdivrem() function,
-		* its source code is about 170 lines of the code.
-		* The glibc counterpart is about 150 lines of the code.
-		*
-		* For 32-bit numbers and some divisors gcc and icc use
-		* a inlined multiplication and shifts.  For example,
-		* unsigned "i32 / 10" is compiled to
-		*
-		*     (i32 * 0xCCCCCCCD) >> 35
-		*/
-
-		ui32 = (uint32_t) ui64;
-
-		do {
-			*--p = (unsigned char) (ui32 % 10 + '0');
-		} while (ui32 /= 10);
-
-	} else {
-		do {
-			*--p = (unsigned char) (ui64 % 10 + '0');
-		} while (ui64 /= 10);
-	}
-
-
-	/* zero or space padding */
-	num_len = (tmp + ZLOG_INT64_LEN) - p;
-
-	if (width > num_len) {
-		zero_len = width - num_len;
-		out_len = width;
-	} else {
-		zero_len = 0;
-		out_len = num_len;
-	}
-
-	if ((q = a_buf->tail + out_len) > a_buf->end) {
-		int rc;
-		//zc_debug("size_left not enough, resize");
-		rc = zlog_buf_resize(a_buf, out_len - (a_buf->end - a_buf->tail));
-		if (rc > 0) {
-			size_t len_left;
-			zc_error("conf limit to %ld, can't extend, so output", a_buf->size_max);
-			len_left = a_buf->end - a_buf->tail;
-			if (len_left <= zero_len) {
-				zero_len = len_left;
-				num_len = 0;
-			} else if (len_left > zero_len) {
-				/* zero_len not changed */
-				num_len = len_left - zero_len;
-			}
-			if (zero_len) memset(a_buf->tail, '0', zero_len);
-			memcpy(a_buf->tail + zero_len, p, num_len);
-			a_buf->tail += len_left;
-			//*(a_buf->tail) = '\0';
-			zlog_buf_truncate(a_buf);
-			return 1;
-		} else if (rc < 0) {
-			zc_error("zlog_buf_resize fail");
-			return -1;
-		} else {
-			//zc_debug("zlog_buf_resize succ, to[%ld]", a_buf->size_real);
-			q = a_buf->tail + out_len; /* re-calculate p*/
-		}
-	}
-
-	if (zero_len) memset(a_buf->tail, '0', zero_len);
-	memcpy(a_buf->tail + zero_len, p, num_len);
-	a_buf->tail = q;
-	//*(a_buf->tail) = '\0';
-	return 0;
-}
-/*******************************************************************************/
-int zlog_buf_printf_hex(zlog_buf_t * a_buf, uint32_t ui32, int width)
-{
-	unsigned char *p;
-	char *q;
-	unsigned char tmp[ZLOG_INT32_LEN + 1];
-	size_t num_len, zero_len, out_len;
-	static unsigned char   hex[] = "0123456789abcdef";
-	//static unsigned char   HEX[] = "0123456789ABCDEF";
-
-	if (!a_buf->start) {
-		zc_error("pre-use of zlog_buf_resize fail, so can't convert");
-		return -1;
-	}
-
-
-	p = tmp + ZLOG_INT32_LEN;
-	do {
-		/* the "(uint32_t)" cast disables the BCC's warning */
-		*--p = hex[(uint32_t) (ui32 & 0xf)];
-	} while (ui32 >>= 4);
-
-#if 0
-	} else { /* is_hex == 2 */
-
-		do {
-			/* the "(uint32_t)" cast disables the BCC's warning */
-			*--p = HEX[(uint32_t) (ui64 & 0xf)];
-
-		} while (ui64 >>= 4);
-	}
-#endif
-
-	/* zero or space padding */
-	num_len = (tmp + ZLOG_INT32_LEN) - p;
-
-	if (width > num_len) {
-		zero_len = width - num_len;
-		out_len = width;
-	} else {
-		zero_len = 0;
-		out_len = num_len;
-	}
-
-	if ((q = a_buf->tail + out_len) > a_buf->end) {
-		int rc;
-		//zc_debug("size_left not enough, resize");
-		rc = zlog_buf_resize(a_buf, out_len - (a_buf->end - a_buf->tail));
-		if (rc > 0) {
-			size_t len_left;
-			zc_error("conf limit to %ld, can't extend, so output", a_buf->size_max);
-			len_left = a_buf->end - a_buf->tail;
-			if (len_left <= zero_len) {
-				zero_len = len_left;
-				num_len = 0;
-			} else if (len_left > zero_len) {
-				/* zero_len not changed */
-				num_len = len_left - zero_len;
-			}
-			if (zero_len) memset(a_buf->tail, '0', zero_len);
-			memcpy(a_buf->tail + zero_len, p, num_len);
-			a_buf->tail += len_left;
-			//*(a_buf->tail) = '\0';
-			zlog_buf_truncate(a_buf);
-			return 1;
-		} else if (rc < 0) {
-			zc_error("zlog_buf_resize fail");
-			return -1;
-		} else {
-			//zc_debug("zlog_buf_resize succ, to[%ld]", a_buf->size_real);
-			q = a_buf->tail + out_len; /* re-calculate p*/
-		}
-	}
-
-	if (zero_len) memset(a_buf->tail, '0', zero_len);
-	memcpy(a_buf->tail + zero_len, p, num_len);
-	a_buf->tail = q;
-	//*(a_buf->tail) = '\0';
-	return 0;
-}
-
-/*******************************************************************************/
-int zlog_buf_append(zlog_buf_t * a_buf, const char *str, size_t str_len)
-{
-	char *p;
-#if 0
-	if (str_len <= 0 || str == NULL) {
-		return 0;
-	}
-	if (!a_buf->start) {
-		zc_error("pre-use of zlog_buf_resize fail, so can't convert");
-		return -1;
-	}
-#endif
-
-	if ((p = a_buf->tail + str_len) > a_buf->end) {
-		int rc;
-		//zc_debug("size_left not enough, resize");
-		rc = zlog_buf_resize(a_buf, str_len - (a_buf->end - a_buf->tail));
-		if (rc > 0) {
-			size_t len_left;
-			zc_error("conf limit to %ld, can't extend, so output",
-				 a_buf->size_max);
-			len_left = a_buf->end - a_buf->tail;
-			memcpy(a_buf->tail, str, len_left);
-			a_buf->tail += len_left;
-			//*(a_buf->tail) = '\0';
-			zlog_buf_truncate(a_buf);
-			return 1;
-		} else if (rc < 0) {
-			zc_error("zlog_buf_resize fail");
-			return -1;
-		} else {
-			//zc_debug("zlog_buf_resize succ, to[%ld]", a_buf->size_real);
-			p = a_buf->tail + str_len; /* re-calculate p*/
-		}
-	}
-
-	memcpy(a_buf->tail, str, str_len);
-	a_buf->tail = p;
-	// *(a_buf->tail) = '\0';
-	return 0;
-}
-
-/*******************************************************************************/
-int zlog_buf_adjust_append(zlog_buf_t * a_buf, const char *str, size_t str_len,
-		int left_adjust, int zero_pad, size_t in_width, size_t out_width)
-{
-	size_t append_len = 0;
-	size_t source_len = 0;
-	size_t space_len = 0;
-
-#if 0
-	if (str_len <= 0 || str == NULL) {
-		return 0;
-	}
-#endif
-
-	if (!a_buf->start) {
-		zc_error("pre-use of zlog_buf_resize fail, so can't convert");
-		return -1;
-	}
-
-	/* calculate how many character will be got from str */
-	if (out_width == 0 || str_len < out_width) {
-		source_len = str_len;
-	} else {
-		source_len = out_width;
-	}
-
-	/* calculate how many character will be output */
-	if (in_width == 0 || source_len >= in_width ) {
-		append_len = source_len;
-		space_len = 0;
-	} else {
-		append_len = in_width;
-		space_len = in_width - source_len;
-	}
-
-	/*  |-----append_len-----------| */
-	/*  |-source_len---|-space_len-|  left_adjust */
-	/*  |-space_len---|-source_len-|  right_adjust */
-	/*  |-(size_real-1)---|           size not enough */
-
-	if (append_len > a_buf->end - a_buf->tail) {
-		int rc = 0;
-		//zc_debug("size_left not enough, resize");
-		rc = zlog_buf_resize(a_buf, append_len - (a_buf->end -a_buf->tail));
-		if (rc > 0) {
-			zc_error("conf limit to %ld, can't extend, so output", a_buf->size_max);
-			append_len = (a_buf->end - a_buf->tail);
-			if (left_adjust) {
-				if (source_len < append_len) {
-					space_len = append_len - source_len;
-				} else {
-					source_len = append_len;
-					space_len = 0;
-				}
-				if (space_len) memset(a_buf->tail + source_len, ' ', space_len);
-				memcpy(a_buf->tail, str, source_len);
-			} else {
-				if (space_len < append_len) {
-					source_len = append_len - space_len;
-				} else {
-					space_len = append_len;
-					source_len = 0;
-				}
-				if (space_len) {
-					if (zero_pad) {
-						memset(a_buf->tail, '0', space_len);
-					} else {
-						memset(a_buf->tail, ' ', space_len);
-					}
-				}
-				memcpy(a_buf->tail + space_len, str, source_len);
-			}
-			a_buf->tail += append_len;
-			//*(a_buf->tail) = '\0';
-			zlog_buf_truncate(a_buf);
-			return 1;
-		} else if (rc < 0) {
-			zc_error("zlog_buf_resize fail");
-			return -1;
-		} else {
-			//zc_debug("zlog_buf_resize succ, to[%ld]", a_buf->size_real);
-		}
-	}
-
-	if (left_adjust) {
-		if (space_len) memset(a_buf->tail + source_len, ' ', space_len);
-		memcpy(a_buf->tail, str, source_len);
-	} else {
-		if (space_len) {
-			if (zero_pad) {
-				memset(a_buf->tail, '0', space_len);
-			} else {
-				memset(a_buf->tail, ' ', space_len);
-			}
-		}
-		memcpy(a_buf->tail + space_len, str, source_len);
-	}
-	a_buf->tail += append_len;
-	//*(a_buf->tail) = '\0';
-	return 0;
-}
-/*******************************************************************************/
-

zlog/buf.h

@@ -1,56 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_buf_h
-#define __zlog_buf_h
-
-/* buf, is a dynamic expand buffer for one single log,
- * as one single log will interlace if use multiple write() to file.
- * and buf is always keep in a thread, to make each thread has its
- * own buffer to avoid lock.
- */
-
-#include <stdarg.h>
-#include <stdint.h>
-
-typedef struct zlog_buf_s {
-	char *start;
-	char *tail;
-	char *end;
-	char *end_plus_1;
-
-	size_t size_min;
-	size_t size_max;
-	size_t size_real;
-
-	char truncate_str[MAXLEN_PATH + 1];
-	size_t truncate_str_len;
-} zlog_buf_t;
-
-
-zlog_buf_t *zlog_buf_new(size_t min, size_t max, const char *truncate_str);
-void zlog_buf_del(zlog_buf_t * a_buf);
-void zlog_buf_profile(zlog_buf_t * a_buf, int flag);
-
-int zlog_buf_vprintf(zlog_buf_t * a_buf, const char *format, va_list args);
-int zlog_buf_append(zlog_buf_t * a_buf, const char *str, size_t str_len);
-int zlog_buf_adjust_append(zlog_buf_t * a_buf, const char *str, size_t str_len,
-			int left_adjust, int zero_pad, size_t in_width, size_t out_width);
-int zlog_buf_printf_dec32(zlog_buf_t * a_buf, uint32_t ui32, int width);
-int zlog_buf_printf_dec64(zlog_buf_t * a_buf, uint64_t ui64, int width);
-int zlog_buf_printf_hex(zlog_buf_t * a_buf, uint32_t ui32, int width);
-
-#define zlog_buf_restart(a_buf) do { \
-	a_buf->tail = a_buf->start; \
-} while(0)
-
-#define zlog_buf_len(a_buf) (a_buf->tail - a_buf->start)
-#define zlog_buf_str(a_buf) (a_buf->start)
-#define zlog_buf_seal(a_buf) do {*(a_buf)->tail = '\0';} while (0)
-
-#endif

zlog/category.c

@@ -1,233 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-#include "fmacros.h"
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-
-#include "category.h"
-#include "rule.h"
-#include "zc_defs.h"
-
-void zlog_category_profile(zlog_category_t *a_category, int flag)
-{
-	int i;
-	zlog_rule_t *a_rule;
-
-	zc_assert(a_category,);
-	zc_profile(flag, "--category[%p][%s][%p]--",
-			a_category,
-			a_category->name,
-			a_category->fit_rules);
-	if (a_category->fit_rules) {
-		zc_arraylist_foreach(a_category->fit_rules, i, a_rule) {
-			zlog_rule_profile(a_rule, flag);
-		}
-	}
-	return;
-}
-
-/*******************************************************************************/
-void zlog_category_del(zlog_category_t * a_category)
-{
-	zc_assert(a_category,);
-	if (a_category->fit_rules) zc_arraylist_del(a_category->fit_rules);
-	zc_debug("zlog_category_del[%p]", a_category);
-    free(a_category);
-	return;
-}
-
-/* overlap one rule's level bitmap to cateogry,
- * so category can judge whether a log level will be output by itself
- * It is safe when configure is reloaded, when rule will be released an recreated
- */
-static void zlog_cateogry_overlap_bitmap(zlog_category_t * a_category, zlog_rule_t *a_rule)
-{
-	int i;
-	for(i = 0; i < sizeof(a_rule->level_bitmap); i++) {
-		a_category->level_bitmap[i] |= a_rule->level_bitmap[i];
-	}
-}
-
-static int zlog_category_obtain_rules(zlog_category_t * a_category, zc_arraylist_t * rules)
-{
-	int i;
-	int count = 0;
-	int fit = 0;
-	zlog_rule_t *a_rule;
-	zlog_rule_t *wastebin_rule = NULL;
-
-	/* before set, clean last fit rules first */
-	if (a_category->fit_rules) zc_arraylist_del(a_category->fit_rules);
-
-	memset(a_category->level_bitmap, 0x00, sizeof(a_category->level_bitmap));
-
-	a_category->fit_rules = zc_arraylist_new(NULL);
-	if (!(a_category->fit_rules)) {
-		zc_error("zc_arraylist_new fail");
-		return -1;
-	}
-
-	/* get match rules from all rules */
-	zc_arraylist_foreach(rules, i, a_rule) {
-		fit = zlog_rule_match_category(a_rule, a_category->name);
-		if (fit) {
-			if (zc_arraylist_add(a_category->fit_rules, a_rule)) {
-				zc_error("zc_arrylist_add fail");
-				goto err;
-			}
-			zlog_cateogry_overlap_bitmap(a_category, a_rule);
-			count++;
-		}
-
-		if (zlog_rule_is_wastebin(a_rule)) {
-			wastebin_rule = a_rule;
-		}
-	}
-
-	if (count == 0) {
-		if (wastebin_rule) {
-			zc_debug("category[%s], no match rules, use wastebin_rule", a_category->name);
-			if (zc_arraylist_add(a_category->fit_rules, wastebin_rule)) {
-				zc_error("zc_arrylist_add fail");
-				goto err;
-			}
-			zlog_cateogry_overlap_bitmap(a_category, wastebin_rule);
-			count++;
-		} else {
-			zc_debug("category[%s], no match rules & no wastebin_rule", a_category->name);
-		}
-	}
-
-	return 0;
-err:
-	zc_arraylist_del(a_category->fit_rules);
-	a_category->fit_rules = NULL;
-	return -1;
-}
-
-zlog_category_t *zlog_category_new(const char *name, zc_arraylist_t * rules)
-{
-	size_t len;
-	zlog_category_t *a_category;
-
-	zc_assert(name, NULL);
-	zc_assert(rules, NULL);
-
-	len = strlen(name);
-	if (len > sizeof(a_category->name) - 1) {
-		zc_error("name[%s] too long", name);
-		return NULL;
-	}
-	a_category = calloc(1, sizeof(zlog_category_t));
-	if (!a_category) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-	strcpy(a_category->name, name);
-	a_category->name_len = len;
-	if (zlog_category_obtain_rules(a_category, rules)) {
-		zc_error("zlog_category_fit_rules fail");
-		goto err;
-	}
-
-	zlog_category_profile(a_category, ZC_DEBUG);
-	return a_category;
-err:
-	zlog_category_del(a_category);
-	return NULL;
-}
-/*******************************************************************************/
-/* update success: fit_rules 1, fit_rules_backup 1 */
-/* update fail: fit_rules 0, fit_rules_backup 1 */
-int zlog_category_update_rules(zlog_category_t * a_category, zc_arraylist_t * new_rules)
-{
-	zc_assert(a_category, -1);
-	zc_assert(new_rules, -1);
-
-	/* 1st, mv fit_rules fit_rules_backup */
-	if (a_category->fit_rules_backup) zc_arraylist_del(a_category->fit_rules_backup);
-	a_category->fit_rules_backup = a_category->fit_rules;
-	a_category->fit_rules = NULL;
-
-	memcpy(a_category->level_bitmap_backup, a_category->level_bitmap,
-			sizeof(a_category->level_bitmap));
-	
-	/* 2nd, obtain new_rules to fit_rules */
-	if (zlog_category_obtain_rules(a_category, new_rules)) {
-		zc_error("zlog_category_obtain_rules fail");
-		a_category->fit_rules = NULL;
-		return -1;
-	}
-
-	/* keep the fit_rules_backup not change, return */
-	return 0;
-}
-
-/* commit fail: fit_rules_backup != 0 */
-/* commit success: fit_rules 1, fit_rules_backup 0 */
-void zlog_category_commit_rules(zlog_category_t * a_category)
-{
-	zc_assert(a_category,);
-	if (!a_category->fit_rules_backup) {
-		zc_warn("a_category->fit_rules_backup is NULL, never update before");
-		return;
-	}
-
-	zc_arraylist_del(a_category->fit_rules_backup);
-	a_category->fit_rules_backup = NULL;
-	memset(a_category->level_bitmap_backup, 0x00,
-			sizeof(a_category->level_bitmap_backup));
-	return;
-}
-
-/* rollback fail: fit_rules_backup != 0 */
-/* rollback success: fit_rules 1, fit_rules_backup 0 */
-/* so whether update succes or not, make things back to old */
-void zlog_category_rollback_rules(zlog_category_t * a_category)
-{
-	zc_assert(a_category,);
-	if (!a_category->fit_rules_backup) {
-		zc_warn("a_category->fit_rules_backup in NULL, never update before");
-		return;
-	}
-
-	if (a_category->fit_rules) {
-		/* update success, rm new and backup */
-		zc_arraylist_del(a_category->fit_rules);
-		a_category->fit_rules = a_category->fit_rules_backup;
-		a_category->fit_rules_backup = NULL;
-	} else {
-		/* update fail, just backup */
-		a_category->fit_rules = a_category->fit_rules_backup;
-		a_category->fit_rules_backup = NULL;
-	}
-
-	memcpy(a_category->level_bitmap, a_category->level_bitmap_backup,
-			sizeof(a_category->level_bitmap));
-	memset(a_category->level_bitmap_backup, 0x00,
-			sizeof(a_category->level_bitmap_backup));
-	
-	return; /* always success */
-}
-
-/*******************************************************************************/
-
-int zlog_category_output(zlog_category_t * a_category, zlog_thread_t * a_thread)
-{
-	int i;
-	int rc = 0;
-	zlog_rule_t *a_rule;
-
-	/* go through all match rules to output */
-	zc_arraylist_foreach(a_category->fit_rules, i, a_rule) {
-		rc = zlog_rule_output(a_rule, a_thread);
-	}
-
-	return rc;
-}

zlog/category.h

@@ -1,38 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_category_h
-#define __zlog_category_h
-
-#include "zc_defs.h"
-#include "thread.h"
-
-typedef struct zlog_category_s {
-	char name[MAXLEN_PATH + 1];
-	size_t name_len;
-	unsigned char level_bitmap[32];
-	unsigned char level_bitmap_backup[32];
-	zc_arraylist_t *fit_rules;
-	zc_arraylist_t *fit_rules_backup;
-} zlog_category_t;
-
-zlog_category_t *zlog_category_new(const char *name, zc_arraylist_t * rules);
-void zlog_category_del(zlog_category_t * a_category);
-void zlog_category_profile(zlog_category_t *a_category, int flag);
-
-int zlog_category_update_rules(zlog_category_t * a_category, zc_arraylist_t * new_rules);
-void zlog_category_commit_rules(zlog_category_t * a_category);
-void zlog_category_rollback_rules(zlog_category_t * a_category);
-
-int zlog_category_output(zlog_category_t * a_category, zlog_thread_t * a_thread);
-
-#define zlog_category_needless_level(a_category, lv) \
-        !((a_category->level_bitmap[lv/8] >> (7 - lv % 8)) & 0x01)
-
-
-#endif

zlog/category_table.c

@@ -1,129 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-
-#include "zc_defs.h"
-#include "category_table.h"
-
-void zlog_category_table_profile(zc_hashtable_t * categories, int flag)
-{
-	zc_hashtable_entry_t *a_entry;
-	zlog_category_t *a_category;
-
-	zc_assert(categories,);
-	zc_profile(flag, "-category_table[%p]-", categories);
-	zc_hashtable_foreach(categories, a_entry) {
-		a_category = (zlog_category_t *) a_entry->value;
-		zlog_category_profile(a_category, flag);
-	}
-	return;
-}
-
-/*******************************************************************************/
-
-void zlog_category_table_del(zc_hashtable_t * categories)
-{
-	zc_assert(categories,);
-	zc_hashtable_del(categories);
-	zc_debug("zlog_category_table_del[%p]", categories);
-	return;
-}
-
-zc_hashtable_t *zlog_category_table_new(void)
-{
-	zc_hashtable_t *categories;
-
-	categories = zc_hashtable_new(20,
-			 (zc_hashtable_hash_fn) zc_hashtable_str_hash,
-			 (zc_hashtable_equal_fn) zc_hashtable_str_equal,
-			 NULL, (zc_hashtable_del_fn) zlog_category_del);
-	if (!categories) {
-		zc_error("zc_hashtable_new fail");
-		return NULL;
-	} else {
-		zlog_category_table_profile(categories, ZC_DEBUG);
-		return categories;
-	}
-}
-/*******************************************************************************/
-int zlog_category_table_update_rules(zc_hashtable_t * categories, zc_arraylist_t * new_rules)
-{
-	zc_hashtable_entry_t *a_entry;
-	zlog_category_t *a_category;
-
-	zc_assert(categories, -1);
-	zc_hashtable_foreach(categories, a_entry) {
-		a_category = (zlog_category_t *) a_entry->value;
-		if (zlog_category_update_rules(a_category, new_rules)) {
-			zc_error("zlog_category_update_rules fail, try rollback");
-			return -1;
-		}
-	}
-	return 0;
-}
-
-void zlog_category_table_commit_rules(zc_hashtable_t * categories)
-{
-	zc_hashtable_entry_t *a_entry;
-	zlog_category_t *a_category;
-
-	zc_assert(categories,);
-	zc_hashtable_foreach(categories, a_entry) {
-		a_category = (zlog_category_t *) a_entry->value;
-		zlog_category_commit_rules(a_category);
-	}
-	return;
-}
-
-void zlog_category_table_rollback_rules(zc_hashtable_t * categories)
-{
-	zc_hashtable_entry_t *a_entry;
-	zlog_category_t *a_category;
-
-	zc_assert(categories,);
-	zc_hashtable_foreach(categories, a_entry) {
-		a_category = (zlog_category_t *) a_entry->value;
-		zlog_category_rollback_rules(a_category);
-	}
-	return;
-}
-
-/*******************************************************************************/
-zlog_category_t *zlog_category_table_fetch_category(zc_hashtable_t * categories,
-			const char *category_name, zc_arraylist_t * rules)
-{
-	zlog_category_t *a_category;
-
-	zc_assert(categories, NULL);
-
-	/* 1st find category in global category map */
-	a_category = zc_hashtable_get(categories, category_name);
-	if (a_category) return a_category;
-
-	/* else not found, create one */
-	a_category = zlog_category_new(category_name, rules);
-	if (!a_category) {
-		zc_error("zc_category_new fail");
-		return NULL;
-	}
-
-	if(zc_hashtable_put(categories, a_category->name, a_category)) {
-		zc_error("zc_hashtable_put fail");
-		goto err;
-	}
-
-	return a_category;
-err:
-	zlog_category_del(a_category);
-	return NULL;
-}
-
-/*******************************************************************************/

zlog/category_table.h

@@ -1,28 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_category_table_h
-#define __zlog_category_table_h
-
-#include "zc_defs.h"
-#include "category.h"
-
-zc_hashtable_t *zlog_category_table_new(void);
-void zlog_category_table_del(zc_hashtable_t * categories);
-void zlog_category_table_profile(zc_hashtable_t * categories, int flag);
-
-/* if none, create new and return */
-zlog_category_t *zlog_category_table_fetch_category(
-			zc_hashtable_t * categories,
-		 	const char *category_name, zc_arraylist_t * rules);
-
-int zlog_category_table_update_rules(zc_hashtable_t * categories, zc_arraylist_t * new_rules);
-void zlog_category_table_commit_rules(zc_hashtable_t * categories);
-void zlog_category_table_rollback_rules(zc_hashtable_t * categories);
-
-#endif

zlog/conf.c

@@ -1,504 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include "fmacros.h"
-#include <ctype.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <time.h>
-
-#include "conf.h"
-#include "rule.h"
-#include "format.h"
-#include "level_list.h"
-#include "rotater.h"
-#include "zc_defs.h"
-
-/*******************************************************************************/
-#define ZLOG_CONF_DEFAULT_FORMAT "default = \"%D %V [%p:%F:%L] %m%n\""
-#define ZLOG_CONF_DEFAULT_RULE "*.*        >stdout"
-#define ZLOG_CONF_DEFAULT_BUF_SIZE_MIN 1024
-#define ZLOG_CONF_DEFAULT_BUF_SIZE_MAX (2 * 1024 * 1024)
-#define ZLOG_CONF_DEFAULT_FILE_PERMS 0600
-#define ZLOG_CONF_DEFAULT_RELOAD_CONF_PERIOD 0
-#define ZLOG_CONF_DEFAULT_FSYNC_PERIOD 0
-#define ZLOG_CONF_BACKUP_ROTATE_LOCK_FILE "/tmp/zlog.lock"
-/*******************************************************************************/
-
-void zlog_conf_profile(zlog_conf_t * a_conf, int flag)
-{
-	int i;
-	zlog_rule_t *a_rule;
-	zlog_format_t *a_format;
-
-	zc_assert(a_conf,);
-	zc_profile(flag, "-conf[%p]-", a_conf);
-	zc_profile(flag, "--global--");
-	zc_profile(flag, "---file[%s],mtime[%s]---", a_conf->file, a_conf->mtime);
-	zc_profile(flag, "---strict init[%d]---", a_conf->strict_init);
-	zc_profile(flag, "---buffer min[%ld]---", a_conf->buf_size_min);
-	zc_profile(flag, "---buffer max[%ld]---", a_conf->buf_size_max);
-	if (a_conf->default_format) {
-		zc_profile(flag, "---default_format---");
-		zlog_format_profile(a_conf->default_format, flag);
-	}
-	zc_profile(flag, "---file perms[0%o]---", a_conf->file_perms);
-	zc_profile(flag, "---reload conf period[%ld]---", a_conf->reload_conf_period);
-	zc_profile(flag, "---fsync period[%ld]---", a_conf->fsync_period);
-
-	zc_profile(flag, "---rotate lock file[%s]---", a_conf->rotate_lock_file);
-	if (a_conf->rotater) zlog_rotater_profile(a_conf->rotater, flag);
-
-	if (a_conf->levels) zlog_level_list_profile(a_conf->levels, flag);
-
-	if (a_conf->formats) {
-		zc_profile(flag, "--format list[%p]--", a_conf->formats);
-		zc_arraylist_foreach(a_conf->formats, i, a_format) {
-			zlog_format_profile(a_format, flag);
-		}
-	}
-
-	if (a_conf->rules) {
-		zc_profile(flag, "--rule_list[%p]--", a_conf->rules);
-		zc_arraylist_foreach(a_conf->rules, i, a_rule) {
-			zlog_rule_profile(a_rule, flag);
-		}
-	}
-
-	return;
-}
-/*******************************************************************************/
-void zlog_conf_del(zlog_conf_t * a_conf)
-{
-	zc_assert(a_conf,);
-	if (a_conf->rotater) zlog_rotater_del(a_conf->rotater);
-	if (a_conf->levels) zlog_level_list_del(a_conf->levels);
-	if (a_conf->default_format) zlog_format_del(a_conf->default_format);
-	if (a_conf->formats) zc_arraylist_del(a_conf->formats);
-	if (a_conf->rules) zc_arraylist_del(a_conf->rules);
-	free(a_conf);
-	zc_debug("zlog_conf_del[%p]");
-	return;
-}
-
-static int zlog_conf_build_without_file(zlog_conf_t * a_conf);
-static int zlog_conf_build_with_file(zlog_conf_t * a_conf);
-
-zlog_conf_t *zlog_conf_new(const char *confpath)
-{
-	int nwrite = 0;
-	int has_conf_file = 0;
-	zlog_conf_t *a_conf = NULL;
-
-	a_conf = calloc(1, sizeof(zlog_conf_t));
-	if (!a_conf) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	if (confpath && confpath[0] != '\0') {
-		nwrite = snprintf(a_conf->file, sizeof(a_conf->file), "%s", confpath);
-		has_conf_file = 1;
-	} else if (getenv("ZLOG_CONF_PATH") != NULL) {
-		nwrite = snprintf(a_conf->file, sizeof(a_conf->file), "%s", getenv("ZLOG_CONF_PATH"));
-		has_conf_file = 1;
-	} else {
-		memset(a_conf->file, 0x00, sizeof(a_conf->file));
-		has_conf_file = 0;
-	}
-	if (nwrite < 0 || nwrite >= sizeof(a_conf->file)) {
-		zc_error("not enough space for path name, nwrite=[%d], errno[%d]", nwrite, errno);
-		goto err;
-	}
-
-	/* set default configuration start */
-	a_conf->strict_init = 1;
-	a_conf->buf_size_min = ZLOG_CONF_DEFAULT_BUF_SIZE_MIN;
-	a_conf->buf_size_max = ZLOG_CONF_DEFAULT_BUF_SIZE_MAX;
-	if (has_conf_file) {
-		/* configure file as default lock file */
-		strcpy(a_conf->rotate_lock_file, a_conf->file);
-	} else {
-		strcpy(a_conf->rotate_lock_file, ZLOG_CONF_BACKUP_ROTATE_LOCK_FILE);
-	}
-	strcpy(a_conf->default_format_line, ZLOG_CONF_DEFAULT_FORMAT);
-	a_conf->file_perms = ZLOG_CONF_DEFAULT_FILE_PERMS;
-	a_conf->reload_conf_period = ZLOG_CONF_DEFAULT_RELOAD_CONF_PERIOD;
-	a_conf->fsync_period = ZLOG_CONF_DEFAULT_FSYNC_PERIOD;
-	/* set default configuration end */
-
-	a_conf->levels = zlog_level_list_new();
-	if (!a_conf->levels) {
-		zc_error("zlog_level_list_new fail");
-		goto err;
-	} 
-
-	a_conf->formats = zc_arraylist_new((zc_arraylist_del_fn) zlog_format_del);
-	if (!a_conf->formats) {
-		zc_error("zc_arraylist_new fail");
-		goto err;
-	}
-
-	a_conf->rules = zc_arraylist_new((zc_arraylist_del_fn) zlog_rule_del);
-	if (!a_conf->rules) {
-		zc_error("init rule_list fail");
-		goto err;
-	}
-
-	if (has_conf_file) {
-		if (zlog_conf_build_with_file(a_conf)) {
-			zc_error("zlog_conf_build_with_file fail");
-			goto err;
-		}
-	} else {
-		if (zlog_conf_build_without_file(a_conf)) {
-			zc_error("zlog_conf_build_without_file fail");
-			goto err;
-		}
-	}
-
-	zlog_conf_profile(a_conf, ZC_DEBUG);
-	return a_conf;
-err:
-	zlog_conf_del(a_conf);
-	return NULL;
-}
-/*******************************************************************************/
-static int zlog_conf_build_without_file(zlog_conf_t * a_conf)
-{
-	zlog_rule_t *default_rule;
-
-	a_conf->default_format = zlog_format_new(a_conf->default_format_line, &(a_conf->time_cache_count));
-	if (!a_conf->default_format) {
-		zc_error("zlog_format_new fail");
-		return -1;
-	}
-
-	a_conf->rotater = zlog_rotater_new(a_conf->rotate_lock_file);
-	if (!a_conf->rotater) {
-		zc_error("zlog_rotater_new fail");
-		return -1;
-	}
-
-	default_rule = zlog_rule_new(
-			ZLOG_CONF_DEFAULT_RULE,
-			a_conf->levels,
-			a_conf->default_format,
-			a_conf->formats,
-			a_conf->file_perms,
-			a_conf->fsync_period,
-			&(a_conf->time_cache_count));
-	if (!default_rule) {
-		zc_error("zlog_rule_new fail");
-		return -1;
-	}
-
-	/* add default rule */
-	if (zc_arraylist_add(a_conf->rules, default_rule)) {
-		zlog_rule_del(default_rule);
-		zc_error("zc_arraylist_add fail");
-		return -1;
-	}
-
-	return 0;
-}
-/*******************************************************************************/
-static int zlog_conf_parse_line(zlog_conf_t * a_conf, char *line, int *section);
-
-static int zlog_conf_build_with_file(zlog_conf_t * a_conf)
-{
-	int rc = 0;
-	struct zlog_stat a_stat;
-	struct tm local_time;
-	FILE *fp = NULL;
-
-	char line[MAXLEN_CFG_LINE + 1];
-	size_t line_len;
-	char *pline = NULL;
-	char *p = NULL;
-	int line_no = 0;
-	int i = 0;
-	int in_quotation = 0;
-
-	int section = 0;
-	/* [global:1] [levels:2] [formats:3] [rules:4] */
-
-	if (lstat(a_conf->file, &a_stat)) {
-		zc_error("lstat conf file[%s] fail, errno[%d]", a_conf->file,
-			 errno);
-		return -1;
-	}
-	localtime_r(&(a_stat.st_mtime), &local_time);
-	strftime(a_conf->mtime, sizeof(a_conf->mtime), "%F %T", &local_time);
-
-	if ((fp = fopen(a_conf->file, "r")) == NULL) {
-		zc_error("open configure file[%s] fail", a_conf->file);
-		return -1;
-	}
-
-	/* Now process the file.
-	 */
-	pline = line;
-	memset(&line, 0x00, sizeof(line));
-	while (fgets((char *)pline, sizeof(line) - (pline - line), fp) != NULL) {
-		++line_no;
-		line_len = strlen(pline);
-		if (pline[line_len - 1] == '\n') {
-			pline[line_len - 1] = '\0';
-		}
-
-		/* check for end-of-section, comments, strip off trailing
-		 * spaces and newline character.
-		 */
-		p = pline;
-		while (*p && isspace((int)*p))
-			++p;
-		if (*p == '\0' || *p == '#')
-			continue;
-
-		for (i = 0; p[i] != '\0'; ++i) {
-			pline[i] = p[i];
-		}
-		pline[i] = '\0';
-
-		for (p = pline + strlen(pline) - 1; isspace((int)*p); --p)
-			/*EMPTY*/;
-
-		if (*p == '\\') {
-			if ((p - line) > MAXLEN_CFG_LINE - 30) {
-				/* Oops the buffer is full - what now? */
-				pline = line;
-			} else {
-				for (p--; isspace((int)*p); --p)
-					/*EMPTY*/;
-				p++;
-				*p = 0;
-				pline = p;
-				continue;
-			}
-		} else
-			pline = line;
-
-		*++p = '\0';
-
-		/* clean the tail comments start from # and not in quotation */
-		in_quotation = 0;
-		for (p = line; *p != '\0'; p++) {
-			if (*p == '"') {
-				in_quotation ^= 1;
-				continue;
-			}
-
-			if (*p == '#' && !in_quotation) {
-				*p = '\0';
-				break;
-			}
-		}
-
-		/* we now have the complete line,
-		 * and are positioned at the first non-whitespace
-		 * character. So let's process it
-		 */
-		rc = zlog_conf_parse_line(a_conf, line, &section);
-		if (rc < 0) {
-			zc_error("parse configure file[%s]line_no[%ld] fail", a_conf->file, line_no);
-			zc_error("line[%s]", line);
-			goto exit;
-		} else if (rc > 0) {
-			zc_warn("parse configure file[%s]line_no[%ld] fail", a_conf->file, line_no);
-			zc_warn("line[%s]", line);
-			zc_warn("as strict init is set to false, ignore and go on");
-			rc = 0;
-			continue;
-		}
-	}
-
-exit:
-	fclose(fp);
-	return rc;
-}
-
-/* section [global:1] [levels:2] [formats:3] [rules:4] */
-static int zlog_conf_parse_line(zlog_conf_t * a_conf, char *line, int *section)
-{
-	int nscan;
-	int nread;
-	char name[MAXLEN_CFG_LINE + 1];
-	char word_1[MAXLEN_CFG_LINE + 1];
-	char word_2[MAXLEN_CFG_LINE + 1];
-	char word_3[MAXLEN_CFG_LINE + 1];
-	char value[MAXLEN_CFG_LINE + 1];
-	zlog_format_t *a_format = NULL;
-	zlog_rule_t *a_rule = NULL;
-
-	if (strlen(line) > MAXLEN_CFG_LINE) {
-		zc_error ("line_len[%ld] > MAXLEN_CFG_LINE[%ld], may cause overflow",
-		     strlen(line), MAXLEN_CFG_LINE);
-		return -1;
-	}
-
-	/* get and set outer section flag, so it is a closure? haha */
-	if (line[0] == '[') {
-		int last_section = *section;
-		nscan = sscanf(line, "[ %[^] \t]", name);
-		if (STRCMP(name, ==, "global")) {
-			*section = 1;
-		} else if (STRCMP(name, ==, "levels")) {
-			*section = 2;
-		} else if (STRCMP(name, ==, "formats")) {
-			*section = 3;
-		} else if (STRCMP(name, ==, "rules")) {
-			*section = 4;
-		} else {
-			zc_error("wrong section name[%s]", name);
-			return -1;
-		}
-		/* check the sequence of section, must increase */
-		if (last_section >= *section) {
-			zc_error("wrong sequence of section, must follow global->levels->formats->rules");
-			return -1;
-		}
-
-		if (*section == 4) {
-			if (a_conf->reload_conf_period != 0
-				&& a_conf->fsync_period >= a_conf->reload_conf_period) {
-				/* as all rule will be rebuilt when conf is reload,
-				 * so fsync_period > reload_conf_period will never
-				 * cause rule to fsync it's file.
-				 * fsync_period will be meaningless and down speed,
-				 * so make it zero.
-				 */
-				zc_warn("fsync_period[%ld] >= reload_conf_period[%ld],"
-					"set fsync_period to zero");
-				a_conf->fsync_period = 0;
-			}
-
-			/* now build rotater and default_format
-			 * from the unchanging global setting,
-			 * for zlog_rule_new() */
-			a_conf->rotater = zlog_rotater_new(a_conf->rotate_lock_file);	
-			if (!a_conf->rotater) {
-				zc_error("zlog_rotater_new fail");
-				return -1;
-			}
-
-			a_conf->default_format = zlog_format_new(a_conf->default_format_line,
-							&(a_conf->time_cache_count));
-			if (!a_conf->default_format) {
-				zc_error("zlog_format_new fail");
-				return -1;
-			}
-		}
-		return 0;
-	}
-
-	/* process detail */
-	switch (*section) {
-	case 1:
-		memset(name, 0x00, sizeof(name));
-		memset(value, 0x00, sizeof(value));
-		nscan = sscanf(line, " %[^=]= %s ", name, value);
-		if (nscan != 2) {
-			zc_error("sscanf [%s] fail, name or value is null", line);
-			return -1;
-		}
-
-		memset(word_1, 0x00, sizeof(word_1));
-		memset(word_2, 0x00, sizeof(word_2));
-		memset(word_3, 0x00, sizeof(word_3));
-		nread = 0;
-		nscan = sscanf(name, "%s%n%s%s", word_1, &nread, word_2, word_3);
-
-		if (STRCMP(word_1, ==, "strict") && STRCMP(word_2, ==, "init")) {
-			/* if environment variable ZLOG_STRICT_INIT is set
-			 * then always make it strict 
-			 */
-			if (STRICMP(value, ==, "false") && !getenv("ZLOG_STRICT_INIT")) {
-				a_conf->strict_init = 0;
-			} else {
-				a_conf->strict_init = 1;
-			}
-		} else if (STRCMP(word_1, ==, "buffer") && STRCMP(word_2, ==, "min")) {
-			a_conf->buf_size_min = zc_parse_byte_size(value);
-		} else if (STRCMP(word_1, ==, "buffer") && STRCMP(word_2, ==, "max")) {
-			a_conf->buf_size_max = zc_parse_byte_size(value);
-		} else if (STRCMP(word_1, ==, "file") && STRCMP(word_2, ==, "perms")) {
-			sscanf(value, "%o", &(a_conf->file_perms));
-		} else if (STRCMP(word_1, ==, "rotate") &&
-				STRCMP(word_2, ==, "lock") && STRCMP(word_3, ==, "file")) {
-			/* may overwrite the inner default value, or last value */
-			if (STRCMP(value, ==, "self")) {
-				strcpy(a_conf->rotate_lock_file, a_conf->file);
-			} else {
-				strcpy(a_conf->rotate_lock_file, value);
-			}
-		} else if (STRCMP(word_1, ==, "default") && STRCMP(word_2, ==, "format")) {
-			/* so the input now is [format = "xxyy"], fit format's style */
-			strcpy(a_conf->default_format_line, line + nread);
-		} else if (STRCMP(word_1, ==, "reload") &&
-				STRCMP(word_2, ==, "conf") && STRCMP(word_3, ==, "period")) {
-			a_conf->reload_conf_period = zc_parse_byte_size(value);
-		} else if (STRCMP(word_1, ==, "fsync") && STRCMP(word_2, ==, "period")) {
-			a_conf->fsync_period = zc_parse_byte_size(value);
-		} else {
-			zc_error("name[%s] is not any one of global options", name);
-			if (a_conf->strict_init) return -1;
-		}
-		break;
-	case 2:
-		if (zlog_level_list_set(a_conf->levels, line)) {
-			zc_error("zlog_level_list_set fail");
-			if (a_conf->strict_init) return -1;
-		}
-		break;
-	case 3:
-		a_format = zlog_format_new(line, &(a_conf->time_cache_count));
-		if (!a_format) {
-			zc_error("zlog_format_new fail [%s]", line);
-			if (a_conf->strict_init) return -1;
-			else break;
-		}
-		if (zc_arraylist_add(a_conf->formats, a_format)) {
-			zlog_format_del(a_format);
-			zc_error("zc_arraylist_add fail");
-			return -1;
-		}
-		break;
-	case 4:
-		a_rule = zlog_rule_new(line,
-			a_conf->levels,
-			a_conf->default_format,
-			a_conf->formats,
-			a_conf->file_perms,
-			a_conf->fsync_period,
-			&(a_conf->time_cache_count));
-
-		if (!a_rule) {
-			zc_error("zlog_rule_new fail [%s]", line);
-			if (a_conf->strict_init) return -1;
-			else break;
-		}
-		if (zc_arraylist_add(a_conf->rules, a_rule)) {
-			zlog_rule_del(a_rule);
-			zc_error("zc_arraylist_add fail");
-			return -1;
-		}
-		break;
-	default:
-		zc_error("not in any section");
-		return -1;
-	}
-
-	return 0;
-}
-/*******************************************************************************/

zlog/conf.h

@@ -1,46 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_conf_h
-#define __zlog_conf_h
-
-#include "zc_defs.h"
-#include "format.h"
-#include "rotater.h"
-
-typedef struct zlog_conf_s {
-	char file[MAXLEN_PATH + 1];
-	char mtime[20 + 1];
-
-	int strict_init;
-	size_t buf_size_min;
-	size_t buf_size_max;
-
-	char rotate_lock_file[MAXLEN_CFG_LINE + 1];
-	zlog_rotater_t *rotater;
-
-	char default_format_line[MAXLEN_CFG_LINE + 1];
-	zlog_format_t *default_format;
-
-	unsigned int file_perms;
-	size_t fsync_period;
-	size_t reload_conf_period;
-
-	zc_arraylist_t *levels;
-	zc_arraylist_t *formats;
-	zc_arraylist_t *rules;
-	int time_cache_count;
-} zlog_conf_t;
-
-extern zlog_conf_t * zlog_env_conf;
-
-zlog_conf_t *zlog_conf_new(const char *confpath);
-void zlog_conf_del(zlog_conf_t * a_conf);
-void zlog_conf_profile(zlog_conf_t * a_conf, int flag);
-
-#endif

zlog/event.c

@@ -1,182 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#define _GNU_SOURCE // For distros like Centos for syscall interface
-
-#include "fmacros.h"
-#include <string.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-
-#include <pthread.h>
-#include <unistd.h>
-#include <sys/time.h>
-
-#include <sys/types.h>
-#include <sys/syscall.h>
-
-#include "zc_defs.h"
-#include "event.h"
-
-void zlog_event_profile(zlog_event_t * a_event, int flag)
-{
-	zc_assert(a_event,);
-	zc_profile(flag, "---event[%p][%s,%s][%s(%ld),%s(%ld),%ld,%d][%p,%s][%ld,%ld][%ld,%ld][%d]---",
-			a_event,
-			a_event->category_name, a_event->host_name,
-			a_event->file, a_event->file_len,
-			a_event->func, a_event->func_len,
-			a_event->line, a_event->level,
-			a_event->hex_buf, a_event->str_format,
-			a_event->time_stamp.tv_sec, a_event->time_stamp.tv_usec,
-			(long)a_event->pid, (long)a_event->tid,
-			a_event->time_cache_count);
-	return;
-}
-
-/*******************************************************************************/
-
-void zlog_event_del(zlog_event_t * a_event)
-{
-	zc_assert(a_event,);
-	if (a_event->time_caches) free(a_event->time_caches);
-	zc_debug("zlog_event_del[%p]", a_event);
-    free(a_event);
-	return;
-}
-
-zlog_event_t *zlog_event_new(int time_cache_count)
-{
-	zlog_event_t *a_event;
-
-	a_event = calloc(1, sizeof(zlog_event_t));
-	if (!a_event) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	a_event->time_caches = calloc(time_cache_count, sizeof(zlog_time_cache_t));
-	if (!a_event->time_caches) {
-		zc_error("calloc fail, errno[%d]", errno);
-		free(a_event);
-		return NULL;
-	}
-	a_event->time_cache_count = time_cache_count;
-
-	/*
-	 * at the zlog_init we gethostname,
-	 * u don't always change your hostname, eh?
-	 */
-	if (gethostname(a_event->host_name, sizeof(a_event->host_name) - 1)) {
-		zc_error("gethostname fail, errno[%d]", errno);
-		goto err;
-	}
-
-	a_event->host_name_len = strlen(a_event->host_name);
-
-	/* tid is bound to a_event
-	 * as in whole lifecycle event persists
-	 * even fork to oth pid, tid not change
-	 */
-	a_event->tid = pthread_self();
-
-	a_event->tid_str_len = sprintf(a_event->tid_str, "%lu", (unsigned long)a_event->tid);
-	a_event->tid_hex_str_len = sprintf(a_event->tid_hex_str, "%x", (unsigned int)a_event->tid);
-
-#ifdef __linux__
-	a_event->ktid = syscall(SYS_gettid);
-#elif __APPLE__
-    uint64_t tid64;
-    pthread_threadid_np(NULL, &tid64);
-    a_event->tid = (pid_t)tid64;
-#endif
-
-#if defined __linux__ || __APPLE__
-	a_event->ktid_str_len = sprintf(a_event->ktid_str, "%u", (unsigned int)a_event->ktid);
-#endif
-
-	//zlog_event_profile(a_event, ZC_DEBUG);
-	return a_event;
-err:
-	zlog_event_del(a_event);
-	return NULL;
-}
-
-/*******************************************************************************/
-void zlog_event_set_fmt(zlog_event_t * a_event,
-			char *category_name, size_t category_name_len,
-			const char *file, size_t file_len, const char *func, size_t func_len,  long line, int level,
-			const char *str_format, va_list str_args)
-{
-	/*
-	 * category_name point to zlog_category_output's category.name
-	 */
-	a_event->category_name = category_name;
-	a_event->category_name_len = category_name_len;
-
-	a_event->file = (char *) file;
-	a_event->file_len = file_len;
-	a_event->func = (char *) func;
-	a_event->func_len = func_len;
-	a_event->line = line;
-	a_event->level = level;
-
-	a_event->generate_cmd = ZLOG_FMT;
-	a_event->str_format = str_format;
-	va_copy(a_event->str_args, str_args);
-
-	/* pid should fetch eveytime, as no one knows,
-	 * when does user fork his process
-	 * so clean here, and fetch at spec.c
-	 */
-	a_event->pid = (pid_t) 0;
-
-	/* in a event's life cycle, time will be get when spec need,
-	 * and keep unchange though all event's life cycle
-	 * zlog_spec_write_time gettimeofday
-	 */
-	a_event->time_stamp.tv_sec = 0;
-	return;
-}
-
-void zlog_event_set_hex(zlog_event_t * a_event,
-			char *category_name, size_t category_name_len,
-			const char *file, size_t file_len, const char *func, size_t func_len,  long line, int level,
-			const void *hex_buf, size_t hex_buf_len)
-{
-	/*
-	 * category_name point to zlog_category_output's category.name
-	 */
-	a_event->category_name = category_name;
-	a_event->category_name_len = category_name_len;
-
-	a_event->file = (char *) file;
-	a_event->file_len = file_len;
-	a_event->func = (char *) func;
-	a_event->func_len = func_len;
-	a_event->line = line;
-	a_event->level = level;
-
-	a_event->generate_cmd = ZLOG_HEX;
-	a_event->hex_buf = hex_buf;
-	a_event->hex_buf_len = hex_buf_len;
-
-	/* pid should fetch eveytime, as no one knows,
-	 * when does user fork his process
-	 * so clean here, and fetch at spec.c
-	 */
-	a_event->pid = (pid_t) 0;
-
-	/* in a event's life cycle, time will be get when spec need,
-	 * and keep unchange though all event's life cycle
-	 */
-	a_event->time_stamp.tv_sec = 0;
-	return;
-}

zlog/event.h

@@ -1,90 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_event_h
-#define __zlog_event_h
-
-#include <sys/types.h>  /* for pid_t */
-#include <sys/time.h>   /* for struct timeval */
-#include <pthread.h>    /* for pthread_t */
-#include <stdarg.h>     /* for va_list */
-#include "zc_defs.h"
-
-typedef enum {
-	ZLOG_FMT = 0,
-	ZLOG_HEX = 1,
-} zlog_event_cmd;
-
-typedef struct zlog_time_cache_s {
-	char str[MAXLEN_CFG_LINE + 1];
-	size_t len;
-	time_t sec;
-} zlog_time_cache_t;
-
-typedef struct {
-	char *category_name;
-	size_t category_name_len;
-	char host_name[256 + 1];
-	size_t host_name_len;
-
-	const char *file;
-	size_t file_len;
-	const char *func;
-	size_t func_len;
-	long line;
-	int level;
-
-	const void *hex_buf;
-	size_t hex_buf_len;
-	const char *str_format;
-	va_list str_args;
-	zlog_event_cmd generate_cmd;
-
-	struct timeval time_stamp;
-
-	time_t time_local_sec;
-	struct tm time_local;
-
-	zlog_time_cache_t *time_caches;
-	int time_cache_count;
-
-	pid_t pid;
-	pid_t last_pid;
-	char pid_str[30 + 1];
-	size_t pid_str_len;
-
-	pthread_t tid;
-	char tid_str[30 + 1];
-	size_t tid_str_len;
-
-	char tid_hex_str[30 + 1];
-	size_t tid_hex_str_len;
-
-#if defined __linux__ || __APPLE__
-	pid_t ktid;
-	char ktid_str[30+1];
-	size_t ktid_str_len;
-#endif
-} zlog_event_t;
-
-
-zlog_event_t *zlog_event_new(int time_cache_count);
-void zlog_event_del(zlog_event_t * a_event);
-void zlog_event_profile(zlog_event_t * a_event, int flag);
-
-void zlog_event_set_fmt(zlog_event_t * a_event,
-			char *category_name, size_t category_name_len,
-			const char *file, size_t file_len, const char *func, size_t func_len, long line, int level,
-			const char *str_format, va_list str_args);
-
-void zlog_event_set_hex(zlog_event_t * a_event,
-			char *category_name, size_t category_name_len,
-			const char *file, size_t file_len, const char *func, size_t func_len, long line, int level,
-			const void *hex_buf, size_t hex_buf_len);
-
-#endif

zlog/fmacros.h

@@ -1,24 +0,0 @@
-#ifndef __zlog_fmacro_h
-#define __zlog_fmacro_h
-
-#define _DEFAULT_SOURCE
-
-#if defined(__linux__) || defined(__OpenBSD__) || defined(_AIX)
-#ifndef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 700
-#endif
-#ifndef _XOPEN_SOURCE_EXTENDED
-#define _XOPEN_SOURCE_EXTENDED
-#endif
-#else
-#define _XOPEN_SOURCE
-#endif
-
-#ifndef _LARGEFILE_SOURCE
-#define _LARGEFILE_SOURCE
-#endif
-#ifndef _FILE_OFFSET_BITS
-#define _FILE_OFFSET_BITS 64
-#endif
-
-#endif

zlog/format.c

@@ -1,164 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include <ctype.h>
-
-#include "zc_defs.h"
-#include "thread.h"
-#include "spec.h"
-#include "format.h"
-
-void zlog_format_profile(zlog_format_t * a_format, int flag)
-{
-
-	zc_assert(a_format,);
-	zc_profile(flag, "---format[%p][%s = %s(%p)]---",
-		a_format,
-		a_format->name,
-		a_format->pattern,
-		a_format->pattern_specs);
-
-#if 0
-	int i;
-	zlog_spec_t *a_spec;
-	zc_arraylist_foreach(a_format->pattern_specs, i, a_spec) {
-		zlog_spec_profile(a_spec, flag);
-	}
-#endif
-
-	return;
-}
-
-/*******************************************************************************/
-void zlog_format_del(zlog_format_t * a_format)
-{
-	zc_assert(a_format,);
-	if (a_format->pattern_specs) {
-		zc_arraylist_del(a_format->pattern_specs);
-	}
-	zc_debug("zlog_format_del[%p]", a_format);
-    free(a_format);
-	return;
-}
-
-zlog_format_t *zlog_format_new(char *line, int * time_cache_count)
-{
-	int nscan = 0;
-	zlog_format_t *a_format = NULL;
-	int nread = 0;
-	const char *p_start;
-	const char *p_end;
-	char *p;
-	char *q;
-	zlog_spec_t *a_spec;
-
-	zc_assert(line, NULL);
-
-	a_format = calloc(1, sizeof(zlog_format_t));
-	if (!a_format) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	/* line         default = "%d(%F %X.%l) %-6V (%c:%F:%L) - %m%n"
-	 * name         default
-	 * pattern      %d(%F %X.%l) %-6V (%c:%F:%L) - %m%n
-	 */
-	memset(a_format->name, 0x00, sizeof(a_format->name));
-	nread = 0;
-	nscan = sscanf(line, " %[^= \t] = %n", a_format->name, &nread);
-	if (nscan != 1) {
-		zc_error("format[%s], syntax wrong", line);
-		goto err;
-	}
-
-	if (*(line + nread) != '"') {
-		zc_error("the 1st char of pattern is not \", line+nread[%s]", line+nread);
-		goto err;
-	}
-
-	for (p = a_format->name; *p != '\0'; p++) {
-		if ((!isalnum(*p)) && (*p != '_')) {
-			zc_error("a_format->name[%s] character is not in [a-Z][0-9][_]", a_format->name);
-			goto err;
-		}
-	}
-
-	p_start = line + nread + 1;
-	p_end = strrchr(p_start, '"');
-	if (!p_end) {
-		zc_error("there is no \" at end of pattern, line[%s]", line);
-		goto err;
-	}
-
-	if (p_end - p_start > sizeof(a_format->pattern) - 1) {
-		zc_error("pattern is too long");
-		goto err;
-	}
-	memset(a_format->pattern, 0x00, sizeof(a_format->pattern));
-	memcpy(a_format->pattern, p_start, p_end - p_start);
-
-	if (zc_str_replace_env(a_format->pattern, sizeof(a_format->pattern))) {
-		zc_error("zc_str_replace_env fail");
-		goto err;
-	}
-
-	a_format->pattern_specs =
-	    zc_arraylist_new((zc_arraylist_del_fn) zlog_spec_del);
-	if (!(a_format->pattern_specs)) {
-		zc_error("zc_arraylist_new fail");
-		goto err;
-	}
-
-	for (p = a_format->pattern; *p != '\0'; p = q) {
-		a_spec = zlog_spec_new(p, &q, time_cache_count);
-		if (!a_spec) {
-			zc_error("zlog_spec_new fail");
-			goto err;
-		}
-
-		if (zc_arraylist_add(a_format->pattern_specs, a_spec)) {
-			zlog_spec_del(a_spec);
-			zc_error("zc_arraylist_add fail");
-			goto err;
-		}
-	}
-
-	zlog_format_profile(a_format, ZC_DEBUG);
-	return a_format;
-err:
-	zlog_format_del(a_format);
-	return NULL;
-}
-
-/*******************************************************************************/
-/* return 0	success, or buf is full
- * return -1	fail
- */
-int zlog_format_gen_msg(zlog_format_t * a_format, zlog_thread_t * a_thread)
-{
-	int i;
-	zlog_spec_t *a_spec;
-
-	zlog_buf_restart(a_thread->msg_buf);
-
-	zc_arraylist_foreach(a_format->pattern_specs, i, a_spec) {
-		if (zlog_spec_gen_msg(a_spec, a_thread) == 0) {
-			continue;
-		} else {
-			return -1;
-		}
-	}
-
-	return 0;
-}

zlog/format.h

@@ -1,32 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_format_h
-#define __zlog_format_h
-
-#include "thread.h"
-#include "zc_defs.h"
-
-typedef struct zlog_format_s zlog_format_t;
-
-struct zlog_format_s {
-	char name[MAXLEN_CFG_LINE + 1];	
-	char pattern[MAXLEN_CFG_LINE + 1];
-	zc_arraylist_t *pattern_specs;
-};
-
-zlog_format_t *zlog_format_new(char *line, int * time_cache_count);
-void zlog_format_del(zlog_format_t * a_format);
-void zlog_format_profile(zlog_format_t * a_format, int flag);
-
-int zlog_format_gen_msg(zlog_format_t * a_format, zlog_thread_t * a_thread);
-
-#define zlog_format_has_name(a_format, fname) \
-	STRCMP(a_format->name, ==, fname)
-
-#endif

zlog/level.c

@@ -1,141 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include "syslog.h"
-
-#include "zc_defs.h"
-#include "level.h"
-
-void zlog_level_profile(zlog_level_t *a_level, int flag)
-{
-	zc_assert(a_level,);
-	zc_profile(flag, "---level[%p][%d,%s,%s,%d,%d]---",
-		a_level,
-		a_level->int_level,
-		a_level->str_uppercase,
-		a_level->str_lowercase,
-		(int) a_level->str_len,
-		a_level->syslog_level);
-	return;
-}
-
-/*******************************************************************************/
-void zlog_level_del(zlog_level_t *a_level)
-{
-	zc_assert(a_level,);
-	zc_debug("zlog_level_del[%p]", a_level);
-    free(a_level);
-	return;
-}
-
-static int syslog_level_atoi(char *str)
-{
-	/* guess no unix system will choose -187
-	 * as its syslog level, so it is a safe return value
-	 */
-	zc_assert(str, -187);
-
-	if (STRICMP(str, ==, "LOG_EMERG"))
-		return LOG_EMERG;
-	if (STRICMP(str, ==, "LOG_ALERT"))
-		return LOG_ALERT;
-	if (STRICMP(str, ==, "LOG_CRIT"))
-		return LOG_CRIT;
-	if (STRICMP(str, ==, "LOG_ERR"))
-		return LOG_ERR;
-	if (STRICMP(str, ==, "LOG_WARNING"))
-		return LOG_WARNING;
-	if (STRICMP(str, ==, "LOG_NOTICE"))
-		return LOG_NOTICE;
-	if (STRICMP(str, ==, "LOG_INFO"))
-		return LOG_INFO;
-	if (STRICMP(str, ==, "LOG_DEBUG"))
-		return LOG_DEBUG;
-
-	zc_error("wrong syslog level[%s]", str);
-	return -187;
-}
-
-/* line: TRACE = 10, LOG_ERR */
-zlog_level_t *zlog_level_new(char *line)
-{
-	zlog_level_t *a_level = NULL;
-	int i;
-	int nscan;
-	char str[MAXLEN_CFG_LINE + 1];
-	int l = 0;
-	char sl[MAXLEN_CFG_LINE + 1];
-
-	zc_assert(line, NULL);
-
-	memset(str, 0x00, sizeof(str));
-	memset(sl, 0x00, sizeof(sl));
-
-	nscan = sscanf(line, " %[^= \t] = %d ,%s", str, &l, sl);
-	if (nscan < 2) {
-		zc_error("level[%s], syntax wrong", line);
-		return NULL;
-	}
-
-	/* check level and str */
-	if ((l < 0) || (l > 255)) {
-		zc_error("l[%d] not in [0,255], wrong", l);
-		return NULL;
-	}
-
-	if (str[0] == '\0') {
-		zc_error("str[0] = 0");
-		return NULL;
-	}
-
-	a_level = calloc(1, sizeof(zlog_level_t));
-	if (!a_level) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	a_level->int_level = l;
-
-	/* fill syslog level */
-	if (sl[0] == '\0') {
-		a_level->syslog_level = LOG_DEBUG;
-	} else {
-		a_level->syslog_level = syslog_level_atoi(sl);
-		if (a_level->syslog_level == -187) {
-			zc_error("syslog_level_atoi fail");
-			goto err;
-		}
-	}
-
-	/* strncpy and toupper(str)  */
-	for (i = 0; (i < sizeof(a_level->str_uppercase) - 1) && str[i] != '\0'; i++) {
-		(a_level->str_uppercase)[i] = toupper(str[i]);
-		(a_level->str_lowercase)[i] = tolower(str[i]);
-	}
-
-	if (str[i] != '\0') {
-		/* overflow */
-		zc_error("not enough space for str, str[%s] > %d", str, i);
-		goto err;
-	} else {
-		(a_level->str_uppercase)[i] = '\0';
-		(a_level->str_lowercase)[i] = '\0';
-	}
-
-	a_level->str_len = i;
-
-	//zlog_level_profile(a_level, ZC_DEBUG);
-	return a_level;
-err:
-	zc_error("line[%s]", line);
-	zlog_level_del(a_level);
-	return NULL;
-}

zlog/level.h

@@ -1,26 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_level_h
-#define __zlog_level_h
-
-#include "zc_defs.h"
-
-typedef struct zlog_level_s {
-	int int_level;
-	char str_uppercase[MAXLEN_PATH + 1];
-	char str_lowercase[MAXLEN_PATH + 1];
-	size_t str_len;
-       	int syslog_level;
-} zlog_level_t;
-
-zlog_level_t *zlog_level_new(char *line);
-void zlog_level_del(zlog_level_t *a_level);
-void zlog_level_profile(zlog_level_t *a_level, int flag);
-
-#endif

zlog/level_list.c

@@ -1,145 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include "syslog.h"
-
-#include "zc_defs.h"
-#include "level.h"
-#include "level_list.h"
-
-/* zlog_level_list == zc_arraylist_t<zlog_level_t> */
-
-void zlog_level_list_profile(zc_arraylist_t *levels, int flag)
-{
-	int i;
-	zlog_level_t *a_level;
-
-	zc_assert(levels,);
-	zc_profile(flag, "--level_list[%p]--", levels);
-	zc_arraylist_foreach(levels, i, a_level) {
-		/* skip empty slots */
-		if (a_level) zlog_level_profile(a_level, flag);
-	}
-	return;
-}
-
-/*******************************************************************************/
-void zlog_level_list_del(zc_arraylist_t *levels)
-{
-	zc_assert(levels,);
-	zc_arraylist_del(levels);
-	zc_debug("zc_level_list_del[%p]", levels);
-	return;
-}
-
-static int zlog_level_list_set_default(zc_arraylist_t *levels)
-{
-	return zlog_level_list_set(levels, "* = 0, LOG_INFO")
-	|| zlog_level_list_set(levels, "DEBUG = 20, LOG_DEBUG")
-	|| zlog_level_list_set(levels, "INFO = 40, LOG_INFO")
-	|| zlog_level_list_set(levels, "NOTICE = 60, LOG_NOTICE")
-	|| zlog_level_list_set(levels, "WARN = 80, LOG_WARNING")
-	|| zlog_level_list_set(levels, "ERROR = 100, LOG_ERR")
-	|| zlog_level_list_set(levels, "FATAL = 120, LOG_ALERT")
-	|| zlog_level_list_set(levels, "UNKNOWN = 254, LOG_ERR")
-	|| zlog_level_list_set(levels, "! = 255, LOG_INFO");
-}
-
-zc_arraylist_t *zlog_level_list_new(void)
-{
-	zc_arraylist_t *levels;
-
-	levels = zc_arraylist_new((zc_arraylist_del_fn)zlog_level_del);
-	if (!levels) {
-		zc_error("zc_arraylist_new fail");
-		return NULL;
-	}
-
-	if (zlog_level_list_set_default(levels)) {
-		zc_error("zlog_level_set_default fail");
-		goto err;
-	}
-
-	//zlog_level_list_profile(levels, ZC_DEBUG);
-	return levels;
-err:
-	zc_arraylist_del(levels);
-	return NULL;
-}
-
-/*******************************************************************************/
-int zlog_level_list_set(zc_arraylist_t *levels, char *line)
-{
-	zlog_level_t *a_level;
-
-	a_level = zlog_level_new(line);
-	if (!a_level) {
-		zc_error("zlog_level_new fail");
-		return -1;
-	}
-
-	if (zc_arraylist_set(levels, a_level->int_level, a_level)) {
-		zc_error("zc_arraylist_set fail");
-		goto err;
-	}
-
-	return 0;
-err:
-	zc_error("line[%s]", line);
-	zlog_level_del(a_level);
-	return -1;
-}
-
-zlog_level_t *zlog_level_list_get(zc_arraylist_t *levels, int l)
-{
-	zlog_level_t *a_level;
-
-#if 0
-	if ((l <= 0) || (l > 254)) {
-		/* illegal input from zlog() */
-		zc_error("l[%d] not in (0,254), set to UNKOWN", l);
-		l = 254;
-	}
-#endif
-
-	a_level = zc_arraylist_get(levels, l);
-	if (a_level) {
-		return a_level;
-	} else {
-		/* empty slot */
-		zc_error("l[%d] not in (0,254), or has no level defined,"
-			"see configure file define, set to UNKOWN", l);
-		return zc_arraylist_get(levels, 254);
-	}
-}
-
-/*******************************************************************************/
-
-int zlog_level_list_atoi(zc_arraylist_t *levels, char *str)
-{
-	int i;
-	zlog_level_t *a_level;
-
-	if (str == NULL || *str == '\0') {
-		zc_error("str is [%s], can't find level", str);
-		return -1;
-	}
-
-	zc_arraylist_foreach(levels, i, a_level) {
-		if (a_level && STRICMP(str, ==, a_level->str_uppercase)) {
-			return i;
-		}
-	}
-
-	zc_error("str[%s] can't found in level list", str);
-	return -1;
-}
-

zlog/level_list.h

@@ -1,33 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_level_list_h
-#define __zlog_level_list_h
-
-#include "zc_defs.h"
-#include "level.h"
-
-zc_arraylist_t *zlog_level_list_new(void);
-void zlog_level_list_del(zc_arraylist_t *levels);
-void zlog_level_list_profile(zc_arraylist_t *levels, int flag);
-
-/* conf init use, slow */
-/* if l is wrong or str=="", return -1 */
-int zlog_level_list_set(zc_arraylist_t *levels, char *line);
-
-/* spec ouput use, fast */
-/* rule output use, fast */
-/* if not found, return levels[254] */
-zlog_level_t *zlog_level_list_get(zc_arraylist_t *levels, int l);
-
-/* rule init use, slow */
-/* if not found, return -1 */
-int zlog_level_list_atoi(zc_arraylist_t *levels, char *str);
-
-
-#endif

zlog/makefile

@@ -1,204 +0,0 @@
-# zlog makefile
-# Copyright (C) 2010-2012 Hardy Simpson <HardySimpson1984@gmail.com>
-# This file is released under the LGPL 2.1 license, see the COPYING file
-
-OBJ=    \
-  buf.o    \
-  category.o    \
-  category_table.o    \
-  conf.o    \
-  event.o    \
-  format.o    \
-  level.o    \
-  level_list.o    \
-  mdc.o    \
-  record.o    \
-  record_table.o    \
-  rotater.o    \
-  rule.o    \
-  spec.o    \
-  thread.o    \
-  zc_arraylist.o    \
-  zc_hashtable.o    \
-  zc_profile.o    \
-  zc_util.o    \
-  zlog.o
-BINS=zlog-chk-conf
-LIBNAME=libzlog
-
-ZLOG_MAJOR=1
-ZLOG_MINOR=2
-
-# Fallback to gcc when $CC is not in $PATH.
-CC:=$(shell sh -c 'type $(CC) >/dev/null 2>/dev/null && echo $(CC) || echo gcc')
-OPTIMIZATION?=-O2
-WARNINGS=-Wall -Wstrict-prototypes -fwrapv
-DEBUG?= -g -ggdb
-REAL_CFLAGS=$(OPTIMIZATION) -fPIC -pthread $(CFLAGS) $(WARNINGS) $(DEBUG)
-REAL_LDFLAGS=$(LDFLAGS) -pthread
-
-DYLIBSUFFIX=so
-STLIBSUFFIX=a
-DYLIB_MINOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(ZLOG_MAJOR).$(ZLOG_MINOR)
-DYLIB_MAJOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(ZLOG_MAJOR)
-DYLIBNAME=$(LIBNAME).$(DYLIBSUFFIX)
-DYLIB_MAKE_CMD=$(CC) -shared -Wl,-soname,$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)
-STLIBNAME=$(LIBNAME).$(STLIBSUFFIX)
-STLIB_MAKE_CMD=ar rcs $(STLIBNAME)
-
-# Installation related variables
-PREFIX?=/usr/local
-INCLUDE_PATH=include
-LIBRARY_PATH=lib
-BINARY_PATH=bin
-INSTALL_INCLUDE_PATH= $(PREFIX)/$(INCLUDE_PATH)
-INSTALL_LIBRARY_PATH= $(PREFIX)/$(LIBRARY_PATH)
-INSTALL_BINARY_PATH=  $(PREFIX)/$(BINARY_PATH)
-
-# Platform-specific overrides
-uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
-compiler_platform := $(shell sh -c '$(CC) --version|grep -i apple')
-
-ifeq ($(uname_S),SunOS)
-#  REAL_LDFLAGS+= -ldl -lnsl -lsocket
-  DYLIB_MAKE_CMD=$(CC) -G -o $(DYLIBNAME) -h $(DYLIB_MINOR_NAME) $(LDFLAGS)
-  INSTALL= cp -r
-endif
-
-# For Darwin builds, check the compiler platform above is not empty. The covers cross compilation on Linux
-ifneq ($(compiler_platform),)
-  DYLIBSUFFIX=dylib
-  DYLIB_MINOR_NAME=$(LIBNAME).$(ZLOG_MAJOR).$(ZLOG_MINOR).$(DYLIBSUFFIX)
-  DYLIB_MAJOR_NAME=$(LIBNAME).$(ZLOG_MAJOR).$(DYLIBSUFFIX)
-  DYLIB_MAKE_CMD=$(CC) -dynamiclib -install_name $(INSTALL_LIBRARY_PATH)/$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)
-endif
-
-ifeq ($(uname_S),AIX)
-  # this logic of minor major is not relevant on AIX or at least not widely used
-  # not to mention dynamic linker .a preference...
-  DYLIB_MAKE_CMD=$(CC) -shared -Wl,-G,-b64 -maix64 -pthread -o $(DYLIBNAME) $(LDFLAGS)
-  REAL_CFLAGS+= -maix64
-  STLIB_MAKE_CMD=OBJECT_MODE=64 ar rcs $(STLIBNAME) $(DYLIB_MAJOR_NAME)
-endif
-
-all: $(DYLIBNAME) $(BINS)
-
-# Deps (use make dep to generate this)
-buf.o: buf.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h buf.h
-category.o: category.c fmacros.h category.h zc_defs.h zc_profile.h \
- zc_arraylist.h zc_hashtable.h zc_xplatform.h zc_util.h thread.h event.h \
- buf.h mdc.h rule.h format.h rotater.h record.h
-category_table.o: category_table.c zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h category_table.h category.h \
- thread.h event.h buf.h mdc.h
-conf.o: conf.c fmacros.h conf.h zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h format.h thread.h event.h buf.h \
- mdc.h rotater.h rule.h record.h level_list.h level.h
-event.o: event.c fmacros.h zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h event.h
-format.o: format.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h thread.h event.h buf.h mdc.h spec.h format.h
-level.o: level.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h level.h
-level_list.o: level_list.c zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h level.h level_list.h
-mdc.o: mdc.c mdc.h zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h
-record.o: record.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h record.h
-record_table.o: record_table.c zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h record_table.h record.h
-rotater.o: rotater.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h rotater.h
-rule.o: rule.c fmacros.h rule.h zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h format.h thread.h event.h buf.h \
- mdc.h rotater.h record.h level_list.h level.h spec.h
-spec.o: spec.c fmacros.h spec.h event.h zc_defs.h zc_profile.h \
- zc_arraylist.h zc_hashtable.h zc_xplatform.h zc_util.h buf.h thread.h \
- mdc.h level_list.h level.h
-thread.o: thread.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h event.h buf.h thread.h mdc.h
-zc_arraylist.o: zc_arraylist.c zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h
-zc_hashtable.o: zc_hashtable.c zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h
-zc_profile.o: zc_profile.c fmacros.h zc_profile.h zc_xplatform.h
-zc_util.o: zc_util.c zc_defs.h zc_profile.h zc_arraylist.h zc_hashtable.h \
- zc_xplatform.h zc_util.h
-zlog-chk-conf.o: zlog-chk-conf.c fmacros.h zlog.h
-zlog.o: zlog.c fmacros.h conf.h zc_defs.h zc_profile.h zc_arraylist.h \
- zc_hashtable.h zc_xplatform.h zc_util.h format.h thread.h event.h buf.h \
- mdc.h rotater.h category_table.h category.h record_table.h \
- record.h rule.h
-
-$(DYLIBNAME): $(OBJ)
-	$(DYLIB_MAKE_CMD) $(OBJ) $(REAL_LDFLAGS)
-	# for use in test folder - linux and requirement for aix runtime
-	# resolving
-	cp -f $(DYLIBNAME) $(DYLIB_MAJOR_NAME)
-	cp -f $(DYLIBNAME) $(DYLIB_MINOR_NAME)
-
-$(STLIBNAME): $(OBJ)
-	$(STLIB_MAKE_CMD) $(OBJ)
-
-dynamic: $(DYLIBNAME)
-static: $(STLIBNAME)
-
-# Binaries:
-zlog-chk-conf: zlog-chk-conf.o $(STLIBNAME) $(DYLIBNAME)
-	$(CC) -o $@ zlog-chk-conf.o -L. -lzlog $(REAL_LDFLAGS)
-
-.c.o:
-	$(CC) -std=c99 -pedantic -c $(REAL_CFLAGS) $<
-
-clean:
-	rm -rf $(DYLIBNAME) $(STLIBNAME) $(BINS) *.o *.gcda *.gcno *.gcov $(DYLIB_MINOR_NAME) $(DYLIB_MAJOR_NAME)
-
-dep:
-	$(CC) -MM *.c
-
-# Installation target
-
-ifeq ($(uname_S),SunOS)
-  INSTALL?= cp -r
-endif
-
-ifeq ($(uname_S),AIX)
-  INSTALL?= cp -r
-endif
-
-
-INSTALL?= cp -a
-
-install: $(DYLIBNAME) $(STLIBNAME)
-	mkdir -p $(INSTALL_INCLUDE_PATH) $(INSTALL_LIBRARY_PATH) $(INSTALL_BINARY_PATH)
-	$(INSTALL) zlog.h $(INSTALL_INCLUDE_PATH)
-	$(INSTALL) zlog-chk-conf $(INSTALL_BINARY_PATH)
-	$(INSTALL) $(DYLIBNAME) $(INSTALL_LIBRARY_PATH)/$(DYLIB_MINOR_NAME)
-	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIB_MAJOR_NAME)
-	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MAJOR_NAME) $(DYLIBNAME)
-	$(INSTALL) $(STLIBNAME) $(INSTALL_LIBRARY_PATH)
-
-32bit:
-	@echo ""
-	@echo "WARNING: if this fails under Linux you probably need to install libc6-dev-i386"
-	@echo ""
-	$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"
-
-gprof:
-	$(MAKE) CFLAGS="-pg" LDFLAGS="-pg"
-
-gcov:
-	$(MAKE) CFLAGS="-fprofile-arcs -ftest-coverage" LDFLAGS="-fprofile-arcs"
-
-coverage: gcov
-	make check
-	mkdir -p tmp/lcov
-	lcov -d . -c -o tmp/lcov/hiredis.info
-	genhtml --legend -o tmp/lcov/report tmp/lcov/hiredis.info
-
-noopt:
-	$(MAKE) OPTIMIZATION=""
-
-.PHONY: all clean dep install 32bit gprof gcov noopt

zlog/mdc.c

@@ -1,145 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-
-#include "mdc.h"
-#include "zc_defs.h"
-
-void zlog_mdc_profile(zlog_mdc_t *a_mdc, int flag)
-{
-	zc_hashtable_entry_t *a_entry;
-	zlog_mdc_kv_t *a_mdc_kv;
-
-	zc_assert(a_mdc,);
-	zc_profile(flag, "---mdc[%p]---", a_mdc);
-
-	zc_hashtable_foreach(a_mdc->tab, a_entry) {
-		a_mdc_kv = a_entry->value;
-		zc_profile(flag, "----mdc_kv[%p][%s]-[%s]----",
-				a_mdc_kv,
-				a_mdc_kv->key, a_mdc_kv->value);
-	}
-	return;
-}
-/*******************************************************************************/
-void zlog_mdc_del(zlog_mdc_t * a_mdc)
-{
-	zc_assert(a_mdc,);
-	if (a_mdc->tab) zc_hashtable_del(a_mdc->tab);
-	zc_debug("zlog_mdc_del[%p]", a_mdc);
-    free(a_mdc);
-	return;
-}
-
-static void zlog_mdc_kv_del(zlog_mdc_kv_t * a_mdc_kv)
-{
-	zc_debug("zlog_mdc_kv_del[%p]", a_mdc_kv);
-    free(a_mdc_kv);
-}
-
-static zlog_mdc_kv_t *zlog_mdc_kv_new(const char *key, const char *value)
-{
-	zlog_mdc_kv_t *a_mdc_kv;
-
-	a_mdc_kv = calloc(1, sizeof(zlog_mdc_kv_t));
-	if (!a_mdc_kv) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	snprintf(a_mdc_kv->key, sizeof(a_mdc_kv->key), "%s", key);
-	a_mdc_kv->value_len = snprintf(a_mdc_kv->value, sizeof(a_mdc_kv->value), "%s", value);
-	return a_mdc_kv;
-}
-
-zlog_mdc_t *zlog_mdc_new(void)
-{
-	zlog_mdc_t *a_mdc;
-
-	a_mdc = calloc(1, sizeof(zlog_mdc_t));
-	if (!a_mdc) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	a_mdc->tab = zc_hashtable_new(20,
-			      zc_hashtable_str_hash,
-			      zc_hashtable_str_equal, NULL,
-			      (zc_hashtable_del_fn) zlog_mdc_kv_del);
-	if (!a_mdc->tab) {
-		zc_error("zc_hashtable_new fail");
-		goto err;
-	}
-
-	//zlog_mdc_profile(a_mdc, ZC_DEBUG);
-	return a_mdc;
-err:
-	zlog_mdc_del(a_mdc);
-	return NULL;
-}
-
-/*******************************************************************************/
-int zlog_mdc_put(zlog_mdc_t * a_mdc, const char *key, const char *value)
-{
-	zlog_mdc_kv_t *a_mdc_kv;
-
-	a_mdc_kv = zlog_mdc_kv_new(key, value);
-	if (!a_mdc_kv) {
-		zc_error("zlog_mdc_kv_new failed");
-		return -1;
-	}
-
-	if (zc_hashtable_put(a_mdc->tab, a_mdc_kv->key, a_mdc_kv)) {
-		zc_error("zc_hashtable_put fail");
-		zlog_mdc_kv_del(a_mdc_kv);
-		return -1;
-	}
-
-	return 0;
-}
-
-void zlog_mdc_clean(zlog_mdc_t * a_mdc)
-{
-	zc_hashtable_clean(a_mdc->tab);
-	return;
-}
-
-char *zlog_mdc_get(zlog_mdc_t * a_mdc, const char *key)
-{
-	zlog_mdc_kv_t *a_mdc_kv;
-
-	a_mdc_kv = zc_hashtable_get(a_mdc->tab, key);
-	if (!a_mdc_kv) {
-		zc_error("zc_hashtable_get fail");
-		return NULL;
-	} else {
-		return a_mdc_kv->value;
-	}
-}
-
-zlog_mdc_kv_t *zlog_mdc_get_kv(zlog_mdc_t * a_mdc, const char *key)
-{
-	zlog_mdc_kv_t *a_mdc_kv;
-
-	a_mdc_kv = zc_hashtable_get(a_mdc->tab, key);
-	if (!a_mdc_kv) {
-		zc_error("zc_hashtable_get fail");
-		return NULL;
-	} else {
-		return a_mdc_kv;
-	}
-}
-
-void zlog_mdc_remove(zlog_mdc_t * a_mdc, const char *key)
-{
-	zc_hashtable_remove(a_mdc->tab, key);
-	return;
-}

zlog/mdc.h

@@ -1,36 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_mdc_h
-#define __zlog_mdc_h
-
-#include "zc_defs.h"
-
-typedef struct zlog_mdc_s zlog_mdc_t;
-struct zlog_mdc_s {
-	zc_hashtable_t *tab;
-};
-
-zlog_mdc_t *zlog_mdc_new(void);
-void zlog_mdc_del(zlog_mdc_t * a_mdc);
-void zlog_mdc_profile(zlog_mdc_t *a_mdc, int flag);
-
-void zlog_mdc_clean(zlog_mdc_t * a_mdc);
-int zlog_mdc_put(zlog_mdc_t * a_mdc, const char *key, const char *value);
-char *zlog_mdc_get(zlog_mdc_t * a_mdc, const char *key);
-void zlog_mdc_remove(zlog_mdc_t * a_mdc, const char *key);
-
-typedef struct zlog_mdc_kv_s {
-	char key[MAXLEN_PATH + 1];
-	char value[MAXLEN_PATH + 1];
-	size_t value_len;
-} zlog_mdc_kv_t;
-
-zlog_mdc_kv_t *zlog_mdc_get_kv(zlog_mdc_t * a_mdc, const char *key);
-
-#endif

zlog/record.c

@@ -1,53 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-#include "errno.h"
-#include "zc_defs.h"
-#include "record.h"
-
-void zlog_record_profile(zlog_record_t *a_record, int flag)
-{
-	zc_assert(a_record,);
-	zc_profile(flag, "--record:[%p][%s:%p]--", a_record, a_record->name,  a_record->output);
-	return;
-}
-
-void zlog_record_del(zlog_record_t *a_record)
-{
-	zc_assert(a_record,);
-	zc_debug("zlog_record_del[%p]", a_record);
-    free(a_record);
-	return;
-}
-
-zlog_record_t *zlog_record_new(const char *name, zlog_record_fn output)
-{
-	zlog_record_t *a_record;
-
-	zc_assert(name, NULL);
-	zc_assert(output, NULL);
-
-	a_record = calloc(1, sizeof(zlog_record_t));
-	if (!a_record) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	if (strlen(name) > sizeof(a_record->name) - 1) {
-		zc_error("name[%s] is too long", name);
-		goto err;
-	}
-
-	strcpy(a_record->name, name);
-	a_record->output = output;
-
-	zlog_record_profile(a_record, ZC_DEBUG);
-	return a_record;
-err:
-	zlog_record_del(a_record);
-	return NULL;
-}

zlog/record.h

@@ -1,32 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_record_h
-#define __zlog_record_h
-
-#include "zc_defs.h"
-
-/* record is user-defined output function and it's name from configure file */
-typedef struct zlog_msg_s {
-	char *buf;
-	size_t len;
-	char *path;
-} zlog_msg_t; /* 3 of this first, see need thread or not later */
-
-typedef int (*zlog_record_fn)(zlog_msg_t * msg);
-
-typedef struct zlog_record_s {
-	char name[MAXLEN_PATH + 1];
-	zlog_record_fn output;
-} zlog_record_t;
-
-zlog_record_t *zlog_record_new(const char *name, zlog_record_fn output);
-void zlog_record_del(zlog_record_t *a_record);
-void zlog_record_profile(zlog_record_t *a_record, int flag);
-
-#endif

zlog/record_table.c

@@ -1,56 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-
-#include "zc_defs.h"
-#include "record_table.h"
-
-void zlog_record_table_profile(zc_hashtable_t * records, int flag)
-{
-	zc_hashtable_entry_t *a_entry;
-	zlog_record_t *a_record;
-
-	zc_assert(records,);
-	zc_profile(flag, "-record_table[%p]-", records);
-	zc_hashtable_foreach(records, a_entry) {
-		a_record = (zlog_record_t *) a_entry->value;
-		zlog_record_profile(a_record, flag);
-	}
-	return;
-}
-
-/*******************************************************************************/
-
-void zlog_record_table_del(zc_hashtable_t * records)
-{
-	zc_assert(records,);
-	zc_hashtable_del(records);
-	zc_debug("zlog_record_table_del[%p]", records);
-	return;
-}
-
-zc_hashtable_t *zlog_record_table_new(void)
-{
-	zc_hashtable_t *records;
-
-	records = zc_hashtable_new(20,
-			 (zc_hashtable_hash_fn) zc_hashtable_str_hash,
-			 (zc_hashtable_equal_fn) zc_hashtable_str_equal,
-			 NULL, (zc_hashtable_del_fn) zlog_record_del);
-	if (!records) {
-		zc_error("zc_hashtable_new fail");
-		return NULL;
-	} else {
-		zlog_record_table_profile(records, ZC_DEBUG);
-		return records;
-	}
-}
-/*******************************************************************************/

zlog/record_table.h

@@ -1,19 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_record_table_h
-#define __zlog_record_table_h
-
-#include "zc_defs.h"
-#include "record.h"
-
-zc_hashtable_t *zlog_record_table_new(void);
-void zlog_record_table_del(zc_hashtable_t * records);
-void zlog_record_table_profile(zc_hashtable_t * records, int flag);
-
-#endif

zlog/rotater.c

@@ -1,575 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <string.h>
-#include <glob.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <pthread.h>
-
-#include "zc_defs.h"
-#include "rotater.h"
-
-#define ROLLING  1     /* aa.02->aa.03, aa.01->aa.02, aa->aa.01 */
-#define SEQUENCE 2     /* aa->aa.03 */
-
-typedef struct {
-	int index;
-	char path[MAXLEN_PATH + 1];
-} zlog_file_t;
-
-void zlog_rotater_profile(zlog_rotater_t * a_rotater, int flag)
-{
-	zc_assert(a_rotater,);
-	zc_profile(flag, "--rotater[%p][%p,%s,%d][%s,%s,%s,%ld,%ld,%d,%d,%d]--",
-		a_rotater,
-
-		&(a_rotater->lock_mutex),
-		a_rotater->lock_file,
-		a_rotater->lock_fd,
-
-		a_rotater->base_path,
-		a_rotater->archive_path,
-		a_rotater->glob_path,
-		(long)a_rotater->num_start_len,
-		(long)a_rotater->num_end_len,
-		a_rotater->num_width,
-		a_rotater->mv_type,
-		a_rotater->max_count
-		);
-	if (a_rotater->files) {
-		int i;
-		zlog_file_t *a_file;
-		zc_arraylist_foreach(a_rotater->files, i, a_file) {
-			zc_profile(flag, "[%s,%d]->", a_file->path, a_file->index);
-		}
-	}
-	return;
-}
-
-/*******************************************************************************/
-void zlog_rotater_del(zlog_rotater_t *a_rotater)
-{
-	zc_assert(a_rotater,);
-
-	if (a_rotater->lock_fd) {
-		if (close(a_rotater->lock_fd)) {
-			zc_error("close fail, errno[%d]", errno);
-		}
-	}
-
-	if (pthread_mutex_destroy(&(a_rotater->lock_mutex))) {
-		zc_error("pthread_mutex_destroy fail, errno[%d]", errno);
-	}
-
-	zc_debug("zlog_rotater_del[%p]", a_rotater);
-    free(a_rotater);
-	return;
-}
-
-zlog_rotater_t *zlog_rotater_new(char *lock_file)
-{
-	int fd = 0;
-	zlog_rotater_t *a_rotater;
-
-	zc_assert(lock_file, NULL);
-
-	a_rotater = calloc(1, sizeof(zlog_rotater_t));
-	if (!a_rotater) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	if (pthread_mutex_init(&(a_rotater->lock_mutex), NULL)) {
-		zc_error("pthread_mutex_init fail, errno[%d]", errno);
-		free(a_rotater);
-		return NULL;
-	}
-
-	/* depends on umask of the user here
-	 * if user A create /tmp/zlog.lock 0600
-	 * user B is unable to read /tmp/zlog.lock
-	 * B has to choose another lock file except /tmp/zlog.lock
-	 */
-	fd = open(lock_file, O_RDWR | O_CREAT,
-		  S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-	if (fd < 0) {
-		zc_error("open file[%s] fail, errno[%d]", lock_file, errno);
-		goto err;
-	}
-
-	a_rotater->lock_fd = fd;
-	a_rotater->lock_file = lock_file;
-
-	//zlog_rotater_profile(a_rotater, ZC_DEBUG);
-	return a_rotater;
-err:
-	zlog_rotater_del(a_rotater);
-	return NULL;
-}
-
-/*******************************************************************************/
-
-static void zlog_file_del(zlog_file_t * a_file)
-{
-	zc_debug("del onefile[%p]", a_file);
-	zc_debug("a_file->path[%s]", a_file->path);
-	free(a_file);
-}
-
-static zlog_file_t *zlog_file_check_new(zlog_rotater_t * a_rotater, const char *path)
-{
-	int nwrite;
-	int nread;
-	zlog_file_t *a_file;
-
-	/* base_path will not be in list */
-	if (STRCMP(a_rotater->base_path, ==, path)) {
-		return NULL;
-	}
-
-	/* omit dirs */
-	if ((path)[strlen(path) - 1] == '/') {
-		return NULL;
-	}
-
-	a_file = calloc(1, sizeof(zlog_file_t));
-	if (!a_file) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	nwrite = snprintf(a_file->path, sizeof(a_file->path), "%s", path);
-	if (nwrite < 0 || nwrite >= sizeof(a_file->path)) {
-		zc_error("snprintf fail or overflow, nwrite=[%d], errno[%d]", nwrite, errno);
-		goto err;
-	}
-
-	nread = 0;
-	sscanf(a_file->path + a_rotater->num_start_len, "%d%n", &(a_file->index), &(nread));
-
-	if (a_rotater->num_width != 0) {
-		if (nread < a_rotater->num_width) {
-			zc_warn("aa.1.log is not expect, need aa.01.log");
-			goto err;
-		}
-	} /* else all file is ok */
-
-	return a_file;
-err:
-	free(a_file);
-	return NULL;
-}
-
-
-static int zlog_file_cmp(zlog_file_t * a_file_1, zlog_file_t * a_file_2)
-{
-	return (a_file_1->index > a_file_2->index);
-}
-
-static int zlog_rotater_add_archive_files(zlog_rotater_t * a_rotater)
-{
-	int rc = 0;
-	glob_t glob_buf;
-	size_t pathc;
-	char **pathv;
-	zlog_file_t *a_file;
-
-	a_rotater->files = zc_arraylist_new((zc_arraylist_del_fn)zlog_file_del);
-	if (!a_rotater->files) {
-		zc_error("zc_arraylist_new fail");
-		return -1;
-	}
-
-	/* scan file which is aa.*.log and aa */
-	rc = glob(a_rotater->glob_path, GLOB_ERR | GLOB_MARK | GLOB_NOSORT, NULL, &glob_buf);
-	if (rc == GLOB_NOMATCH) {
-		goto exit;
-	} else if (rc) {
-		zc_error("glob err, rc=[%d], errno[%d]", rc, errno);
-		return -1;
-	}
-
-	pathv = glob_buf.gl_pathv;
-	pathc = glob_buf.gl_pathc;
-
-	/* check and find match aa.[0-9]*.log, depend on num_width */
-	for (; pathc-- > 0; pathv++) {
-		a_file = zlog_file_check_new(a_rotater, *pathv);
-		if (!a_file) {
-			zc_warn("not the expect pattern file");
-			continue;
-		}
-
-		/* file in list aa.00, aa.01, aa.02... */
-		rc = zc_arraylist_sortadd(a_rotater->files,
-					(zc_arraylist_cmp_fn)zlog_file_cmp, a_file);
-		if (rc) {
-			zc_error("zc_arraylist_sortadd fail");
-			goto err;
-		}
-	}
-
-exit:
-	globfree(&glob_buf);
-	return 0;
-err:
-	globfree(&glob_buf);
-	return -1;
-}
-
-static int zlog_rotater_seq_files(zlog_rotater_t * a_rotater)
-{
-	int rc = 0;
-	int nwrite = 0;
-	int i, j;
-	zlog_file_t *a_file;
-	char new_path[MAXLEN_PATH + 1];
-
-	zc_arraylist_foreach(a_rotater->files, i, a_file) {
-		if (a_rotater->max_count > 0 
-			&& i < zc_arraylist_len(a_rotater->files) - a_rotater->max_count) {
-			/* unlink aa.0 aa.1 .. aa.(n-c) */
-			rc = unlink(a_file->path);
-			if (rc) {
-				zc_error("unlink[%s] fail, errno[%d]",a_file->path , errno);
-				return -1;
-			}
-			continue;
-		}
-	}
-
-	if (zc_arraylist_len(a_rotater->files) > 0) { /* list is not empty */
-		a_file = zc_arraylist_get(a_rotater->files, zc_arraylist_len(a_rotater->files)-1);
-		if (!a_file) {
-			zc_error("zc_arraylist_get fail");
-			return -1;
-		}
-
-		j = zc_max(zc_arraylist_len(a_rotater->files)-1, a_file->index) + 1;
-	} else {
-		j = 0;
-	}
-
-	/* do the base_path mv  */
-	memset(new_path, 0x00, sizeof(new_path));
-	nwrite = snprintf(new_path, sizeof(new_path), "%.*s%0*d%s",
-		(int) a_rotater->num_start_len, a_rotater->glob_path, 
-		a_rotater->num_width, j,
-		a_rotater->glob_path + a_rotater->num_end_len);
-	if (nwrite < 0 || nwrite >= sizeof(new_path)) {
-		zc_error("nwirte[%d], overflow or errno[%d]", nwrite, errno);
-		return -1;
-	}
-
-	if (rename(a_rotater->base_path, new_path)) {
-		zc_error("rename[%s]->[%s] fail, errno[%d]", a_rotater->base_path, new_path, errno);
-		return -1;
-	}
-
-	return 0;
-}
-
-
-static int zlog_rotater_roll_files(zlog_rotater_t * a_rotater)
-{
-	int i;
-	int rc = 0;
-	int nwrite;
-	char new_path[MAXLEN_PATH + 1];
-	zlog_file_t *a_file;
-
-	/* now in the list, aa.0 aa.1 aa.2 aa.02... */
-	for (i = zc_arraylist_len(a_rotater->files) - 1; i > -1; i--) {
-		a_file = zc_arraylist_get(a_rotater->files, i);
-		if (!a_file) {
-			zc_error("zc_arraylist_get fail");
-			return -1;
-		}
-
-		if (a_rotater->max_count > 0 && i >= a_rotater->max_count - 1) {
-			/* remove file.3 >= 3*/
-			rc = unlink(a_file->path);
-			if (rc) {
-				zc_error("unlink[%s] fail, errno[%d]",a_file->path , errno);
-				return -1;
-			}
-			continue;
-		}
-
-		/* begin rename aa.01.log -> aa.02.log , using i, as index in list maybe repeat */
-		memset(new_path, 0x00, sizeof(new_path));
-		nwrite = snprintf(new_path, sizeof(new_path), "%.*s%0*d%s",
-			(int) a_rotater->num_start_len, a_rotater->glob_path, 
-			a_rotater->num_width, i + 1,
-			a_rotater->glob_path + a_rotater->num_end_len);
-		if (nwrite < 0 || nwrite >= sizeof(new_path)) {
-			zc_error("nwirte[%d], overflow or errno[%d]", nwrite, errno);
-			return -1;
-		}
-
-		if (rename(a_file->path, new_path)) {
-			zc_error("rename[%s]->[%s] fail, errno[%d]", a_file->path, new_path, errno);
-			return -1;
-		}
-	}
-
-	/* do the base_path mv  */
-	memset(new_path, 0x00, sizeof(new_path));
-	nwrite = snprintf(new_path, sizeof(new_path), "%.*s%0*d%s",
-		(int) a_rotater->num_start_len, a_rotater->glob_path, 
-		a_rotater->num_width, 0,
-		a_rotater->glob_path + a_rotater->num_end_len);
-	if (nwrite < 0 || nwrite >= sizeof(new_path)) {
-		zc_error("nwirte[%d], overflow or errno[%d]", nwrite, errno);
-		return -1;
-	}
-
-	if (rename(a_rotater->base_path, new_path)) {
-		zc_error("rename[%s]->[%s] fail, errno[%d]", a_rotater->base_path, new_path, errno);
-		return -1;
-	}
-
-	return 0;
-}
-
-
-static int zlog_rotater_parse_archive_path(zlog_rotater_t * a_rotater)
-{
-	int nwrite;
-	int nread;
-	char *p;
-	size_t len;
-
-	/* no archive path is set */
-	if (a_rotater->archive_path[0] == '\0') {
-		nwrite = snprintf(a_rotater->glob_path, sizeof(a_rotater->glob_path),
-					"%s.*", a_rotater->base_path);
-		if (nwrite < 0 || nwrite > sizeof(a_rotater->glob_path)) {
-			zc_error("nwirte[%d], overflow or errno[%d]", nwrite, errno);
-			return -1;
-		}
-
-		a_rotater->mv_type = ROLLING;
-		a_rotater->num_width = 0;
-		a_rotater->num_start_len = strlen(a_rotater->base_path) + 1;
-		a_rotater->num_end_len = strlen(a_rotater->base_path) + 2;
-		return 0;
-	} else {
-
-		/* find the 1st # */
-		p = strchr(a_rotater->archive_path, '#');
-		if (!p) {
-			zc_error("no # in archive_path[%s]", a_rotater->archive_path);
-			return -1;
-		}
-
-		nread = 0;
-		sscanf(p, "#%d%n", &(a_rotater->num_width), &nread);
-		if (nread == 0) nread = 1;
-		if (*(p+nread) == 'r') {
-			a_rotater->mv_type = ROLLING;
-		} else if (*(p+nread) == 's') {
-			a_rotater->mv_type = SEQUENCE;
-		} else {
-			zc_error("#r or #s not found");
-			return -1;
-		}
-
-		/* copy and substitue #i to * in glob_path*/
-		len = p - a_rotater->archive_path;
-		if (len > sizeof(a_rotater->glob_path) - 1) {
-			zc_error("sizeof glob_path not enough,len[%ld]", (long) len);
-			return -1;
-		}
-		memcpy(a_rotater->glob_path, a_rotater->archive_path, len);
-
-		nwrite = snprintf(a_rotater->glob_path + len, sizeof(a_rotater->glob_path) - len,
-				"*%s", p + nread + 1);
-		if (nwrite < 0 || nwrite > sizeof(a_rotater->glob_path) - len) {
-			zc_error("nwirte[%d], overflow or errno[%d]", nwrite, errno);
-			return -1;
-		}
-
-		a_rotater->num_start_len = len;
-		a_rotater->num_end_len = len + 1;
-	}
-	
-	return 0;
-}
-
-static void zlog_rotater_clean(zlog_rotater_t *a_rotater)
-{
-	a_rotater->base_path = NULL;
-	a_rotater->archive_path = NULL;
-	a_rotater->max_count = 0;
-	a_rotater->mv_type = 0;
-	a_rotater->num_width = 0;
-	a_rotater->num_start_len = 0;
-	a_rotater->num_end_len = 0;
-	memset(a_rotater->glob_path, 0x00, sizeof(a_rotater->glob_path));
-
-	if (a_rotater->files) zc_arraylist_del(a_rotater->files);
-	a_rotater->files = NULL;
-}
-
-static int zlog_rotater_lsmv(zlog_rotater_t *a_rotater, 
-		char *base_path, char *archive_path, int archive_max_count)
-{
-	int rc = 0;
-
-	a_rotater->base_path = base_path;
-	a_rotater->archive_path = archive_path;
-	a_rotater->max_count = archive_max_count;
-	rc = zlog_rotater_parse_archive_path(a_rotater);
-	if (rc) {
-		zc_error("zlog_rotater_parse_archive_path fail");
-		goto err;
-	}
-
-	rc = zlog_rotater_add_archive_files(a_rotater);
-	if (rc) {
-		zc_error("zlog_rotater_add_archive_files fail");
-		goto err;
-	}
-
-	if (a_rotater->mv_type == ROLLING) {
-		rc = zlog_rotater_roll_files(a_rotater);
-		if (rc) {
-			zc_error("zlog_rotater_roll_files fail");
-			goto err;
-		}
-	} else if (a_rotater->mv_type == SEQUENCE) {
-		rc = zlog_rotater_seq_files(a_rotater);
-		if (rc) {
-			zc_error("zlog_rotater_seq_files fail");
-			goto err;
-		}
-	}
-
-	zlog_rotater_clean(a_rotater);
-	return 0;
-err:
-	zlog_rotater_clean(a_rotater);
-	return -1;
-}
-/*******************************************************************************/
-
-static int zlog_rotater_trylock(zlog_rotater_t *a_rotater)
-{
-	int rc;
-	struct flock fl;
-
-	fl.l_type = F_WRLCK;
-	fl.l_start = 0;
-	fl.l_whence = SEEK_SET;
-	fl.l_len = 0;
-
-	rc = pthread_mutex_trylock(&(a_rotater->lock_mutex));
-	if (rc == EBUSY) {
-		zc_warn("pthread_mutex_trylock fail, as lock_mutex is locked by other threads");
-		return -1;
-	} else if (rc != 0) {
-		zc_error("pthread_mutex_trylock fail, rc[%d]", rc);
-		return -1;
-	}
-
-	if (fcntl(a_rotater->lock_fd, F_SETLK, &fl)) {
-		if (errno == EAGAIN || errno == EACCES) {
-			/* lock by other process, that's right, go on */
-			/* EAGAIN on linux */
-			/* EACCES on AIX */
-			zc_warn("fcntl lock fail, as file is lock by other process");
-		} else {
-			zc_error("lock fd[%d] fail, errno[%d]", a_rotater->lock_fd, errno);
-		}
-		if (pthread_mutex_unlock(&(a_rotater->lock_mutex))) {
-			zc_error("pthread_mutex_unlock fail, errno[%d]", errno);
-		}
-		return -1;
-	}
-
-	return 0;
-}
-
-static int zlog_rotater_unlock(zlog_rotater_t *a_rotater)
-{
-	int rc = 0;
-	struct flock fl;
-
-	fl.l_type = F_UNLCK;
-	fl.l_start = 0;
-	fl.l_whence = SEEK_SET;
-	fl.l_len = 0;
-
-	if (fcntl(a_rotater->lock_fd, F_SETLK, &fl)) {
-		rc = -1;
-		zc_error("unlock fd[%s] fail, errno[%d]", a_rotater->lock_fd, errno);
-	}
-
-	if (pthread_mutex_unlock(&(a_rotater->lock_mutex))) {
-		rc = -1;
-		zc_error("pthread_mutext_unlock fail, errno[%d]", errno);
-	}
-
-	return rc;
-}
-
-int zlog_rotater_rotate(zlog_rotater_t *a_rotater,
-		char *base_path, size_t msg_len,
-		char *archive_path, long archive_max_size, int archive_max_count)
-{
-	int rc = 0;
-	struct zlog_stat info;
-
-	zc_assert(base_path, -1);
-
-	if (zlog_rotater_trylock(a_rotater)) {
-		zc_warn("zlog_rotater_trylock fail, maybe lock by other process or threads");
-		return 0;
-	}
-
-	if (stat(base_path, &info)) {
-		rc = -1;
-		zc_error("stat [%s] fail, errno[%d]", base_path, errno);
-		goto exit;
-	}
-
-	if (info.st_size + msg_len <= archive_max_size) {
-		/* file not so big,
-		 * may alread rotate by oth process or thread,
-		 * return */
-		rc = 0;
-		goto exit;
-	}
-
-	/* begin list and move files */
-	rc = zlog_rotater_lsmv(a_rotater, base_path, archive_path, archive_max_count);
-	if (rc) {
-		zc_error("zlog_rotater_lsmv [%s] fail, return", base_path);
-		rc = -1;
-	} /* else if (rc == 0) */
-
-	//zc_debug("zlog_rotater_file_ls_mv success");
-
-exit:
-	/* unlock file */
-	if (zlog_rotater_unlock(a_rotater)) {
-		zc_error("zlog_rotater_unlock fail");
-	}
-
-	return rc;
-}
-
-/*******************************************************************************/

zlog/rotater.h

@@ -1,45 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_rotater_h
-#define __zlog_rotater_h
-
-#include "zc_defs.h"
-
-typedef struct zlog_rotater_s {
-	pthread_mutex_t lock_mutex;
-	char *lock_file;
-	int lock_fd;
-
-	/* single-use members */
-	char *base_path;			/* aa.log */
-	char *archive_path;			/* aa.#5i.log */
-	char glob_path[MAXLEN_PATH + 1];	/* aa.*.log */
-	size_t num_start_len;			/* 3, offset to glob_path */
-	size_t num_end_len;			/* 6, offset to glob_path */
-	int num_width;				/* 5 */
-	int mv_type;				/* ROLLING or SEQUENCE */
-	int max_count;
-	zc_arraylist_t *files;
-} zlog_rotater_t;
-
-zlog_rotater_t *zlog_rotater_new(char *lock_file);
-void zlog_rotater_del(zlog_rotater_t *a_rotater);
-
-/*
- * return
- * -1	fail
- * 0	no rotate, or rotate and success
- */
-int zlog_rotater_rotate(zlog_rotater_t *a_rotater,
-		char *base_path, size_t msg_len,
-		char *archive_path, long archive_max_size, int archive_max_count);
-
-void zlog_rotater_profile(zlog_rotater_t *a_rotater, int flag);
-
-#endif

zlog/rule.h

@@ -1,88 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-/**
- * @file rule.h
- * @brief rule decide to output in format by category & level
- */
-
-#ifndef __zlog_rule_h
-#define __zlog_rule_h
-
-#include <stdio.h>
-#include <pthread.h>
-
-#include "zc_defs.h"
-#include "format.h"
-#include "thread.h"
-#include "rotater.h"
-#include "record.h"
-
-typedef struct zlog_rule_s zlog_rule_t;
-
-typedef int (*zlog_rule_output_fn) (zlog_rule_t * a_rule, zlog_thread_t * a_thread);
-
-struct zlog_rule_s {
-	char category[MAXLEN_CFG_LINE + 1];
-	char compare_char;
-	/* 
-	 * [*] log all level
-	 * [.] log level >= rule level, default
-	 * [=] log level == rule level 
-	 * [!] log level != rule level
-	 */
-	int level;
-	unsigned char level_bitmap[32]; /* for category determine whether ouput or not */
-
-	unsigned int file_perms;
-	int file_open_flags;
-
-	char file_path[MAXLEN_PATH + 1];
-	zc_arraylist_t *dynamic_specs;
-	int static_fd;
-	dev_t static_dev;
-	ino_t static_ino;
-
-	long archive_max_size;
-	int archive_max_count;
-	char archive_path[MAXLEN_PATH + 1];
-	zc_arraylist_t *archive_specs;
-
-	FILE *pipe_fp;
-	int pipe_fd;
-
-	size_t fsync_period;
-	size_t fsync_count;
-
-	zc_arraylist_t *levels;
-	int syslog_facility;
-
-	zlog_format_t *format;
-	zlog_rule_output_fn output;
-
-	char record_name[MAXLEN_PATH + 1];
-	char record_path[MAXLEN_PATH + 1];
-	zlog_record_fn record_func;
-};
-
-zlog_rule_t *zlog_rule_new(char * line,
-		zc_arraylist_t * levels,
-		zlog_format_t * default_format,
-		zc_arraylist_t * formats,
-		unsigned int file_perms,
-		size_t fsync_period,
-		int * time_cache_count);
-
-void zlog_rule_del(zlog_rule_t * a_rule);
-void zlog_rule_profile(zlog_rule_t * a_rule, int flag);
-int zlog_rule_match_category(zlog_rule_t * a_rule, char *category);
-int zlog_rule_is_wastebin(zlog_rule_t * a_rule);
-int zlog_rule_set_record(zlog_rule_t * a_rule, zc_hashtable_t *records);
-int zlog_rule_output(zlog_rule_t * a_rule, zlog_thread_t * a_thread);
-
-#endif

zlog/spec.c

@@ -1,659 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include "fmacros.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <sys/time.h>
-#include <time.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "conf.h"
-#include "spec.h"
-#include "level_list.h"
-#include "zc_defs.h"
-
-
-#define ZLOG_DEFAULT_TIME_FMT "%F %T"
-#define	ZLOG_HEX_HEAD  \
-	"\n             0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F    0123456789ABCDEF"
-
-/*******************************************************************************/
-void zlog_spec_profile(zlog_spec_t * a_spec, int flag)
-{
-	zc_assert(a_spec,);
-	zc_profile(flag, "----spec[%p][%.*s][%s|%d][%s,%ld,%ld,%s][%s]----",
-		a_spec,
-		a_spec->len, a_spec->str,
-		a_spec->time_fmt,
-		a_spec->time_cache_index,
-		a_spec->print_fmt, (long)a_spec->max_width, (long)a_spec->min_width, a_spec->left_fill_zeros ? "true" : "false",
-		a_spec->mdc_key);
-	return;
-}
-
-/*******************************************************************************/
-/* implementation of write function */
-
-static int zlog_spec_write_time(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	zlog_time_cache_t * a_cache = a_thread->event->time_caches + a_spec->time_cache_index;
-	time_t now_sec = a_thread->event->time_stamp.tv_sec;
-	struct tm *time_local = &(a_thread->event->time_local);
-
-	/* the event meet the 1st time_spec in his life cycle */
-	if (!now_sec) {
-		gettimeofday(&(a_thread->event->time_stamp), NULL);
-		now_sec = a_thread->event->time_stamp.tv_sec;
-	}
-
-	/* When this event's last cached time_local is not now */
-	if (a_thread->event->time_local_sec != now_sec) {
-		localtime_r(&(now_sec), time_local);
-		a_thread->event->time_local_sec = now_sec;
-	}
-
-	/* When this spec's last cache time string is not now */
-	if (a_cache->sec != now_sec) {
-		a_cache->len = strftime(a_cache->str, sizeof(a_cache->str), a_spec->time_fmt, time_local);
-		a_cache->sec = now_sec;
-	}
-
-	return zlog_buf_append(a_buf, a_cache->str, a_cache->len);
-}
-
-#if 0
-static int zlog_spec_write_time_D(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	if (!a_thread->event->time_stamp.tv_sec) {
-		gettimeofday(&(a_thread->event->time_stamp), NULL);
-	}
-
-	/*
-	 * It is modified when time slips one second.
-	 * So it is a strong cache, as Default time format is always %F %T.
-	 * That's why I said %D is faster than %d()
-	 */
-	if (a_thread->event->time_stamp.tv_sec != a_thread->event->time_last_D) {
-
-		a_thread->event->time_last_D = a_thread->event->time_stamp.tv_sec;
-		localtime_r(&(a_thread->event->time_stamp.tv_sec),
-			    &(a_thread->event->time_local));
-
-		strftime(a_thread->event->time_cache_D,
-			sizeof(a_thread->event->time_cache_D),
-			ZLOG_DEFAULT_TIME_FMT, &(a_thread->event->time_local) );
-	}
-	return zlog_buf_append(a_buf, a_thread->event->time_cache_D, sizeof(a_thread->event->time_cache_D) - 1);
-}
-#endif
-
-static int zlog_spec_write_ms(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	if (!a_thread->event->time_stamp.tv_sec) {
-		gettimeofday(&(a_thread->event->time_stamp), NULL);
-	}
-	return zlog_buf_printf_dec32(a_buf, (a_thread->event->time_stamp.tv_usec / 1000), 3);
-}
-
-static int zlog_spec_write_us(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	if (!a_thread->event->time_stamp.tv_sec) {
-		gettimeofday(&(a_thread->event->time_stamp), NULL);
-	}
-	return zlog_buf_printf_dec32(a_buf, a_thread->event->time_stamp.tv_usec, 6);
-}
-
-static int zlog_spec_write_mdc(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	zlog_mdc_kv_t *a_mdc_kv;
-
-	a_mdc_kv = zlog_mdc_get_kv(a_thread->mdc, a_spec->mdc_key);
-	if (!a_mdc_kv) {
-		zc_error("zlog_mdc_get_kv key[%s] fail", a_spec->mdc_key);
-		return 0;
-	}
-
-	return zlog_buf_append(a_buf, a_mdc_kv->value, a_mdc_kv->value_len);
-}
-
-static int zlog_spec_write_str(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	return zlog_buf_append(a_buf, a_spec->str, a_spec->len);
-}
-
-static int zlog_spec_write_category(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	return zlog_buf_append(a_buf, a_thread->event->category_name, a_thread->event->category_name_len);
-}
-
-static int zlog_spec_write_srcfile(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	if (!a_thread->event->file) {
-		return zlog_buf_append(a_buf, "(file=null)", sizeof("(file=null)") - 1);
-	} else {
-		return zlog_buf_append(a_buf, a_thread->event->file, a_thread->event->file_len);
-	}
-}
-
-static int zlog_spec_write_srcfile_neat(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	char *p;
-
-	if ((p = strrchr(a_thread->event->file, '/')) != NULL) {
-		return zlog_buf_append(a_buf, p + 1,
-			(char*)a_thread->event->file + a_thread->event->file_len - p - 1);
-	} else {
-		if (!a_thread->event->file) {
-			return zlog_buf_append(a_buf, "(file=null)", sizeof("(file=null)") - 1);
-		} else {
-			return zlog_buf_append(a_buf, a_thread->event->file, a_thread->event->file_len);
-		}
-	}
-}
-
-static int zlog_spec_write_srcline(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-
-	return zlog_buf_printf_dec64(a_buf, a_thread->event->line, 0);
-}
-
-static int zlog_spec_write_srcfunc(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	if (!a_thread->event->file) {
-		return zlog_buf_append(a_buf, "(func=null)", sizeof("(func=null)") - 1);
-	} else {
-		return zlog_buf_append(a_buf, a_thread->event->func, a_thread->event->func_len);
-	}
-}
-
-
-static int zlog_spec_write_hostname(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	return zlog_buf_append(a_buf, a_thread->event->host_name, a_thread->event->host_name_len);
-}
-
-static int zlog_spec_write_newline(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	return zlog_buf_append(a_buf, FILE_NEWLINE, FILE_NEWLINE_LEN);
-}
-
-static int zlog_spec_write_percent(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	return zlog_buf_append(a_buf, "%", 1);
-}
-
-static int zlog_spec_write_pid(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	/* 1st in event lifecycle */
-	if (!a_thread->event->pid) {
-		a_thread->event->pid = getpid();
-
-		/* compare with previous event */
-		if (a_thread->event->pid != a_thread->event->last_pid) {
-			a_thread->event->last_pid = a_thread->event->pid;
-			a_thread->event->pid_str_len
-				= sprintf(a_thread->event->pid_str, "%u", a_thread->event->pid);
-		}
-	}
-
-	return zlog_buf_append(a_buf, a_thread->event->pid_str, a_thread->event->pid_str_len);
-}
-
-static int zlog_spec_write_tid_hex(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-
-	/* don't need to get tid again, as tmap_new_thread fetched it already */
-	/* and fork not change tid */
-	return zlog_buf_append(a_buf, a_thread->event->tid_hex_str, a_thread->event->tid_hex_str_len);
-}
-
-static int zlog_spec_write_tid_long(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-
-	/* don't need to get tid again, as tmap_new_thread fetched it already */
-	/* and fork not change tid */
-	return zlog_buf_append(a_buf, a_thread->event->tid_str, a_thread->event->tid_str_len);
-}
-
-static int zlog_spec_write_ktid(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-
-	/* don't need to get ktid again, as tmap_new_thread fetched it already */
-	/* and fork not change tid */
-	return zlog_buf_append(a_buf, a_thread->event->ktid_str, a_thread->event->ktid_str_len);
-}
-
-static int zlog_spec_write_level_lowercase(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	zlog_level_t *a_level;
-
-	a_level = zlog_level_list_get(zlog_env_conf->levels, a_thread->event->level);
-	return zlog_buf_append(a_buf, a_level->str_lowercase, a_level->str_len);
-}
-
-static int zlog_spec_write_level_uppercase(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	zlog_level_t *a_level;
-
-	a_level = zlog_level_list_get(zlog_env_conf->levels, a_thread->event->level);
-	return zlog_buf_append(a_buf, a_level->str_uppercase, a_level->str_len);
-}
-
-static int zlog_spec_write_usrmsg(zlog_spec_t * a_spec, zlog_thread_t * a_thread, zlog_buf_t * a_buf)
-{
-	if (a_thread->event->generate_cmd == ZLOG_FMT) {
-		if (a_thread->event->str_format) {
-			return zlog_buf_vprintf(a_buf,
-				      a_thread->event->str_format,
-				      a_thread->event->str_args);
-		} else {
-			return zlog_buf_append(a_buf, "format=(null)", sizeof("format=(null)")-1);
-		}
-	} else if (a_thread->event->generate_cmd == ZLOG_HEX) {
-		int rc;
-		long line_offset;
-		long byte_offset;
-
-		/* thread buf start == null or len <= 0 */
-		if (a_thread->event->hex_buf == NULL) {
-			rc = zlog_buf_append(a_buf, "buf=(null)", sizeof("buf=(null)")-1);
-			goto zlog_hex_exit;
-		}
-
-		rc = zlog_buf_append(a_buf, ZLOG_HEX_HEAD, sizeof(ZLOG_HEX_HEAD)-1);
-		if (rc) {
-			goto zlog_hex_exit;
-		}
-
-		line_offset = 0;
-		//byte_offset = 0;
-
-		while (1) {
-			unsigned char c;
-
-			rc = zlog_buf_append(a_buf, "\n", 1);
-			if (rc)  goto zlog_hex_exit;
-
-			rc = zlog_buf_printf_dec64(a_buf, line_offset + 1, 10);
-			if (rc)  goto zlog_hex_exit;
-			rc = zlog_buf_append(a_buf, "   ", 3);
-			if (rc)  goto zlog_hex_exit;
-
-			for (byte_offset = 0; byte_offset < 16; byte_offset++) {
-				if (line_offset * 16 + byte_offset < a_thread->event->hex_buf_len) {
-					c = *((unsigned char *)a_thread->event->hex_buf
-						+ line_offset * 16 + byte_offset);
-					rc = zlog_buf_printf_hex(a_buf, c, 2);
-					if (rc) goto zlog_hex_exit;
-					rc = zlog_buf_append(a_buf, " ", 1);
-					if (rc) goto zlog_hex_exit;
-				} else {
-					rc = zlog_buf_append(a_buf, "   ", 3);
-					if (rc)  goto zlog_hex_exit;
-				}
-			}
-
-			rc = zlog_buf_append(a_buf, "  ", 2);
-			if (rc) goto zlog_hex_exit;
-
-			for (byte_offset = 0; byte_offset < 16; byte_offset++) {
-				if (line_offset * 16 + byte_offset < a_thread->event->hex_buf_len) {
-					c = *((unsigned char *)a_thread->event->hex_buf
-						+ line_offset * 16 + byte_offset);
-					if (c >= 32 && c <= 126) {
-						rc = zlog_buf_append(a_buf,(char*)&c, 1);
-						if (rc)  goto zlog_hex_exit;
-					} else {
-						rc = zlog_buf_append(a_buf, ".", 1);
-						if (rc)  goto zlog_hex_exit;
-					}
-				} else {
-					rc = zlog_buf_append(a_buf, " ", 1);
-					if (rc)  goto zlog_hex_exit;
-				}
-			}
-
-			if (line_offset * 16 + byte_offset >= a_thread->event->hex_buf_len) {
-				break;
-			}
-
-			line_offset++;
-		}
-
-	      zlog_hex_exit:
-		if (rc < 0) {
-			zc_error("write hex msg fail");
-			return -1;
-		} else if (rc > 0) {
-			zc_error("write hex msg, buf is full");
-			return 1;
-		}
-
-		return 0;
-	}
-
-	return 0;
-}
-
-/*******************************************************************************/
-/* implementation of gen function */
-
-static int zlog_spec_gen_msg_direct(zlog_spec_t * a_spec, zlog_thread_t * a_thread)
-{
-	/* no need to reprint %1.2d here */
-	return a_spec->write_buf(a_spec, a_thread, a_thread->msg_buf);
-}
-
-static int zlog_spec_gen_msg_reformat(zlog_spec_t * a_spec, zlog_thread_t * a_thread)
-{
-	int rc;
-
-	zlog_buf_restart(a_thread->pre_msg_buf);
-
-	rc = a_spec->write_buf(a_spec, a_thread, a_thread->pre_msg_buf);
-	if (rc < 0) {
-		zc_error("a_spec->gen_buf fail");
-		return -1;
-	} else if (rc > 0) {
-		/* buf is full, try printf */
-	}
-
-	return zlog_buf_adjust_append(a_thread->msg_buf,
-		zlog_buf_str(a_thread->pre_msg_buf), zlog_buf_len(a_thread->pre_msg_buf),
-		a_spec->left_adjust, a_spec->left_fill_zeros, a_spec->min_width, a_spec->max_width);
-}
-
-/*******************************************************************************/
-static int zlog_spec_gen_path_direct(zlog_spec_t * a_spec, zlog_thread_t * a_thread)
-{
-	/* no need to reprint %1.2d here */
-	return a_spec->write_buf(a_spec, a_thread, a_thread->path_buf);
-}
-
-static int zlog_spec_gen_path_reformat(zlog_spec_t * a_spec, zlog_thread_t * a_thread)
-{
-	int rc;
-
-	zlog_buf_restart(a_thread->pre_path_buf);
-
-	rc = a_spec->write_buf(a_spec, a_thread, a_thread->pre_path_buf);
-	if (rc < 0) {
-		zc_error("a_spec->gen_buf fail");
-		return -1;
-	} else if (rc > 0) {
-		/* buf is full, try printf */
-	}
-
-	return zlog_buf_adjust_append(a_thread->path_buf,
-		zlog_buf_str(a_thread->pre_path_buf), zlog_buf_len(a_thread->pre_path_buf),
-		a_spec->left_adjust, a_spec->left_fill_zeros, a_spec->min_width, a_spec->max_width);
-}
-
-/*******************************************************************************/
-static int zlog_spec_gen_archive_path_direct(zlog_spec_t * a_spec, zlog_thread_t * a_thread)
-{
-	/* no need to reprint %1.2d here */
-	return a_spec->write_buf(a_spec, a_thread, a_thread->archive_path_buf);
-}
-
-static int zlog_spec_gen_archive_path_reformat(zlog_spec_t * a_spec, zlog_thread_t * a_thread)
-{
-	int rc;
-
-	zlog_buf_restart(a_thread->pre_path_buf);
-
-	rc = a_spec->write_buf(a_spec, a_thread, a_thread->pre_path_buf);
-	if (rc < 0) {
-		zc_error("a_spec->gen_buf fail");
-		return -1;
-	} else if (rc > 0) {
-		/* buf is full, try printf */
-	}
-
-	return zlog_buf_adjust_append(a_thread->archive_path_buf,
-		zlog_buf_str(a_thread->pre_path_buf), zlog_buf_len(a_thread->pre_path_buf),
-		a_spec->left_adjust, a_spec->left_fill_zeros, a_spec->min_width, a_spec->max_width);
-}
-
-/*******************************************************************************/
-static int zlog_spec_parse_print_fmt(zlog_spec_t * a_spec)
-{
-	/* -12.35 12 .35 */
-	char *p, *q;
-	long i, j;
-
-	p = a_spec->print_fmt;
-	if (*p == '-') {
-		a_spec->left_adjust = 1;
-		p++;
-	} else {
-		if (*p == '0') {
-			a_spec->left_fill_zeros = 1;
-		}
-		a_spec->left_adjust = 0;
-	}
-
-	i = j = 0;
-	sscanf(p, "%ld.", &i);
-	q = strchr(p, '.');
-	if (q) sscanf(q, ".%ld", &j);
-
-	a_spec->min_width = (size_t) i;
-	a_spec->max_width = (size_t) j;
-	return 0;
-}
-
-/*******************************************************************************/
-void zlog_spec_del(zlog_spec_t * a_spec)
-{
-	zc_assert(a_spec,);
-	zc_debug("zlog_spec_del[%p]", a_spec);
-    free(a_spec);
-}
-
-/* a spec may consist of
- * a const string: /home/bb
- * a string begin with %: %12.35d(%F %X,%l)
- */
-zlog_spec_t *zlog_spec_new(char *pattern_start, char **pattern_next, int *time_cache_count)
-{
-	char *p;
-	int nscan = 0;
-	int nread = 0;
-	zlog_spec_t *a_spec;
-
-	zc_assert(pattern_start, NULL);
-	zc_assert(pattern_next, NULL);
-
-	a_spec = calloc(1, sizeof(zlog_spec_t));
-	if (!a_spec) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	a_spec->str = p = pattern_start;
-
-	switch (*p) {
-	case '%':
-		/* a string begin with %: %12.35d(%F %X) */
-
-		/* process width and precision char in %-12.35P */
-		nread = 0;
-		nscan = sscanf(p, "%%%[.0-9-]%n", a_spec->print_fmt, &nread);
-		if (nscan == 1) {
-			a_spec->gen_msg = zlog_spec_gen_msg_reformat;
-			a_spec->gen_path = zlog_spec_gen_path_reformat;
-			a_spec->gen_archive_path = zlog_spec_gen_archive_path_reformat;
-			if (zlog_spec_parse_print_fmt(a_spec)) {
-				zc_error("zlog_spec_parse_print_fmt fail");
-				goto err;
-			}
-		} else {
-			nread = 1; /* skip the % char */
-			a_spec->gen_msg = zlog_spec_gen_msg_direct;
-			a_spec->gen_path = zlog_spec_gen_path_direct;
-			a_spec->gen_archive_path = zlog_spec_gen_archive_path_direct;
-		}
-
-		p += nread;
-
-		if (*p == 'd') {
-			if (*(p+1) != '(') {
-				/* without '(' , use default */
-				strcpy(a_spec->time_fmt, ZLOG_DEFAULT_TIME_FMT);
-				p++;
-			} else if (STRNCMP(p, ==, "d()", 3)) {
-				/* with () but without detail time format,
-				 * keep a_spec->time_fmt=="" */
-				strcpy(a_spec->time_fmt, ZLOG_DEFAULT_TIME_FMT);
-				p += 3;
-			} else {
-				nread = 0;
-				nscan = sscanf(p, "d(%[^)])%n", a_spec->time_fmt, &nread);
-				if (nscan != 1) {
-					nread = 0;
-				}
-				p += nread;
-				if (*(p - 1) != ')') {
-					zc_error("in string[%s] can't find match \')\'", a_spec->str);
-					goto err;
-				}
-			}
-
-			a_spec->time_cache_index = *time_cache_count;
-			(*time_cache_count)++;
-			a_spec->write_buf = zlog_spec_write_time;
-
-			*pattern_next = p;
-			a_spec->len = p - a_spec->str;
-			break;
-		}
-
-		if (*p == 'M') {
-			nread = 0;
-			nscan = sscanf(p, "M(%[^)])%n", a_spec->mdc_key, &nread);
-			if (nscan != 1) {
-				nread = 0;
-				if (STRNCMP(p, ==, "M()", 3)) {
-					nread = 3;
-				}
-			}
-			p += nread;
-			if (*(p - 1) != ')') {
-				zc_error("in string[%s] can't find match \')\'", a_spec->str);
-				goto err;
-			}
-
-			*pattern_next = p;
-			a_spec->len = p - a_spec->str;
-			a_spec->write_buf = zlog_spec_write_mdc;
-			break;
-		}
-
-		if (STRNCMP(p, ==, "ms", 2)) {
-			p += 2;
-			*pattern_next = p;
-			a_spec->len = p - a_spec->str;
-			a_spec->write_buf = zlog_spec_write_ms;
-			break;
-		} else if (STRNCMP(p, ==, "us", 2)) {
-			p += 2;
-			*pattern_next = p;
-			a_spec->len = p - a_spec->str;
-			a_spec->write_buf = zlog_spec_write_us;
-			break;
-		}
-
-		*pattern_next = p + 1;
-		a_spec->len = p - a_spec->str + 1;
-
-		switch (*p) {
-		case 'c':
-			a_spec->write_buf = zlog_spec_write_category;
-			break;
-		case 'D':
-			strcpy(a_spec->time_fmt, ZLOG_DEFAULT_TIME_FMT);
-			a_spec->time_cache_index = *time_cache_count;
-			(*time_cache_count)++;
-			a_spec->write_buf = zlog_spec_write_time;
-			break;
-		case 'F':
-			a_spec->write_buf = zlog_spec_write_srcfile;
-			break;
-		case 'f':
-			a_spec->write_buf = zlog_spec_write_srcfile_neat;
-			break;
-		case 'H':
-			a_spec->write_buf = zlog_spec_write_hostname;
-			break;
-		case 'k':
-			a_spec->write_buf = zlog_spec_write_ktid;
-			break;
-		case 'L':
-			a_spec->write_buf = zlog_spec_write_srcline;
-			break;
-		case 'm':
-			a_spec->write_buf = zlog_spec_write_usrmsg;
-			break;
-		case 'n':
-			a_spec->write_buf = zlog_spec_write_newline;
-			break;
-		case 'p':
-			a_spec->write_buf = zlog_spec_write_pid;
-			break;
-		case 'U':
-			a_spec->write_buf = zlog_spec_write_srcfunc;
-			break;
-		case 'v':
-			a_spec->write_buf = zlog_spec_write_level_lowercase;
-			break;
-		case 'V':
-			a_spec->write_buf = zlog_spec_write_level_uppercase;
-			break;
-		case 't':
-			a_spec->write_buf = zlog_spec_write_tid_hex;
-			break;
-		case 'T':
-			a_spec->write_buf = zlog_spec_write_tid_long;
-			break;
-		case '%':
-			a_spec->write_buf = zlog_spec_write_percent;
-			break;
-		default:
-			zc_error("str[%s] in wrong format, p[%c]", a_spec->str, *p);
-			goto err;
-		}
-		break;
-	default:
-		/* a const string: /home/bb */
-		*pattern_next = strchr(p, '%');
-		if (*pattern_next) {
-			a_spec->len = *pattern_next - p;
-		} else {
-			a_spec->len = strlen(p);
-			*pattern_next = p + a_spec->len;
-		}
-		a_spec->write_buf = zlog_spec_write_str;
-		a_spec->gen_msg = zlog_spec_gen_msg_direct;
-		a_spec->gen_path = zlog_spec_gen_path_direct;
-		a_spec->gen_archive_path = zlog_spec_gen_archive_path_direct;
-	}
-
-	zlog_spec_profile(a_spec, ZC_DEBUG);
-	return a_spec;
-err:
-	zlog_spec_del(a_spec);
-	return NULL;
-}
-

zlog/spec.h

@@ -1,60 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_spec_h
-#define __zlog_spec_h
-
-#include "event.h"
-#include "buf.h"
-#include "thread.h"
-
-typedef struct zlog_spec_s zlog_spec_t;
-
-/* write buf, according to each spec's Conversion Characters */
-typedef int (*zlog_spec_write_fn) (zlog_spec_t * a_spec,
-			 	zlog_thread_t * a_thread,
-			 	zlog_buf_t * a_buf);
-
-/* gen a_thread->msg or gen a_thread->path by using write_fn */
-typedef int (*zlog_spec_gen_fn) (zlog_spec_t * a_spec,
-				zlog_thread_t * a_thread);
-
-struct zlog_spec_s {
-	char *str;
-	int len;
-
-	char time_fmt[MAXLEN_CFG_LINE + 1];
-	int time_cache_index;
-	char mdc_key[MAXLEN_PATH + 1];
-
-	char print_fmt[MAXLEN_CFG_LINE + 1];
-	int left_adjust;
-	int left_fill_zeros;
-	size_t max_width;
-	size_t min_width;
-
-	zlog_spec_write_fn write_buf;
-	zlog_spec_gen_fn gen_msg;
-	zlog_spec_gen_fn gen_path;
-	zlog_spec_gen_fn gen_archive_path;
-};
-
-zlog_spec_t *zlog_spec_new(char *pattern_start, char **pattern_end, int * time_cache_count);
-void zlog_spec_del(zlog_spec_t * a_spec);
-void zlog_spec_profile(zlog_spec_t * a_spec, int flag);
-
-#define zlog_spec_gen_msg(a_spec, a_thread) \
-	a_spec->gen_msg(a_spec, a_thread)
-
-#define zlog_spec_gen_path(a_spec, a_thread) \
-	a_spec->gen_path(a_spec, a_thread)
-
-#define zlog_spec_gen_archive_path(a_spec, a_thread) \
-	a_spec->gen_archive_path(a_spec, a_thread)
-
-#endif

zlog/thread.c

@@ -1,184 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <pthread.h>
-#include <errno.h>
-
-#include "zc_defs.h"
-#include "event.h"
-#include "buf.h"
-#include "thread.h"
-#include "mdc.h"
-
-void zlog_thread_profile(zlog_thread_t * a_thread, int flag)
-{
-	zc_assert(a_thread,);
-	zc_profile(flag, "--thread[%p][%p][%p][%p,%p,%p,%p,%p]--",
-			a_thread,
-			a_thread->mdc,
-			a_thread->event,
-			a_thread->pre_path_buf,
-			a_thread->path_buf,
-			a_thread->archive_path_buf,
-			a_thread->pre_msg_buf,
-			a_thread->msg_buf);
-
-	zlog_mdc_profile(a_thread->mdc, flag);
-	zlog_event_profile(a_thread->event, flag);
-	zlog_buf_profile(a_thread->pre_path_buf, flag);
-	zlog_buf_profile(a_thread->path_buf, flag);
-	zlog_buf_profile(a_thread->archive_path_buf, flag);
-	zlog_buf_profile(a_thread->pre_msg_buf, flag);
-	zlog_buf_profile(a_thread->msg_buf, flag);
-	return;
-}
-/*******************************************************************************/
-void zlog_thread_del(zlog_thread_t * a_thread)
-{
-	zc_assert(a_thread,);
-	if (a_thread->mdc)
-		zlog_mdc_del(a_thread->mdc);
-	if (a_thread->event)
-		zlog_event_del(a_thread->event);
-	if (a_thread->pre_path_buf)
-		zlog_buf_del(a_thread->pre_path_buf);
-	if (a_thread->path_buf)
-		zlog_buf_del(a_thread->path_buf);
-	if (a_thread->archive_path_buf)
-		zlog_buf_del(a_thread->archive_path_buf);
-	if (a_thread->pre_msg_buf)
-		zlog_buf_del(a_thread->pre_msg_buf);
-	if (a_thread->msg_buf)
-		zlog_buf_del(a_thread->msg_buf);
-
-	zc_debug("zlog_thread_del[%p]", a_thread);
-    free(a_thread);
-	return;
-}
-
-zlog_thread_t *zlog_thread_new(int init_version, size_t buf_size_min, size_t buf_size_max, int time_cache_count)
-{
-	zlog_thread_t *a_thread;
-
-	a_thread = calloc(1, sizeof(zlog_thread_t));
-	if (!a_thread) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	a_thread->init_version = init_version;
-
-	a_thread->mdc = zlog_mdc_new();
-	if (!a_thread->mdc) {
-		zc_error("zlog_mdc_new fail");
-		goto err;
-	}
-
-	a_thread->event = zlog_event_new(time_cache_count);
-	if (!a_thread->event) {
-		zc_error("zlog_event_new fail");
-		goto err;
-	}
-
-	a_thread->pre_path_buf = zlog_buf_new(MAXLEN_PATH + 1, MAXLEN_PATH + 1, NULL);
-	if (!a_thread->pre_path_buf) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-	a_thread->path_buf = zlog_buf_new(MAXLEN_PATH + 1, MAXLEN_PATH + 1, NULL);
-	if (!a_thread->path_buf) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-	a_thread->archive_path_buf = zlog_buf_new(MAXLEN_PATH + 1, MAXLEN_PATH + 1, NULL);
-	if (!a_thread->archive_path_buf) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-	a_thread->pre_msg_buf = zlog_buf_new(buf_size_min, buf_size_max, "..." FILE_NEWLINE);
-	if (!a_thread->pre_msg_buf) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-	a_thread->msg_buf = zlog_buf_new(buf_size_min, buf_size_max, "..." FILE_NEWLINE);
-	if (!a_thread->msg_buf) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-
-	//zlog_thread_profile(a_thread, ZC_DEBUG);
-	return a_thread;
-err:
-	zlog_thread_del(a_thread);
-	return NULL;
-}
-
-/*******************************************************************************/
-int zlog_thread_rebuild_msg_buf(zlog_thread_t * a_thread, size_t buf_size_min, size_t buf_size_max)
-{
-	zlog_buf_t *pre_msg_buf_new = NULL;
-	zlog_buf_t *msg_buf_new = NULL;
-	zc_assert(a_thread, -1);
-
-	if ( (a_thread->msg_buf->size_min == buf_size_min)
-		&& (a_thread->msg_buf->size_max == buf_size_max)) {
-		zc_debug("buf size not changed, no need rebuild");
-		return 0;
-	}
-
-	pre_msg_buf_new = zlog_buf_new(buf_size_min, buf_size_max, "..." FILE_NEWLINE);
-	if (!pre_msg_buf_new) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-	msg_buf_new = zlog_buf_new(buf_size_min, buf_size_max, "..." FILE_NEWLINE);
-	if (!msg_buf_new) {
-		zc_error("zlog_buf_new fail");
-		goto err;
-	}
-
-	zlog_buf_del(a_thread->pre_msg_buf);
-	a_thread->pre_msg_buf = pre_msg_buf_new;
-
-	zlog_buf_del(a_thread->msg_buf);
-	a_thread->msg_buf = msg_buf_new;
-
-	return 0;
-err:
-	if (pre_msg_buf_new) zlog_buf_del(pre_msg_buf_new);
-	if (msg_buf_new) zlog_buf_del(msg_buf_new);
-	return -1;
-}
-
-int zlog_thread_rebuild_event(zlog_thread_t * a_thread, int time_cache_count)
-{
-	zlog_event_t *event_new = NULL;
-	zc_assert(a_thread, -1);
-
-	event_new = zlog_event_new(time_cache_count);
-	if (!event_new) {
-		zc_error("zlog_event_new fail");
-		goto err;
-	}
-
-	zlog_event_del(a_thread->event);
-	a_thread->event = event_new;
-	return 0;
-err:
-	if (event_new) zlog_event_del(event_new);
-	return -1;
-}
-
-
-/*******************************************************************************/

zlog/thread.h

@@ -1,38 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_thread_h
-#define  __zlog_thread_h
-
-#include "zc_defs.h"
-#include "event.h"
-#include "buf.h"
-#include "mdc.h"
-
-typedef struct {
-	int init_version;
-	zlog_mdc_t *mdc;
-	zlog_event_t *event;
-
-	zlog_buf_t *pre_path_buf;
-	zlog_buf_t *path_buf;
-	zlog_buf_t *archive_path_buf;
-	zlog_buf_t *pre_msg_buf;
-	zlog_buf_t *msg_buf;
-} zlog_thread_t;
-
-
-void zlog_thread_del(zlog_thread_t * a_thread);
-void zlog_thread_profile(zlog_thread_t * a_thread, int flag);
-zlog_thread_t *zlog_thread_new(int init_version,
-			size_t buf_size_min, size_t buf_size_max, int time_cache_count);
-
-int zlog_thread_rebuild_msg_buf(zlog_thread_t * a_thread, size_t buf_size_min, size_t buf_size_max);
-int zlog_thread_rebuild_event(zlog_thread_t * a_thread, int time_cache_count);
-
-#endif

zlog/version.h

@@ -1 +0,0 @@
-#define ZLOG_VERSION "1.2.12"

zlog/zc_arraylist.c

@@ -1,132 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <errno.h>
-
-#include "zc_defs.h"
-
-zc_arraylist_t *zc_arraylist_new(zc_arraylist_del_fn del)
-{
-	zc_arraylist_t *a_list;
-
-	a_list = (zc_arraylist_t *) calloc(1, sizeof(zc_arraylist_t));
-	if (!a_list) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-	a_list->size = ARRAY_LIST_DEFAULT_SIZE;
-	a_list->len = 0;
-
-	/* this could be NULL */
-	a_list->del = del;
-	a_list->array = (void **)calloc(a_list->size, sizeof(void *));
-	if (!a_list->array) {
-		zc_error("calloc fail, errno[%d]", errno);
-		free(a_list);
-		return NULL;
-	}
-
-	return a_list;
-}
-
-void zc_arraylist_del(zc_arraylist_t * a_list)
-{
-	int i;
-
-	if (!a_list)
-		return;
-	if (a_list->del) {
-		for (i = 0; i < a_list->len; i++) {
-			if (a_list->array[i])
-				a_list->del(a_list->array[i]);
-		}
-	}
-	if (a_list->array)
-		free(a_list->array);
-	free(a_list);
-	return;
-}
-
-static int zc_arraylist_expand_inner(zc_arraylist_t * a_list, int max)
-{
-	void *tmp;
-	int new_size;
-	int diff_size;
-
-	new_size = zc_max(a_list->size * 2, max);
-	tmp = realloc(a_list->array, new_size * sizeof(void *));
-	if (!tmp) {
-		zc_error("realloc fail, errno[%d]", errno);
-		return -1;
-	}
-	a_list->array = (void **)tmp;
-	diff_size = new_size - a_list->size;
-	if (diff_size) memset(a_list->array + a_list->size, 0x00, diff_size * sizeof(void *));
-	a_list->size = new_size;
-	return 0;
-}
-
-int zc_arraylist_set(zc_arraylist_t * a_list, int idx, void *data)
-{
-	if (idx > a_list->size - 1) {
-		if (zc_arraylist_expand_inner(a_list, idx)) {
-			zc_error("expand_internal fail");
-			return -1;
-		}
-	}
-	if (a_list->array[idx] && a_list->del) a_list->del(a_list->array[idx]);
-	a_list->array[idx] = data;
-	if (a_list->len <= idx)
-		a_list->len = idx + 1;
-	return 0;
-}
-
-int zc_arraylist_add(zc_arraylist_t * a_list, void *data)
-{
-	return zc_arraylist_set(a_list, a_list->len, data);
-}
-
-/* assum idx < len */
-static int zc_arraylist_insert_inner(zc_arraylist_t * a_list, int idx,
-				     void *data)
-{
-	if (a_list->array[idx] == NULL) {
-		a_list->array[idx] = data;
-		return 0;
-	}
-	if (a_list->len > a_list->size - 1) {
-		if (zc_arraylist_expand_inner(a_list, 0)) {
-			zc_error("expand_internal fail");
-			return -1;
-		}
-	}
-	memmove(a_list->array + idx + 1, a_list->array + idx,
-		(a_list->len - idx) * sizeof(void *));
-	a_list->array[idx] = data;
-	a_list->len++;
-	return 0;
-}
-
-int zc_arraylist_sortadd(zc_arraylist_t * a_list, zc_arraylist_cmp_fn cmp,
-			 void *data)
-{
-	int i;
-
-	for (i = 0; i < a_list->len; i++) {
-		if ((*cmp) (a_list->array[i], data) > 0)
-			break;
-	}
-
-	if (i == a_list->len)
-		return zc_arraylist_add(a_list, data);
-	else
-		return zc_arraylist_insert_inner(a_list, i, data);
-}

zlog/zc_arraylist.h

@@ -1,41 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zc_arraylist_h
-#define __zc_arraylist_h
-
-#define ARRAY_LIST_DEFAULT_SIZE 32
-
-typedef void (*zc_arraylist_del_fn) (void *data);
-typedef int (*zc_arraylist_cmp_fn) (void *data1, void *data2);
-
-/* make zc_arraylist_foreach speed up, so keep struct defination here */
-typedef struct {
-	void **array;
-	int len;
-	int size;
-	zc_arraylist_del_fn del;
-} zc_arraylist_t;
-
-zc_arraylist_t *zc_arraylist_new(zc_arraylist_del_fn del);
-void zc_arraylist_del(zc_arraylist_t * a_list);
-
-int zc_arraylist_set(zc_arraylist_t * a_list, int i, void *data);
-int zc_arraylist_add(zc_arraylist_t * a_list, void *data);
-int zc_arraylist_sortadd(zc_arraylist_t * a_list, zc_arraylist_cmp_fn cmp,
-			 void *data);
-
-#define zc_arraylist_len(a_list)  (a_list->len)
-
-#define zc_arraylist_get(a_list, i) \
-	 ((i >= a_list->len) ? NULL : a_list->array[i])
-
-#define zc_arraylist_foreach(a_list, i, a_unit) \
-	for(i = 0, a_unit = a_list->array[0]; (i < a_list->len) && (a_unit = a_list->array[i], 1) ; i++)
-
-#endif

zlog/zc_defs.h

@@ -1,18 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zc_defs_h
-#define __zc_defs_h
-
-#include "zc_profile.h"
-#include "zc_arraylist.h"
-#include "zc_hashtable.h"
-#include "zc_xplatform.h"
-#include "zc_util.h"
-
-#endif

zlog/zc_hashtable.c

@@ -1,330 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <stdlib.h>
-#include <errno.h>
-#include <pthread.h>
-
-#include "zc_defs.h"
-#include "zc_hashtable.h"
-
-struct zc_hashtable_s {
-	size_t nelem;
-
-	zc_hashtable_entry_t **tab;
-	size_t tab_size;
-
-	zc_hashtable_hash_fn hash;
-	zc_hashtable_equal_fn equal;
-	zc_hashtable_del_fn key_del;
-	zc_hashtable_del_fn value_del;
-};
-
-zc_hashtable_t *zc_hashtable_new(size_t a_size,
-				 zc_hashtable_hash_fn hash,
-				 zc_hashtable_equal_fn equal,
-				 zc_hashtable_del_fn key_del,
-				 zc_hashtable_del_fn value_del)
-{
-	zc_hashtable_t *a_table;
-
-	a_table = calloc(1, sizeof(*a_table));
-	if (!a_table) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return NULL;
-	}
-
-	a_table->tab = calloc(a_size, sizeof(*(a_table->tab)));
-	if (!a_table->tab) {
-		zc_error("calloc fail, errno[%d]", errno);
-		free(a_table);
-		return NULL;
-	}
-	a_table->tab_size = a_size;
-
-	a_table->nelem = 0;
-	a_table->hash = hash;
-	a_table->equal = equal;
-
-	/* these two could be NULL */
-	a_table->key_del = key_del;
-	a_table->value_del = value_del;
-
-	return a_table;
-}
-
-void zc_hashtable_del(zc_hashtable_t * a_table)
-{
-	size_t i;
-	zc_hashtable_entry_t *p;
-	zc_hashtable_entry_t *q;
-
-	if (!a_table) {
-		zc_error("a_table[%p] is NULL, just do nothing", a_table);
-		return;
-	}
-
-	for (i = 0; i < a_table->tab_size; i++) {
-		for (p = (a_table->tab)[i]; p; p = q) {
-			q = p->next;
-			if (a_table->key_del) {
-				a_table->key_del(p->key);
-			}
-			if (a_table->value_del) {
-				a_table->value_del(p->value);
-			}
-			free(p);
-		}
-	}
-	if (a_table->tab)
-		free(a_table->tab);
-	free(a_table);
-
-	return;
-}
-
-void zc_hashtable_clean(zc_hashtable_t * a_table)
-{
-	size_t i;
-	zc_hashtable_entry_t *p;
-	zc_hashtable_entry_t *q;
-
-	for (i = 0; i < a_table->tab_size; i++) {
-		for (p = (a_table->tab)[i]; p; p = q) {
-			q = p->next;
-			if (a_table->key_del) {
-				a_table->key_del(p->key);
-			}
-			if (a_table->value_del) {
-				a_table->value_del(p->value);
-			}
-			free(p);
-		}
-		(a_table->tab)[i] = NULL;
-	}
-	a_table->nelem = 0;
-	return;
-}
-
-static int zc_hashtable_rehash(zc_hashtable_t * a_table)
-{
-	size_t i;
-	size_t j;
-	size_t tab_size;
-	zc_hashtable_entry_t **tab;
-	zc_hashtable_entry_t *p;
-	zc_hashtable_entry_t *q;
-
-	tab_size = 2 * a_table->tab_size;
-	tab = calloc(tab_size, sizeof(*tab));
-	if (!tab) {
-		zc_error("calloc fail, errno[%d]", errno);
-		return -1;
-	}
-
-	for (i = 0; i < a_table->tab_size; i++) {
-		for (p = (a_table->tab)[i]; p; p = q) {
-			q = p->next;
-
-			p->next = NULL;
-			p->prev = NULL;
-			j = p->hash_key % tab_size;
-			if (tab[j]) {
-				tab[j]->prev = p;
-				p->next = tab[j];
-			}
-			tab[j] = p;
-		}
-	}
-	free(a_table->tab);
-	a_table->tab = tab;
-	a_table->tab_size = tab_size;
-
-	return 0;
-}
-
-zc_hashtable_entry_t *zc_hashtable_get_entry(zc_hashtable_t * a_table, const void *a_key)
-{
-	unsigned int i;
-	zc_hashtable_entry_t *p;
-
-	i = a_table->hash(a_key) % a_table->tab_size;
-	for (p = (a_table->tab)[i]; p; p = p->next) {
-		if (a_table->equal(a_key, p->key))
-			return p;
-	}
-
-	return NULL;
-}
-
-void *zc_hashtable_get(zc_hashtable_t * a_table, const void *a_key)
-{
-	unsigned int i;
-	zc_hashtable_entry_t *p;
-
-	i = a_table->hash(a_key) % a_table->tab_size;
-	for (p = (a_table->tab)[i]; p; p = p->next) {
-		if (a_table->equal(a_key, p->key))
-			return p->value;
-	}
-
-	return NULL;
-}
-
-int zc_hashtable_put(zc_hashtable_t * a_table, void *a_key, void *a_value)
-{
-	int rc = 0;
-	unsigned int i;
-	zc_hashtable_entry_t *p = NULL;
-
-	i = a_table->hash(a_key) % a_table->tab_size;
-	for (p = (a_table->tab)[i]; p; p = p->next) {
-		if (a_table->equal(a_key, p->key))
-			break;
-	}
-
-	if (p) {
-		if (a_table->key_del) {
-			a_table->key_del(p->key);
-		}
-		if (a_table->value_del) {
-			a_table->value_del(p->value);
-		}
-		p->key = a_key;
-		p->value = a_value;
-		return 0;
-	} else {
-		if (a_table->nelem > a_table->tab_size * 1.3) {
-			rc = zc_hashtable_rehash(a_table);
-			if (rc) {
-				zc_error("rehash fail");
-				return -1;
-			}
-		}
-
-		p = calloc(1, sizeof(*p));
-		if (!p) {
-			zc_error("calloc fail, errno[%d]", errno);
-			return -1;
-		}
-
-		p->hash_key = a_table->hash(a_key);
-		p->key = a_key;
-		p->value = a_value;
-		p->next = NULL;
-		p->prev = NULL;
-
-		i = p->hash_key % a_table->tab_size;
-		if ((a_table->tab)[i]) {
-			(a_table->tab)[i]->prev = p;
-			p->next = (a_table->tab)[i];
-		}
-		(a_table->tab)[i] = p;
-		a_table->nelem++;
-	}
-
-	return 0;
-}
-
-void zc_hashtable_remove(zc_hashtable_t * a_table, const void *a_key)
-{
-	zc_hashtable_entry_t *p;
-	unsigned int i;
-
-        if (!a_table || !a_key) {
-		zc_error("a_table[%p] or a_key[%p] is NULL, just do nothing", a_table, a_key);
-		return;
-        }
-
-	i = a_table->hash(a_key) % a_table->tab_size;
-	for (p = (a_table->tab)[i]; p; p = p->next) {
-		if (a_table->equal(a_key, p->key))
-			break;
-	}
-
-	if (!p) {
-		zc_error("p[%p] not found in hashtable", p);
-		return;
-	}
-
-	if (a_table->key_del) {
-		a_table->key_del(p->key);
-	}
-	if (a_table->value_del) {
-		a_table->value_del(p->value);
-	}
-
-	if (p->next) {
-		p->next->prev = p->prev;
-	}
-	if (p->prev) {
-		p->prev->next = p->next;
-	} else {
-		unsigned int i;
-
-		i = p->hash_key % a_table->tab_size;
-		a_table->tab[i] = p->next;
-	}
-
-	free(p);
-	a_table->nelem--;
-
-	return;
-}
-
-zc_hashtable_entry_t *zc_hashtable_begin(zc_hashtable_t * a_table)
-{
-	size_t i;
-	zc_hashtable_entry_t *p;
-
-	for (i = 0; i < a_table->tab_size; i++) {
-		for (p = (a_table->tab)[i]; p; p = p->next) {
-			if (p)
-				return p;
-		}
-	}
-
-	return NULL;
-}
-
-zc_hashtable_entry_t *zc_hashtable_next(zc_hashtable_t * a_table, zc_hashtable_entry_t * a_entry)
-{
-	size_t i;
-	size_t j;
-
-	if (a_entry->next)
-		return a_entry->next;
-
-	i = a_entry->hash_key % a_table->tab_size;
-
-	for (j = i + 1; j < a_table->tab_size; j++) {
-		if ((a_table->tab)[j]) {
-			return (a_table->tab)[j];
-		}
-	}
-
-	return NULL;
-}
-
-/*******************************************************************************/
-
-unsigned int zc_hashtable_str_hash(const void *str)
-{
-	unsigned int h = 5381;
-	const char *p = (const char *)str;
-
-	while (*p != '\0')
-		h = ((h << 5) + h) + (*p++); /* hash * 33 + c */
-
-	return h;
-}
-
-int zc_hashtable_str_equal(const void *key1, const void *key2)
-{
-	return (STRCMP((const char *)key1, ==, (const char *)key2));
-}

zlog/zc_hashtable.h

@@ -1,49 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zc_hashtalbe_h
-#define __zc_hashtalbe_h
-
-#include <stdlib.h>
-
-typedef struct zc_hashtable_entry_s {
-	unsigned int hash_key;
-	void *key;
-	void *value;
-	struct zc_hashtable_entry_s *prev;
-	struct zc_hashtable_entry_s *next;
-} zc_hashtable_entry_t;
-
-typedef struct zc_hashtable_s zc_hashtable_t;
-
-typedef unsigned int (*zc_hashtable_hash_fn) (const void *key);
-typedef int (*zc_hashtable_equal_fn) (const void *key1, const void *key2);
-typedef void (*zc_hashtable_del_fn) (void *kv);
-
-zc_hashtable_t *zc_hashtable_new(size_t a_size,
-				 zc_hashtable_hash_fn hash_fn,
-				 zc_hashtable_equal_fn equal_fn,
-				 zc_hashtable_del_fn key_del_fn,
-				 zc_hashtable_del_fn value_del_fn);
-
-void zc_hashtable_del(zc_hashtable_t * a_table);
-void zc_hashtable_clean(zc_hashtable_t * a_table);
-int zc_hashtable_put(zc_hashtable_t * a_table, void *a_key, void *a_value);
-zc_hashtable_entry_t *zc_hashtable_get_entry(zc_hashtable_t * a_table, const void *a_key);
-void *zc_hashtable_get(zc_hashtable_t * a_table, const void *a_key);
-void zc_hashtable_remove(zc_hashtable_t * a_table, const void *a_key);
-zc_hashtable_entry_t *zc_hashtable_begin(zc_hashtable_t * a_table);
-zc_hashtable_entry_t *zc_hashtable_next(zc_hashtable_t * a_table, zc_hashtable_entry_t * a_entry);
-
-#define zc_hashtable_foreach(a_table, a_entry) \
-for(a_entry = zc_hashtable_begin(a_table); a_entry; a_entry = zc_hashtable_next(a_table, a_entry))
-
-unsigned int zc_hashtable_str_hash(const void *str);
-int zc_hashtable_str_equal(const void *key1, const void *key2);
-
-#endif

zlog/zc_profile.c

@@ -1,86 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include "fmacros.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <time.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "zc_profile.h"
-#include "zc_xplatform.h"
-
-static void zc_time(char *time_str, size_t time_str_size)
-{
-	time_t tt;
-	struct tm local_time;
-
-	time(&tt);
-	localtime_r(&tt, &local_time);
-	strftime(time_str, time_str_size, "%m-%d %T", &local_time);
-
-	return;
-}
-
-int zc_profile_inner(int flag, const char *file, const long line, const char *fmt, ...)
-{
-	va_list args;
-	char time_str[20 + 1];
-	FILE *fp = NULL;
-
-	static char *debug_log = NULL;
-	static char *error_log = NULL;
-	static size_t init_flag = 0;
-
-	if (!init_flag) {
-		init_flag = 1;
-		debug_log = getenv("ZLOG_PROFILE_DEBUG");
-		error_log = getenv("ZLOG_PROFILE_ERROR");
-	}
-
-	switch (flag) {
-	case ZC_DEBUG:
- 		if (debug_log == NULL) return 0;
-		fp = fopen(debug_log, "a");
-		if (!fp) return -1;
-		zc_time(time_str, sizeof(time_str));
-		fprintf(fp, "%s DEBUG (%d:%s:%ld) ", time_str, getpid(), file, line);
-		break;
-	case ZC_WARN:
- 		if (error_log == NULL) return 0;
-		fp = fopen(error_log, "a");
-		if (!fp) return -1;
-		zc_time(time_str, sizeof(time_str));
-		fprintf(fp, "%s WARN  (%d:%s:%ld) ", time_str, getpid(), file, line);
-		break;
-	case ZC_ERROR:
- 		if (error_log == NULL) return 0;
-		fp = fopen(error_log, "a");
-		if (!fp) return -1;
-		zc_time(time_str, sizeof(time_str));
-		fprintf(fp, "%s ERROR (%d:%s:%ld) ", time_str, getpid(), file, line);
-		break;
-	}
-
-	/* writing file twice(time & msg) is not atomic
-	 * may cause cross
-	 * but avoid log size limit */
-	va_start(args, fmt);
-	vfprintf(fp, fmt, args);
-	va_end(args);
-	fprintf(fp, "\n");
-
-	fclose(fp);
-	return 0;
-}
-

zlog/zc_profile.h

@@ -1,53 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zc_profile_h
-#define __zc_profile_h
-
-#include <stdarg.h>
-
-#define EMPTY()
-#define zc_assert(expr, rv) \
-	if(!(expr)) { \
-		zc_error(#expr" is null or 0"); \
-		return rv; \
-	} 
-
-enum zc_profile_flag {
-	ZC_DEBUG = 0,
-	ZC_WARN = 1,
-	ZC_ERROR = 2
-};
-
-
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
-	#define zc_debug(...) \
-		zc_profile_inner(ZC_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
-	#define zc_warn(...) \
-		zc_profile_inner(ZC_WARN, __FILE__, __LINE__, __VA_ARGS__)
-	#define zc_error(...) \
-		zc_profile_inner(ZC_ERROR, __FILE__, __LINE__, __VA_ARGS__)
-	#define zc_profile(flag, ...) \
-		zc_profile_inner(flag, __FILE__, __LINE__, __VA_ARGS__)
-#elif defined __GNUC__
-	#define zc_debug(fmt, args...) \
-		zc_profile_inner(ZC_DEBUG, __FILE__, __LINE__, fmt, ## args)
-	#define zc_warn(fmt, args...) \
-		zc_profile_inner(ZC_WARN, __FILE__, __LINE__, fmt, ## args)
-	#define zc_error(fmt, args...) \
-		zc_profile_inner(ZC_ERROR, __FILE__, __LINE__, fmt, ## args)
-	#define zc_profile(flag, fmt, args...) \
-		zc_profile_inner(flag, __FILE__, __LINE__, fmt, ## args)
-#endif
-
-
-int zc_profile_inner(int flag, 
-		const char *file, const long line,
-		const char *fmt, ...);
-
-#endif

zlog/zc_util.c

@@ -1,147 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include <string.h>
-#include <syslog.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <errno.h>
-
-#include "zc_defs.h"
-
-size_t zc_parse_byte_size(char *astring)
-{
-	/* Parse size in bytes depending on the suffix.   Valid suffixes are KB, MB and GB */
-	char *p;
-	char *q;
-	size_t sz;
-	long res;
-	int c, m;
-
-	zc_assert(astring, 0);
-
-	/* clear space */
-	for (p = q = astring; *p != '\0'; p++) {
-		if (isspace(*p)) {
-			continue;
-		} else {
-			*q = *p;
-			q++;
-		}
-	}
-	*q = '\0';
-
-	sz = strlen(astring);
-	res = strtol(astring, (char **)NULL, 10);
-
-	if (res <= 0)
-		return 0;
-
-	if (astring[sz - 1] == 'B' || astring[sz - 1] == 'b') {
-		c = astring[sz - 2];
-		m = 1024;
-	} else {
-		c = astring[sz - 1];
-		m = 1000;
-	}
-
-	switch (c) {
-	case 'K':
-	case 'k':
-		res *= m;
-		break;
-	case 'M':
-	case 'm':
-		res *= m * m;
-		break;
-	case 'G':
-	case 'g':
-		res *= m * m * m;
-		break;
-	default:
-		if (!isdigit(c)) {
-			zc_error("Wrong suffix parsing " "size in bytes for string [%s], ignoring suffix",
-				 astring);
-		}
-		break;
-	}
-
-	return (res);
-}
-
-/*******************************************************************************/
-int zc_str_replace_env(char *str, size_t str_size)
-{
-	char *p;
-	char *q;
-	char fmt[MAXLEN_CFG_LINE + 1];
-	char env_key[MAXLEN_CFG_LINE + 1];
-	char env_value[MAXLEN_CFG_LINE + 1];
-	int str_len;
-	int env_value_len;
-	int nscan;
-	int nread;
-
-	str_len = strlen(str);
-	q = str;
-
-	do {
-		p = strchr(q, '%');
-		if (!p) {
-			/* can't find more % */
-			break;
-		}
-
-		memset(fmt, 0x00, sizeof(fmt));
-		memset(env_key, 0x00, sizeof(env_key));
-		memset(env_value, 0x00, sizeof(env_value));
-		nread = 0;
-		nscan = sscanf(p + 1, "%[.0-9-]%n", fmt + 1, &nread);
-		if (nscan == 1) {
-			fmt[0] = '%';
-			fmt[nread + 1] = 's';
-		} else {
-			nread = 0;
-			strcpy(fmt, "%s");
-		}
-
-		q = p + 1 + nread;
-
-		nscan = sscanf(q, "E(%[^)])%n", env_key, &nread);
-		if (nscan == 0) {
-			continue;
-		}
-
-		q += nread;
-
-		if (*(q - 1) != ')') {
-			zc_error("in string[%s] can't find match )", p);
-			return -1;
-		}
-
-		env_value_len = snprintf(env_value, sizeof(env_value), fmt, getenv(env_key));
-		if (env_value_len < 0 || env_value_len >= sizeof(env_value)) {
-			zc_error("snprintf fail, errno[%d], evn_value_len[%d]",
-				 errno, env_value_len);
-			return -1;
-		}
-
-		str_len = str_len - (q - p) + env_value_len;
-		if (str_len > str_size - 1) {
-			zc_error("repalce env_value[%s] cause overlap", env_value);
-			return -1;
-		}
-
-		memmove(p + env_value_len, q, strlen(q) + 1);
-		memcpy(p, env_value, env_value_len);
-
-	} while (1);
-
-	return 0;
-}

zlog/zc_util.h

@@ -1,17 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-#ifndef __zc_util_h
-#define __zc_util_h
-
-size_t zc_parse_byte_size(char *astring);
-int zc_str_replace_env(char *str, size_t str_size);
-
-#define zc_max(a,b) ((a) > (b) ? (a) : (b))
-#define zc_min(a,b) ((a) < (b) ? (a) : (b))
-
-#endif

zlog/zc_xplatform.h

@@ -1,61 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-#ifndef __zc_xplatform_h
-#define __zc_xplatform_h
-
-#include <limits.h>
-
-#define ZLOG_INT32_LEN   sizeof("-2147483648") - 1
-#define ZLOG_INT64_LEN   sizeof("-9223372036854775808") - 1
-
-#if ((__GNU__ == 2) && (__GNUC_MINOR__ < 8))
-#define ZLOG_MAX_UINT32_VALUE  (uint32_t) 0xffffffffLL
-#else
-#define ZLOG_MAX_UINT32_VALUE  (uint32_t) 0xffffffff
-#endif
-
-#define ZLOG_MAX_INT32_VALUE   (uint32_t) 0x7fffffff
-
-#define MAXLEN_PATH 1024
-#define MAXLEN_CFG_LINE (MAXLEN_PATH * 4)
-
-#define FILE_NEWLINE "\n"
-#define FILE_NEWLINE_LEN 1
-
-#include <string.h>
-#include <strings.h>
-
-#define STRCMP(_a_,_C_,_b_) ( strcmp(_a_,_b_) _C_ 0 )
-#define STRNCMP(_a_,_C_,_b_,_n_) ( strncmp(_a_,_b_,_n_) _C_ 0 )
-#define STRICMP(_a_,_C_,_b_) ( strcasecmp(_a_,_b_) _C_ 0 )
-#define STRNICMP(_a_,_C_,_b_,_n_) ( strncasecmp(_a_,_b_,_n_) _C_ 0 )
-
-
-#ifdef __APPLE__
-#include <AvailabilityMacros.h>
-#endif
-
-/* Define zlog_fstat to fstat or fstat64() */
-#if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
-#define zlog_fstat fstat64
-#define zlog_stat stat64
-#else
-#define zlog_fstat fstat
-#define zlog_stat stat
-#endif
-
-/* Define zlog_fsync to fdatasync() in Linux and fsync() for all the rest */
-#ifdef __linux__
-#define zlog_fsync fdatasync
-#else
-#define zlog_fsync fsync
-#endif
-
-
-
-#endif

zlog/zlog-chk-conf.c

@@ -1,70 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#include "fmacros.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-
-#include <unistd.h>
-
-#include "zlog.h"
-#include "version.h"
-
-
-int main(int argc, char *argv[])
-{
-	int rc = 0;
-	int op;
-	int quiet = 0;
-	static const char *help = 
-		"usage: zlog-chk-conf [conf files]...\n"
-		"\t-q,\tsuppress non-error message\n"
-		"\t-h,\tshow help message\n"
-		"zlog version: " ZLOG_VERSION "\n";
-
-	while((op = getopt(argc, argv, "qhv")) > 0) {
-		if (op == 'h') {
-			fputs(help, stdout);
-			return 0;
-		} else if (op == 'q') {
-			quiet = 1;
-		}
-	}
-
-	argc -= optind;
-	argv += optind;
-
-	if (argc == 0) {
-		fputs(help, stdout);
-		return -1;
-	}
-
-	setenv("ZLOG_PROFILE_ERROR", "/dev/stderr", 1);
-	setenv("ZLOG_CHECK_FORMAT_RULE", "1", 1);
-
-	while (argc > 0) {
-		rc = zlog_init(*argv);
-		if (rc) {
-			printf("\n---[%s] syntax error, see error message above\n",
-				*argv);
-			exit(2);
-		} else {
-			zlog_fini();
-			if (!quiet) {
-				printf("--[%s] syntax right\n", *argv);
-			}
-		}
-		argc--;
-		argv++;
-	}
-
-	exit(0);
-}

zlog/zlog.h

@@ -1,279 +0,0 @@
-/*
- * This file is part of the zlog Library.
- *
- * Copyright (C) 2011 by Hardy Simpson <HardySimpson1984@gmail.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING in base directory.
- */
-
-#ifndef __zlog_h
-#define __zlog_h
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h> /* for va_list */
-#include <stdio.h> /* for size_t */
-
-# if defined __GNUC__
-#   define ZLOG_CHECK_PRINTF(m,n) __attribute__((format(printf,m,n)))
-# else 
-#   define ZLOG_CHECK_PRINTF(m,n)
-# endif
-
-typedef struct zlog_category_s zlog_category_t;
-
-int zlog_init(const char *confpath);
-int zlog_reload(const char *confpath);
-void zlog_fini(void);
-
-void zlog_profile(void);
-
-zlog_category_t *zlog_get_category(const char *cname);
-int zlog_level_enabled(zlog_category_t *category, const int level);
-
-int zlog_put_mdc(const char *key, const char *value);
-char *zlog_get_mdc(const char *key);
-void zlog_remove_mdc(const char *key);
-void zlog_clean_mdc(void);
-
-int zlog_level_switch(zlog_category_t * category, int level);
-int zlog_level_enabled(zlog_category_t * category, int level);
-
-void zlog(zlog_category_t * category,
-	const char *file, size_t filelen,
-	const char *func, size_t funclen,
-	long line, int level,
-	const char *format, ...) ZLOG_CHECK_PRINTF(8,9);
-void vzlog(zlog_category_t * category,
-	const char *file, size_t filelen,
-	const char *func, size_t funclen,
-	long line, int level,
-	const char *format, va_list args);
-void hzlog(zlog_category_t * category,
-	const char *file, size_t filelen,
-	const char *func, size_t funclen,
-	long line, int level,
-	const void *buf, size_t buflen);
-
-int dzlog_init(const char *confpath, const char *cname);
-int dzlog_set_category(const char *cname);
-
-void dzlog(const char *file, size_t filelen,
-	const char *func, size_t funclen,
-	long line, int level,
-	const char *format, ...) ZLOG_CHECK_PRINTF(7,8);
-void vdzlog(const char *file, size_t filelen,
-	const char *func, size_t funclen,
-	long line, int level,
-	const char *format, va_list args);
-void hdzlog(const char *file, size_t filelen,
-	const char *func, size_t funclen,
-	long line, int level,
-	const void *buf, size_t buflen);
-
-typedef struct zlog_msg_s {
-	char *buf;
-	size_t len;
-	char *path;
-} zlog_msg_t;
-
-typedef int (*zlog_record_fn)(zlog_msg_t *msg);
-int zlog_set_record(const char *rname, zlog_record_fn record);
-
-const char *zlog_version(void);
-
-/******* useful macros, can be redefined at user's h file **********/
-
-typedef enum {
-	ZLOG_LEVEL_DEBUG = 20,
-	ZLOG_LEVEL_INFO = 40,
-	ZLOG_LEVEL_NOTICE = 60,
-	ZLOG_LEVEL_WARN = 80,
-	ZLOG_LEVEL_ERROR = 100,
-	ZLOG_LEVEL_FATAL = 120
-} zlog_level; 
-
-#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L
-# if defined __GNUC__ && __GNUC__ >= 2
-#  define __func__ __FUNCTION__
-# else
-#  define __func__ "<unknown>"
-# endif
-#endif
-
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
-/* zlog macros */
-#define zlog_fatal(cat, ...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, __VA_ARGS__)
-#define zlog_error(cat, ...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, __VA_ARGS__)
-#define zlog_warn(cat, ...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, __VA_ARGS__)
-#define zlog_notice(cat, ...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, __VA_ARGS__)
-#define zlog_info(cat, ...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, __VA_ARGS__)
-#define zlog_debug(cat, ...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, __VA_ARGS__)
-/* dzlog macros */
-#define dzlog_fatal(...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, __VA_ARGS__)
-#define dzlog_error(...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, __VA_ARGS__)
-#define dzlog_warn(...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, __VA_ARGS__)
-#define dzlog_notice(...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, __VA_ARGS__)
-#define dzlog_info(...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, __VA_ARGS__)
-#define dzlog_debug(...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, __VA_ARGS__)
-#elif defined __GNUC__
-/* zlog macros */
-#define zlog_fatal(cat, format, args...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, format, ##args)
-#define zlog_error(cat, format, args...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, format, ##args)
-#define zlog_warn(cat, format, args...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, format, ##args)
-#define zlog_notice(cat, format, args...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, format, ##args)
-#define zlog_info(cat, format, args...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, format, ##args)
-#define zlog_debug(cat, format, args...) \
-	zlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, format, ##args)
-/* dzlog macros */
-#define dzlog_fatal(format, args...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, format, ##args)
-#define dzlog_error(format, args...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, format, ##args)
-#define dzlog_warn(format, args...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, format, ##args)
-#define dzlog_notice(format, args...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, format, ##args)
-#define dzlog_info(format, args...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, format, ##args)
-#define dzlog_debug(format, args...) \
-	dzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, format, ##args)
-#endif
-
-/* vzlog macros */
-#define vzlog_fatal(cat, format, args) \
-	vzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, format, args)
-#define vzlog_error(cat, format, args) \
-	vzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, format, args)
-#define vzlog_warn(cat, format, args) \
-	vzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, format, args)
-#define vzlog_notice(cat, format, args) \
-	vzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, format, args)
-#define vzlog_info(cat, format, args) \
-	vzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, format, args)
-#define vzlog_debug(cat, format, args) \
-	vzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, format, args)
-
-/* hzlog macros */
-#define hzlog_fatal(cat, buf, buf_len) \
-	hzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, buf, buf_len)
-#define hzlog_error(cat, buf, buf_len) \
-	hzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, buf, buf_len)
-#define hzlog_warn(cat, buf, buf_len) \
-	hzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, buf, buf_len)
-#define hzlog_notice(cat, buf, buf_len) \
-	hzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, buf, buf_len)
-#define hzlog_info(cat, buf, buf_len) \
-	hzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, buf, buf_len)
-#define hzlog_debug(cat, buf, buf_len) \
-	hzlog(cat, __FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, buf, buf_len)
-
-
-/* vdzlog macros */
-#define vdzlog_fatal(format, args) \
-	vdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, format, args)
-#define vdzlog_error(format, args) \
-	vdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, format, args)
-#define vdzlog_warn(format, args) \
-	vdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, format, args)
-#define vdzlog_notice(format, args) \
-	vdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, format, args)
-#define vdzlog_info(format, args) \
-	vdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, format, args)
-#define vdzlog_debug(format, args) \
-	vdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, format, args)
-
-/* hdzlog macros */
-#define hdzlog_fatal(buf, buf_len) \
-	hdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_FATAL, buf, buf_len)
-#define hdzlog_error(buf, buf_len) \
-	hdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_ERROR, buf, buf_len)
-#define hdzlog_warn(buf, buf_len) \
-	hdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_WARN, buf, buf_len)
-#define hdzlog_notice(buf, buf_len) \
-	hdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_NOTICE, buf, buf_len)
-#define hdzlog_info(buf, buf_len) \
-	hdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_INFO, buf, buf_len)
-#define hdzlog_debug(buf, buf_len) \
-	hdzlog(__FILE__, sizeof(__FILE__)-1, __func__, sizeof(__func__)-1, __LINE__, \
-	ZLOG_LEVEL_DEBUG, buf, buf_len)
-
-/* enabled macros */
-#define zlog_fatal_enabled(zc) zlog_level_enabled(zc, ZLOG_LEVEL_FATAL)
-#define zlog_error_enabled(zc) zlog_level_enabled(zc, ZLOG_LEVEL_ERROR)
-#define zlog_warn_enabled(zc) zlog_level_enabled(zc, ZLOG_LEVEL_WARN)
-#define zlog_notice_enabled(zc) zlog_level_enabled(zc, ZLOG_LEVEL_NOTICE)
-#define zlog_info_enabled(zc) zlog_level_enabled(zc, ZLOG_LEVEL_INFO)
-#define zlog_debug_enabled(zc) zlog_level_enabled(zc, ZLOG_LEVEL_DEBUG)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif