No OneTemporary
Actions

Size

64 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/configure.ac b/configure.ac
	index b8742e0..50e1549 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,618 +1,624 @@

	# Process this file with autoconf to produce a configure script.

	AC_PREREQ([2.61])

	AC_INIT([libqb],
	m4_esyscmd([build-aux/git-version-gen .tarball-version]),
	[developers@clusterlabs.org])
	AC_CONFIG_AUX_DIR([build-aux])
	AC_CONFIG_SRCDIR([lib/ringbuffer.c])
	AC_CONFIG_HEADERS([include/config.h include/qb/qbconfig.h])
	AC_USE_SYSTEM_EXTENSIONS

	AM_INIT_AUTOMAKE([-Wno-portability dist-xz])
	dnl automake >= 1.11 offers --enable-silent-rules for suppressing the output from
	dnl normal compilation. When a failure occurs, it will then display the full
	dnl command line
	dnl Wrap in m4_ifdef to avoid breaking on older platforms
	m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
	LT_PREREQ([2.2.6])
	LT_INIT

	AC_CONFIG_MACRO_DIR([m4])

	AC_CANONICAL_HOST
	AC_PROG_LIBTOOL
	AC_LANG([C])

	dnl Fix default variables - "prefix" variable if not specified
	if test "$prefix" = "NONE"; then
	prefix="/usr"
	if test "$localstatedir" = "\${prefix}/var"; then
	localstatedir="/var"
	fi
	if test "$sysconfdir" = "\${prefix}/etc"; then
	sysconfdir="/etc"
	fi
	if test "$libdir" = "\${exec_prefix}/lib"; then
	if test -e /usr/lib64; then
	libdir="/usr/lib64"
	else
	libdir="/usr/lib"
	fi
	fi
	fi

	if test "$srcdir" = "."; then
	AC_MSG_NOTICE([building in place srcdir:$srcdir])
	AC_DEFINE([BUILDING_IN_PLACE], 1, [building in place])
	else
	AC_MSG_NOTICE([building out of tree srcdir:$srcdir])
	fi

	# Checks for programs.

	# check stolen from gnulib/m4/gnu-make.m4
	if ! ${MAKE-make} --version /cannot/make/this >/dev/null 2>&1; then
	AC_MSG_ERROR([you don't seem to have GNU make; it is required])
	fi

	AC_PROG_CXX
	AC_PROG_AWK
	AC_PROG_CC
	AC_PROG_CPP
	AM_PROG_CC_C_O
	AC_PROG_INSTALL
	AC_PROG_LN_S
	AC_PROG_MAKE_SET
	AC_CHECK_PROGS([PKGCONFIG], [pkg-config])
	AC_CHECK_PROGS([DOXYGEN], [doxygen])
	AM_CONDITIONAL(HAVE_DOXYGEN, test -n "${DOXYGEN}")
	AC_CHECK_PROGS([SPLINT], [splint])
	AM_CONDITIONAL(HAVE_SPLINT, test -n "${SPLINT}")

	## local helper functions

	# this function checks if CC support options passed as
	# args. Global CFLAGS are ignored during this test.
	cc_supports_flag() {
	BACKUP="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $@ -Werror"
	AC_MSG_CHECKING([whether $CC supports "$@"])
	AC_PREPROC_IFELSE([AC_LANG_PROGRAM([])],
	[RC=0; AC_MSG_RESULT([yes])],
	[RC=1; AC_MSG_RESULT([no])])
	CPPFLAGS="$BACKUP"
	return $RC
	}

	## cleanup
	AC_MSG_NOTICE(Sanitizing prefix: ${prefix})
	case $prefix in
	NONE) prefix=/usr/local;;
	esac

	AC_MSG_NOTICE(Sanitizing exec_prefix: ${exec_prefix})
	case $exec_prefix in
	NONE) exec_prefix=$prefix;;
	prefix) exec_prefix=$prefix;;
	esac

	# Checks for libraries.
	dnl librt from glibc NEEDs libpthread
	dnl so. if test for libpthread after librt
	dnl it will always be "none needed", but it is not true
	dnl when linking libraries. Looks like a bug.
	AC_SEARCH_LIBS([pthread_create], [pthread])
	AC_SEARCH_LIBS([mq_open], [rt])
	AC_SEARCH_LIBS([dlopen], [dl])
	AC_SEARCH_LIBS([socket], [socket])
	AC_SEARCH_LIBS([gethostbyname], [nsl])

	# look for testing harness "check"
	PKG_CHECK_MODULES([CHECK], [check >= 0.9.4],[with_check=yes],[with_check=no])
	AM_CONDITIONAL(HAVE_CHECK, test "${with_check}" = "yes")

	# look for GLIB (used for testing integration)
	PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.0, have_glib=yes, have_glib=no)
	AM_CONDITIONAL(HAVE_GLIB, test x$have_glib = xyes)
	AC_SUBST(GLIB_CFLAGS)
	AC_SUBST(GLIB_LIBS)
	if test x"$have_glib" = xyes; then
	AC_DEFINE_UNQUOTED([HAVE_GLIB], [1], [We have glib])
	fi

	# Checks for header files.
	AC_HEADER_STDC
	AC_HEADER_SYS_WAIT

	AC_CHECK_HEADERS([arpa/inet.h link.h fcntl.h inttypes.h limits.h netinet/in.h \
	stdint.h stddef.h stdlib.h string.h strings.h \
	dlfcn.h time.h sys/time.h sys/types.h sys/stat.h \
	sys/param.h sys/socket.h sys/time.h sys/poll.h sys/epoll.h \
	sys/uio.h sys/event.h sys/sockio.h sys/un.h sys/resource.h \
	syslog.h errno.h unistd.h sys/mman.h \
	sys/sem.h sys/ipc.h sys/msg.h netdb.h])

	# Checks for typedefs, structures, and compiler characteristics.
	AC_TYPE_UID_T
	AC_C_INLINE
	AC_TYPE_INT32_T
	AC_TYPE_INT64_T
	AC_TYPE_INT8_T
	AC_TYPE_MODE_T
	AC_TYPE_PID_T
	AC_TYPE_SIZE_T
	AC_TYPE_SSIZE_T
	AC_TYPE_UINT64_T
	AC_TYPE_UINT32_T
	AC_TYPE_UINT16_T
	AC_TYPE_UINT8_T

	AC_CHECK_MEMBER([struct sockaddr_un.sun_len],
	[AC_DEFINE([HAVE_STRUCT_SOCKADDR_UN_SUN_LEN],
	1,
	[Define to 1 if struct sockaddr_un has a member sun_len])],
	[],
	[#include <sys/un.h>])

	AC_MSG_CHECKING(looking for union semun in sys/sem.h)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
	[[#include <sys/types.h>
	#include <sys/ipc.h>
	#include <sys/sem.h>]],
	[[union semun arg; semctl(0, 0, 0, arg);]])],
	[
	AC_MSG_RESULT([yes])
	AC_DEFINE_UNQUOTED([HAVE_SEMUN], 1, [Define to 1 if you have union semun.])
	],
	[
	AC_MSG_RESULT([no])
	]
	)


	AC_MSG_CHECKING(for MSG_NOSIGNAL)
	AC_TRY_COMPILE([#include <sys/socket.h>],
	[ int f = MSG_NOSIGNAL; ],
	[ AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_MSG_NOSIGNAL, 1,
	[Define this symbol if you have MSG_NOSIGNAL])],
	[ AC_MSG_RESULT(no)])

	AC_MSG_CHECKING(for SO_NOSIGPIPE )
	AC_TRY_COMPILE([#include <sys/socket.h>],
	[ int f = SO_NOSIGPIPE; ],
	[ AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_SO_NOSIGPIPE, 1,
	[Define this symbol if you have SO_NOSIGPIPE]) ],
	[ AC_MSG_RESULT(no)])

	# Checks for library functions.
	AC_FUNC_CHOWN
	AC_FUNC_FORK
	AC_FUNC_MMAP
	AC_FUNC_STRERROR_R
	AC_CHECK_FUNCS([alarm clock_gettime ftruncate gettimeofday \
	localtime localtime_r memset munmap socket \
	strchr strrchr strdup strstr strcasecmp \
	poll epoll_create epoll_create1 kqueue \
	random rand getrlimit sysconf \
	pthread_spin_lock pthread_setschedparam \
	pthread_mutexattr_setpshared \
	pthread_condattr_setpshared \
	sem_timedwait semtimedop \
	sched_get_priority_max sched_setscheduler \
	getpeerucred getpeereid])

	AM_CONDITIONAL(HAVE_SEM_TIMEDWAIT,
	[test "x$ac_cv_func_sem_timedwait" = xyes])
	AM_CONDITIONAL(HAVE_EPOLL,
	[test "x$ac_cv_func_epoll_create" = xyes])
	AM_CONDITIONAL(HAVE_POLL,
	[test "x$ac_cv_func_poll" = xyes])
	AM_CONDITIONAL(HAVE_KQUEUE,
	[test "x$ac_cv_func_kqueue" = xyes])

	AC_CONFIG_LIBOBJ_DIR(lib)
	AC_REPLACE_FUNCS(strlcpy strlcat strchrnul)

	## local defines
	PACKAGE_FEATURES=""

	if test x$ac_cv_func_epoll_create = xyes; then
	PACKAGE_FEATURES="$PACKAGE_FEATURES epoll"
	fi

	nongcc_memory_barrier_needed=no
	arch_force_shmlba=no
	AC_MSG_CHECKING([for architecture in ${host_cpu}])
	case $host_cpu in
	sparc*)
	AC_MSG_RESULT([sparc])
	AC_DEFINE_UNQUOTED([QB_ARCH_SPARC], [1], [sparc])
	nongcc_memory_barrier_needed=yes
	arch_force_shmlba=yes
	;;
	alpha*)
	AC_MSG_RESULT([alpha])
	AC_DEFINE_UNQUOTED([QB_ARCH_ALPHA], [1], [alpha])
	nongcc_memory_barrier_needed=yes
	;;
	powerpc*)
	AC_MSG_RESULT([powerpc])
	AC_DEFINE_UNQUOTED([QB_ARCH_POWERPC], [1], [powerpc])
	ac_cv_link_attribute_section=no
	nongcc_memory_barrier_needed=yes
	arch_force_shmlba=yes
	;;
	ia64)
	AC_MSG_RESULT([ia64])
	AC_DEFINE_UNQUOTED([QB_ARCH_IA64], [1], [ia64])
	nongcc_memory_barrier_needed=yes
	;;
	arm*)
	AC_MSG_RESULT([arm])
	AC_DEFINE_UNQUOTED([QB_ARCH_ARM], [1], [arm])
	arch_force_shmlba=yes
	;;
	hppa*)
	AC_MSG_RESULT([hppa])
	AC_DEFINE_UNQUOTED([QB_ARCH_HPPA], [1], [hppa])
	;;
	mips*)
	AC_MSG_RESULT([ia64])
	AC_DEFINE_UNQUOTED([QB_ARCH_MIPS], [1], [mips])
	arch_force_shmlba=yes
	;;
	*)
	AC_MSG_RESULT([${host_cpu}])
	;;
	esac

	if test $arch_force_shmlba = yes; then
	AC_DEFINE_UNQUOTED([QB_FORCE_SHM_ALIGN], [1],
	[shared and fixed mmap must align on 16k])
	fi

	# OS detection
	# THIS SECTION MUST DIE!
	CP=cp
	AC_MSG_CHECKING([for os in ${host_os}])
	case "$host_os" in
	linux)
	AC_DEFINE_UNQUOTED([QB_LINUX], [1],
	[Compiling for Linux platform])
	AC_MSG_RESULT([Linux])
	;;
	cygwin)
	AC_DEFINE_UNQUOTED([QB_CYGWIN], [1],
	[Compiling for Cygwin platform])
	ac_cv_link_attribute_section=no
	nongcc_memory_barrier_needed=yes
	gcc_has_builtin_sync_operations=no
	AC_MSG_RESULT([Cygwin])
	;;
	darwin*)
	AC_DEFINE_UNQUOTED([QB_DARWIN], [1],
	[Compiling for Darwin platform])
	CP=rsync
	ac_cv_link_attribute_section=no
	dnl Attribute section appears to work here but fails later with:
	dnl cc1: error in backend: Global variable 'descriptor.4902'
	dnl has an invalid section specifier '__verbose': mach-o
	dnl section specifier requires a segment and section
	dnl separated by a comma
	AC_DEFINE_UNQUOTED([DISABLE_POSIX_THREAD_PROCESS_SHARED], [1],
	[Disable _POSIX_THREAD_PROCESS_SHARED])
	AC_MSG_RESULT([Darwin])
	;;
	bsd)
	AC_DEFINE_UNQUOTED([QB_BSD], [1],
	[Compiling for BSD platform])
	case "$host_os" in
	netbsd)
	# this is because dlopen within a dl_iterate_phdr
	# callback locks up.
	ac_cv_link_attribute_section=no
	AC_DEFINE_UNQUOTED([UNIX_PATH_MAX], [103],
	[Unix path length])
	;;
	openbsd)
	AC_DEFINE_UNQUOTED([UNIX_PATH_MAX], [104],
	[Unix path length])
	;;
	esac
	AC_MSG_RESULT([BSD])
	;;
	solaris)
	ac_cv_link_attribute_section=no
	AC_DEFINE_UNQUOTED(DISABLE_IPC_SHM, 1,
	[Disable shared mem ipc])
	AC_DEFINE_UNQUOTED([QB_SOLARIS], [1],
	[Compiling for Solaris platform])
	CP=rsync
	AC_MSG_RESULT([Solaris])
	;;
	*)
	AC_MSG_ERROR([Unsupported OS? hmmmm])
	;;
	esac

	AC_MSG_CHECKING([whether GCC supports builtin sync intrinsics])
	if test -z "$gcc_has_builtin_sync_operations"; then
	gcc_has_builtin_sync_operations=no
	if test x"$GCC" = xyes && test x$have_mingw != xyes; then
	AC_TRY_LINK([],
	[int i;
	__sync_synchronize ();
	__sync_bool_compare_and_swap (&i, 0, 1);
	__sync_fetch_and_add (&i, 1);
	],
	[gcc_has_builtin_sync_operations=yes],
	[gcc_has_builtin_sync_operations=no])
	fi
	fi
	AC_MSG_RESULT($gcc_has_builtin_sync_operations)
	AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_SYNC_OPERATIONS,
	[test "x$gcc_has_builtin_sync_operations" = xyes])

	if test "x$gcc_has_builtin_sync_operations" = xyes; then
	AC_DEFINE_UNQUOTED(HAVE_GCC_BUILTINS_FOR_SYNC_OPERATIONS, 1,
	[have builtin sync operations])
	fi

	# __atomic_XXX
	AC_MSG_CHECKING([whether GCC supports builtin atomic intrinsics])
	if test -z "$gcc_has_builtin_atomic_operations"; then
	gcc_has_builtin_atomic_operations=no
	if test x"$GCC" = xyes && test x$have_mingw != xyes; then
	AC_TRY_LINK([],
	[int i;
	__atomic_load_n(&i, __ATOMIC_ACQUIRE);
	__atomic_exchange_n(&i, 0, __ATOMIC_RELEASE);
	],
	[gcc_has_builtin_atomic_operations=yes],
	[gcc_has_builtin_atomic_operations=no])
	fi
	fi
	AC_MSG_RESULT($gcc_has_builtin_atomic_operations)
	AM_CONDITIONAL(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS,
	[test "x$gcc_has_builtin_atomic_operations" = xyes])

	if test "x$gcc_has_builtin_atomic_operations" = xyes; then
	AC_DEFINE_UNQUOTED(HAVE_GCC_BUILTINS_FOR_ATOMIC_OPERATIONS, 1,
	[have builtin atomic operations])
	fi


	AC_MSG_CHECKING([whether atomics need memory barrier])
	if test -n "$ac_cv_atomic_need_memory_barrier"; then
	memory_barrier_needed=$ac_cv_atomic_need_memory_barrier
	else
	if test x$gcc_has_builtin_sync_operations = xyes; then
	memory_barrier_needed=yes
	PACKAGE_FEATURES="$PACKAGE_FEATURES gcc__sync"
	else
	memory_barrier_needed=$nongcc_memory_barrier_needed
	AC_MSG_WARN([-----------------------------])
	AC_MSG_WARN([You have gcc but not __sync_bool_compare_and_swap])
	AC_MSG_WARN([try CFLAGS="-march=<your arch> -mtune=native" ./configure])
	AC_MSG_WARN([-----------------------------])
	fi
	fi
	AC_MSG_RESULT($memory_barrier_needed)

	if test x"$memory_barrier_needed" != xno; then
	AC_DEFINE_UNQUOTED(QB_ATOMIC_OP_MEMORY_BARRIER_NEEDED, 1,
	[need atomic memory barrier])
	fi

	LINT_FLAGS="-syntax -weak -unrecog +posixlib +ignoresigns -fcnuse \
	-badflag -D__gnuc_va_list=va_list -D__attribute$x$= \
	-warnposix +matchanyintegral -sysunrecog"

	# local options
	AC_ARG_ENABLE([ansi],
	[ --enable-ansi : force to build with ANSI standards. ],
	[ default="no" ])

	AC_ARG_ENABLE([fatal-warnings],
	[ --enable-fatal-warnings : enable fatal warnings. ],
	[ default="no" ])

	AC_ARG_ENABLE([debug],
	[ --enable-debug : enable debug build. ],
	[ default="no" ])

	AC_ARG_ENABLE([coverage],
	[ --enable-coverage : coverage analysis of the codebase. ],
	[ default="no" ])

	AC_ARG_ENABLE([slow-tests],
	[ --enable-slow-tests : build and run slow tests. ],
	[ default="no" ])

	AC_ARG_WITH([socket-dir],
	[ --with-socket-dir=DIR : socket dir. ],
	[ SOCKETDIR="$withval" ],
	[ SOCKETDIR="$localstatedir/run" ])

	AC_SUBST(CP)
	# *FLAGS handling goes here

	ENV_CFLAGS="$CFLAGS"
	ENV_CPPFLAGS="$CPPFLAGS"
	ENV_LDFLAGS="$LDFLAGS"

	# debug build stuff
	if test "x${enable_debug}" = xyes; then
	AC_DEFINE_UNQUOTED([DEBUG], [1], [Compiling Debugging code])
	OPT_CFLAGS="-O0"
	if test "x${GCC}" = xyes; then
	GDB_FLAGS="-ggdb3"
	else
	GDB_FLAGS="-g"
	fi
	PACKAGE_FEATURES="$PACKAGE_FEATURES debug"
	fi

	# extra warnings
	EXTRA_WARNINGS=""

	WARNLIST="
	all
	shadow
	missing-prototypes
	missing-declarations
	strict-prototypes
	declaration-after-statement
	pointer-arith
	write-strings
	cast-align
	bad-function-cast
	missing-format-attribute
	format=2
	format-security
	no-format-nonliteral
	no-long-long
	unsigned-char
	gnu89-inline
	no-strict-aliasing
	"

	for j in $WARNLIST; do
	if cc_supports_flag -W$j; then
	EXTRA_WARNINGS="$EXTRA_WARNINGS -W$j";
	fi
	done

	+# warnings suppression
	+if test x"$GCC" = xyes && cc_supports_flag -Wsuggest-attribute=format; then
	+ AC_DEFINE([HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT], [],
	+ [gcc supports -Wsuggest-attribute=format])
	+fi
	+
	# --- coverage ---
	if test "x${enable_coverage}" = xyes && \
	cc_supports_flag -ftest-coverage && \
	cc_supports_flag -fprofile-arcs ; then
	AC_MSG_NOTICE([Enabling Coverage (enable -O0 by default)])
	OPT_CFLAGS="-O0"
	COVERAGE_CFLAGS="-ftest-coverage -fprofile-arcs"
	COVERAGE_LDFLAGS="-ftest-coverage -fprofile-arcs"
	PACKAGE_FEATURES="$PACKAGE_FEATURES coverage"
	else
	COVERAGE_CFLAGS=""
	COVERAGE_LDFLAGS=""
	fi

	if test "x${enable_slow_tests}" = xyes ; then
	AC_DEFINE([HAVE_SLOW_TESTS], 1,[have slow tests])
	AC_MSG_NOTICE([Enabling Slow tests])
	fi
	AM_CONDITIONAL(HAVE_SLOW_TESTS, [test "x${enable_slow_tests}" = xyes])
	AC_SUBST(HAVE_SLOW_TESTS)

	# --- callsite sections ---
	if test "x${GCC}" = xyes; then
	AC_MSG_CHECKING([whether GCC supports __attribute__((section())])
	if test "x${ac_cv_link_attribute_section}" = x ; then
	AC_TRY_LINK([],
	[static int my_var __attribute__((section("__verbose"))) = 5;
	if (my_var == 5) return 0;
	else return -1;
	],
	[gcc_has_attribute_section=yes],
	[gcc_has_attribute_section=no])
	else
	gcc_has_attribute_section=${ac_cv_link_attribute_section}
	fi

	AC_MSG_RESULT($gcc_has_attribute_section)
	if test $gcc_has_attribute_section = yes; then
	AC_DEFINE([QB_HAVE_ATTRIBUTE_SECTION], 1,
	[Enabling code using __attribute__((section))])
	PACKAGE_FEATURES="$PACKAGE_FEATURES attribute-section"
	fi
	fi

	# --- ansi ---
	if test "x${enable_ansi}" = xyes && \
	cc_supports_flag -std=iso9899:199409 ; then
	AC_MSG_NOTICE([Enabling ANSI Compatibility])
	ANSI_CPPFLAGS="-ansi -D_GNU_SOURCE -DANSI_ONLY"
	PACKAGE_FEATURES="$PACKAGE_FEATURES ansi"
	else
	ANSI_CPPFLAGS=""
	fi

	# --- fatal warnings ---
	if test "x${enable_fatal_warnings}" = xyes && \
	cc_supports_flag -Werror ; then
	AC_MSG_NOTICE([Enabling Fatal Warnings (-Werror)])
	WERROR_CFLAGS="-Werror"
	PACKAGE_FEATURES="$PACKAGE_FEATURES fatal-warnings"
	else
	WERROR_CFLAGS=""
	fi

	# final build of *FLAGS
	CFLAGS="$ENV_CFLAGS $OPT_CFLAGS $GDB_FLAGS \
	$COVERAGE_CFLAGS $EXTRA_WARNINGS $WERROR_CFLAGS"
	CPPFLAGS="$ENV_CPPFLAGS $ANSI_CPPFLAGS"
	LDFLAGS="$ENV_LDFLAGS $COVERAGE_LDFLAGS"

	if test -f /usr/share/dict/words ; then
	HAVE_DICT_WORDS=yes
	AC_DEFINE([HAVE_DICT_WORDS], 1, "Have /usr/share/dict/words")
	fi
	AM_CONDITIONAL([HAVE_DICT_WORDS], [test "x$HAVE_DICT_WORDS" = xyes])

	# substitute what we need:
	AC_SUBST([SOCKETDIR])
	AC_SUBST([LINT_FLAGS])

	AC_DEFINE_UNQUOTED([SOCKETDIR], "$(eval echo ${SOCKETDIR})", [Socket directory])
	AC_DEFINE_UNQUOTED([LOCALSTATEDIR], "$(eval echo ${localstatedir})", [localstate directory])
	AC_DEFINE_UNQUOTED([PACKAGE_FEATURES], "${PACKAGE_FEATURES}", [quarterback built-in features])

	AC_CONFIG_FILES([Makefile
	include/Makefile
	include/qb/Makefile
	lib/Makefile
	lib/libqb.pc
	tools/Makefile
	tests/Makefile
	tests/test.conf
	examples/Makefile
	docs/Makefile
	docs/man.dox
	docs/html.dox])

	AC_OUTPUT

	AC_MSG_RESULT([])
	AC_MSG_RESULT([$PACKAGE configuration:])
	AC_MSG_RESULT([ Version = ${VERSION}])
	AC_MSG_RESULT([ Prefix = ${prefix}])
	AC_MSG_RESULT([ Executables = ${sbindir}])
	AC_MSG_RESULT([ Man pages = ${mandir}])
	AC_MSG_RESULT([ Doc dir = ${docdir}])
	AC_MSG_RESULT([ Libraries = ${libdir}])
	AC_MSG_RESULT([ Header files = ${includedir}])
	AC_MSG_RESULT([ Arch-independent files = ${datadir}])
	AC_MSG_RESULT([ State information = ${localstatedir}])
	AC_MSG_RESULT([ System configuration = ${sysconfdir}])
	AC_MSG_RESULT([ SOCKETDIR = ${SOCKETDIR}])
	AC_MSG_RESULT([ Features =${PACKAGE_FEATURES}])
	AC_MSG_RESULT([])
	AC_MSG_RESULT([$PACKAGE build info:])
	AC_MSG_RESULT([ Optimization = ${OPT_CFLAGS}])
	AC_MSG_RESULT([ Debug options = ${GDB_CFLAGS}])
	AC_MSG_RESULT([ Extra compiler warnings = ${EXTRA_WARNING}])
	AC_MSG_RESULT([ Env. defined CFLAG = ${ENV_CFLAGS}])
	AC_MSG_RESULT([ Env. defined CPPFLAGS = ${ENV_CPPFLAGS}])
	AC_MSG_RESULT([ Env. defined LDFLAGS = ${ENV_LDFLAGS}])
	AC_MSG_RESULT([ ANSI defined CPPFLAGS = ${ANSI_CPPFLAGS}])
	AC_MSG_RESULT([ Coverage CFLAGS = ${COVERAGE_CFLAGS}])
	AC_MSG_RESULT([ Coverage LDFLAGS = ${COVERAGE_LDFLAGS}])
	AC_MSG_RESULT([ Fatal War. CFLAGS = ${WERROR_CFLAGS}])
	AC_MSG_RESULT([ Final CFLAGS = ${CFLAGS}])
	AC_MSG_RESULT([ Final CPPFLAGS = ${CPPFLAGS}])
	AC_MSG_RESULT([ Final LDFLAGS = ${LDFLAGS}])
	diff --git a/include/qb/qblog.h b/include/qb/qblog.h
	index 042d7a0..870cbae 100644
	--- a/include/qb/qblog.h
	+++ b/include/qb/qblog.h
	@@ -1,655 +1,657 @@
	/*
	* Copyright (C) 2010 Red Hat, Inc.
	*
	* All rights reserved.
	*
	* Author: Angus Salkeld <asalkeld@redhat.com>
	*
	* libqb is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Lesser General Public License as published by
	* the Free Software Foundation, either version 2.1 of the License, or
	* (at your option) any later version.
	*
	* libqb is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public License
	* along with libqb. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef QB_LOG_H_DEFINED
	#define QB_LOG_H_DEFINED

	/* INDENT-OFF */
	#ifdef __cplusplus
	extern "C" {
	#endif
	/* INDENT-ON */

	#include <stdint.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <stdarg.h>
	#include <errno.h>
	#include <syslog.h>
	#include <string.h>
	#include <qb/qbutil.h>
	#include <qb/qbconfig.h>

	#ifdef S_SPLINT_S
	#undef QB_HAVE_ATTRIBUTE_SECTION
	#endif /* S_SPLINT_S */

	/**
	* @file qblog.h
	* The logging API provides four main parts (basics, filtering, threading & blackbox).
	*
	* The idea behind this logging system is not to be prescriptive but to provide a
	* set of tools to help the developer achieve what they want quickly and easily.
	*
	* @par Basic logging API.
	* Call qb_log() to generate a log message. Then to write the message
	* somewhere meaningful call qb_log_ctl() to configure the targets.
	*
	* Simplist possible use:
	* @code
	* main() {
	* qb_log_init("simple-log", LOG_DAEMON, LOG_INFO);
	* // ...
	* qb_log(LOG_WARNING, "watch out");
	* // ...
	* qb_log_fini();
	* }
	* @endcode
	*
	* @par Configuring log targets.
	* A log target can by syslog, stderr, the blackbox or a text file.
	* By default only syslog is enabled.
	*
	* To enable a target do the following
	* @code
	* qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
	* @endcode
	*
	* syslog, stderr and the blackbox are static (they don't need
	* to be created, just enabled or disabled. However you can open multiple
	* logfiles (32 - QB_LOG_BLACKBOX). To do this use the following code.
	* @code
	* mytarget = qb_log_file_open("/var/log/mylogfile");
	* qb_log_ctl(mytarget, QB_LOG_CONF_ENABLED, QB_TRUE);
	* @endcode
	*
	* Once your targets are enabled/opened you can configure them as follows:
	* Configure the size of blackbox
	* @code
	* qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 1024*10);
	* @endcode
	*
	* Make logging to file threaded:
	* @code
	* qb_log_ctl(mytarget, QB_LOG_CONF_THREADED, QB_TRUE);
	* @endcode
	*
	* To workaround your syslog daemon filtering all messages > LOG_INFO
	* @code
	* qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_PRIORITY_BUMP,
	* LOG_INFO - LOG_DEBUG);
	* @endcode
	*
	* To ensure all logs to file targets are fsync'ed (default QB_FALSE)
	* @code
	* qb_log_ctl(mytarget, QB_LOG_CONF_FILE_SYNC, QB_TRUE);
	* @endcode
	*
	*
	* @par Filtering messages.
	* To have more power over what log messages go to which target you can apply
	* filters to the targets. What happens is the desired callsites have the
	* correct bit set. Then when the log message is generated it gets sent to the
	* targets based on which bit is set in the callsite's "target" bitmap.
	* Messages can be filtered based on the:
	* -# filename + priority
	* -# function name + priority
	* -# format string + priority
	*
	* So to make all logs from evil_fnunction() go to stderr do the following:
	* @code
	* qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
	* QB_LOG_FILTER_FUNCTION, "evil_fnunction", LOG_TRACE);
	* @endcode
	*
	* So to make all logs from totem* (with a priority <= LOG_INFO) go to stderr do the following:
	* @code
	* qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
	* QB_LOG_FILTER_FILE, "totem", LOG_INFO);
	* @endcode
	*
	* So to make all logs with the substring "ringbuffer" go to stderr do the following:
	* @code
	* qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
	* QB_LOG_FILTER_FORMAT, "ringbuffer", LOG_TRACE);
	* @endcode
	*
	* @par Thread safe non-blocking logging.
	* Logging is only thread safe when threaded logging is in use. If you plan
	* on logging from multiple threads, you must initialize libqb's logger thread
	* and use qg_log_filter_ctl to set the QB_LOG_CONF_THREADED flag on all the
	* logging targets in use.
	*
	* To achieve non-blocking logging you can use threaded logging as well
	* So any calls to write() or syslog() will not hold up your program.
	*
	* Threaded logging use:
	* @code
	* main() {
	* qb_log_init("simple-log", LOG_DAEMON, LOG_INFO);
	* qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_THREADED, QB_TRUE);
	* // ...
	* daemonize();
	* // call this after you fork()
	* qb_log_thread_start();
	* // ...
	* qb_log(LOG_WARNING, "watch out");
	* // ...
	* qb_log_fini();
	* }
	* @endcode
	*
	* @par A blackbox for in-field diagnosis.
	* This stores log messages in a ringbuffer so they can be written to
	* file if the program crashes (you will need to catch SIGSEGV). These
	* can then be easily printed out later.
	*
	* @note the blackbox is not enabled by default.
	*
	* Blackbox usage:
	* @code
	*
	* static void sigsegv_handler(int sig)
	* {
	* (void)signal (SIGSEGV, SIG_DFL);
	* qb_log_blackbox_write_to_file("simple-log.fdata");
	* qb_log_fini();
	* raise(SIGSEGV);
	* }
	*
	* main() {
	*
	* signal(SIGSEGV, sigsegv_handler);
	*
	* qb_log_init("simple-log", LOG_DAEMON, LOG_INFO);
	* qb_log_filter_ctl(QB_LOG_BLACKBOX, QB_LOG_FILTER_ADD,
	* QB_LOG_FILTER_FILE, "*", LOG_DEBUG);
	* qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 1024*10);
	* qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
	* // ...
	* qb_log(LOG_WARNING, "watch out");
	* // ...
	* qb_log_fini();
	* }
	* @endcode
	*
	* @par Tagging messages.
	* You can tag messages using the second argument to qb_logt() or
	* by using qb_log_filter_ctl().
	* This can be used to add feature or sub-system information to the logs.
	*
	* @code
	* const char* my_tags_stringify(uint32_t tags) {
	* if (qb_bit_is_set(tags, QB_LOG_TAG_LIBQB_MSG_BIT) {
	* return "libqb";
	* } else if (tags == 3) {
	* return "three";
	* } else {
	* return "MAIN";
	* }
	* }
	* main() {
	* // ...
	* qb_log_tags_stringify_fn_set(my_tags_stringify);
	* qb_log_format_set(QB_LOG_STDERR, "[%5g] %p %b");
	* // ...
	* qb_logt(LOG_INFO, 3, "hello");
	* qb_logt(LOG_INFO, 0, "hello");
	* }
	* @endcode
	* The code above will produce:
	* @code
	* [libqb] some message
	* [three] info hello
	* [MAIN ] info hello
	* @endcode
	*
	* @example simplelog.c
	*/

	#undef LOG_TRACE
	#define LOG_TRACE (LOG_DEBUG + 1)

	#define QB_LOG_MAX_LEN 512
	#define QB_LOG_STRERROR_MAX_LEN 128

	typedef const char (qb_log_tags_stringify_fn)(uint32_t tags);

	/**
	* An instance of this structure is created in a special
	* ELF section at every dynamic debug callsite. At runtime,
	* the special section is treated as an array of these.
	*/
	struct qb_log_callsite {
	const char *function;
	const char *filename;
	const char *format;
	uint8_t priority;
	uint32_t lineno;
	uint32_t targets;
	uint32_t tags;
	} __attribute__((aligned(8)));

	typedef void (qb_log_filter_fn)(struct qb_log_callsite cs);

	/* will be assigned by ld linker magic */
	#ifdef QB_HAVE_ATTRIBUTE_SECTION
	extern struct qb_log_callsite __start___verbose[];
	extern struct qb_log_callsite __stop___verbose[];

	#define QB_LOG_INIT_DATA(name) \
	void name(void); \
	void name(void) { if (__start___verbose != __stop___verbose) {assert(1);} } \
	void __attribute__ ((constructor)) name(void);
	#else
	#define QB_LOG_INIT_DATA(name)
	#endif

	/**
	* Internal function: use qb_log() or qb_logt()
	*/
	void qb_log_real_(struct qb_log_callsite *cs, ...);
	void qb_log_real_va_(struct qb_log_callsite *cs, va_list ap);

	#define QB_LOG_TAG_LIBQB_MSG_BIT 31
	#define QB_LOG_TAG_LIBQB_MSG (1 << QB_LOG_TAG_LIBQB_MSG_BIT)

	/**
	* This function is to import logs from other code (like libraries)
	* that provide a callback with their logs.
	*
	* @note the performance of this will not impress you, as
	* the filtering is done on each log message, not
	* before hand. So try doing basic pre-filtering.
	*
	* @param function originating function name
	* @param filename originating filename
	* @param format format string
	* @param priority this takes syslog priorities.
	* @param lineno file line number
	* @param tags this is a uint32_t that you can use with
	* qb_log_tags_stringify_fn_set() to "tag" a log message
	* with a feature or sub-system then you can use "%g"
	* in the format specifer to print it out.
	*/
	void qb_log_from_external_source(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno,
	uint32_t tags,
	- ...);
	+ ...)
	+ __attribute__ ((format (printf, 3, 7)));

	/**
	* Get or create a callsite at the give position.
	*
	* The result can then be passed into qb_log_real_()
	*
	* @param function originating function name
	* @param filename originating filename
	* @param format format string
	* @param priority this takes syslog priorities.
	* @param lineno file line number
	* @param tags the tag
	*/
	struct qb_log_callsite* qb_log_callsite_get(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno,
	uint32_t tags);

	void qb_log_from_external_source_va(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno,
	uint32_t tags,
	- va_list ap);
	+ va_list ap)
	+ __attribute__ ((format (printf, 3, 0)));

	/**
	* This is the function to generate a log message if you want to
	* manually add tags.
	*
	* @param priority this takes syslog priorities.
	* @param tags this is a uint32_t that you can use with
	* qb_log_tags_stringify_fn_set() to "tag" a log message
	* with a feature or sub-system then you can use "%g"
	* in the format specifer to print it out.
	* @param fmt usual printf style format specifiers
	* @param args usual printf style args
	*/
	#ifdef QB_HAVE_ATTRIBUTE_SECTION
	#define qb_logt(priority, tags, fmt, args...) do { \
	static struct qb_log_callsite descriptor \
	__attribute__((section("__verbose"), aligned(8))) = \
	{ __func__, __FILE__, fmt, priority, __LINE__, 0, tags }; \
	qb_log_real_(&descriptor, ##args); \
	} while(0)
	#else
	#define qb_logt(priority, tags, fmt, args...) do { \
	struct qb_log_callsite* descriptor_pt = \
	qb_log_callsite_get(__func__, __FILE__, fmt, \
	priority, __LINE__, tags); \
	qb_log_real_(descriptor_pt, ##args); \
	} while(0)
	#endif /* QB_HAVE_ATTRIBUTE_SECTION */


	/**
	* This is the main function to generate a log message.
	*
	* @param priority this takes syslog priorities.
	* @param fmt usual printf style format specifiers
	* @param args usual printf style args
	*/
	#define qb_log(priority, fmt, args...) qb_logt(priority, 0, fmt, ##args)

	/* Define the character used to mark the beginning of "extended" information;
	* a string equivalent is also defined so clients can use it like:
	* qb_log(level, "blah blah "QB_XS" yada yada", __func__);
	*/
	#define QB_XC '\a'
	#define QB_XS "\a"

	/**
	* This is similar to perror except it goes into the logging system.
	*
	* @param priority this takes syslog priorities.
	* @param fmt usual printf style format specifiers
	* @param args usual printf style args
	*
	* @note Because qb_perror() adds the system error message and error number onto
	* the end of the given fmt, that information will become extended
	* information if QB_XS is used inside fmt and will not show up in any
	* logs that strip extended information.
	*/
	#ifndef S_SPLINT_S
	#define qb_perror(priority, fmt, args...) do { \
	char _perr_buf_[QB_LOG_STRERROR_MAX_LEN]; \
	const char *_perr_str_ = qb_strerror_r(errno, _perr_buf_, sizeof(_perr_buf_)); \
	qb_logt(priority, 0, fmt ": %s (%d)", ##args, _perr_str_, errno); \
	} while(0)
	#else
	#define qb_perror
	#endif

	#define qb_enter() qb_log(LOG_TRACE, "ENTERING %s()", __func__)
	#define qb_leave() qb_log(LOG_TRACE, "LEAVING %s()", __func__)

	#define QB_LOG_SYSLOG 0
	#define QB_LOG_STDERR 1
	#define QB_LOG_BLACKBOX 2
	#define QB_LOG_STDOUT 3

	#define QB_LOG_TARGET_MAX 32

	enum qb_log_target_state {
	QB_LOG_STATE_UNUSED = 1,
	QB_LOG_STATE_DISABLED = 2,
	QB_LOG_STATE_ENABLED = 3,
	};

	enum qb_log_conf {
	QB_LOG_CONF_ENABLED,
	QB_LOG_CONF_FACILITY,
	QB_LOG_CONF_DEBUG,
	QB_LOG_CONF_SIZE,
	QB_LOG_CONF_THREADED,
	QB_LOG_CONF_PRIORITY_BUMP,
	QB_LOG_CONF_STATE_GET,
	QB_LOG_CONF_FILE_SYNC,
	QB_LOG_CONF_EXTENDED,
	};

	enum qb_log_filter_type {
	QB_LOG_FILTER_FILE,
	QB_LOG_FILTER_FUNCTION,
	QB_LOG_FILTER_FORMAT,
	QB_LOG_FILTER_FILE_REGEX,
	QB_LOG_FILTER_FUNCTION_REGEX,
	QB_LOG_FILTER_FORMAT_REGEX,
	};

	enum qb_log_filter_conf {
	QB_LOG_FILTER_ADD,
	QB_LOG_FILTER_REMOVE,
	QB_LOG_FILTER_CLEAR_ALL,
	QB_LOG_TAG_SET,
	QB_LOG_TAG_CLEAR,
	QB_LOG_TAG_CLEAR_ALL,
	};

	typedef void (*qb_log_logger_fn)(int32_t t,
	struct qb_log_callsite *cs,
	time_t timestamp,
	const char *msg);
	typedef void (*qb_log_vlogger_fn)(int32_t t,
	struct qb_log_callsite *cs,
	time_t timestamp,
	va_list ap);

	typedef void (*qb_log_close_fn)(int32_t t);
	typedef void (*qb_log_reload_fn)(int32_t t);

	/**
	* Init the logging system.
	*
	* @param name will be passed into openlog()
	* @param facility default for all new targets.
	* @param priority a basic filter with this priority will be added.
	*/
	void qb_log_init(const char *name,
	int32_t facility,
	uint8_t priority);

	/**
	* Logging system finalization function.
	*
	* It releases any shared memory.
	* Stops the logging thread if running.
	* Flushes the last message to their destinations.
	*/
	void qb_log_fini(void);

	/**
	* If you are using dynamically loadable modules via dlopen() and
	* you load them after qb_log_init() then after you load the module
	* you will need to do the following to get the filters to work
	* in that module.
	* @code
	* _start = dlsym (dl_handle, "__start___verbose");
	* _stop = dlsym (dl_handle, "__stop___verbose");
	* qb_log_callsites_register(_start, _stop);
	* @endcode
	*/
	int32_t qb_log_callsites_register(struct qb_log_callsite _start, struct qb_log_callsite _stop);

	/**
	* Dump the callsite info to stdout.
	*/
	void qb_log_callsites_dump(void);

	/**
	* Main logging control function.
	*
	* @param target QB_LOG_SYSLOG, QB_LOG_STDERR or result from qb_log_file_open()
	* @param conf_type what to configure
	* @param arg the new value
	* @see qb_log_conf
	*
	* @retval -errno on error
	* @retval 0 on success
	* @retval qb_log_target_state for QB_LOG_CONF_STATE_GET
	*/
	int32_t qb_log_ctl(int32_t target, enum qb_log_conf conf_type, int32_t arg);

	/**
	* This allows you modify the 'tags' and 'targets' callsite fields at runtime.
	*/
	int32_t qb_log_filter_ctl(int32_t value, enum qb_log_filter_conf c,
	enum qb_log_filter_type type, const char * text,
	uint8_t low_priority);


	/**
	* This extends qb_log_filter_ctl() by been able to provide a high_priority.
	*/
	int32_t qb_log_filter_ctl2(int32_t value, enum qb_log_filter_conf c,
	enum qb_log_filter_type type, const char * text,
	uint8_t high_priority, uint8_t low_priority);


	/**
	* Instead of using the qb_log_filter_ctl() functions you
	* can apply the filters manually by defining a callback
	* and setting the targets field using qb_bit_set() and
	* qb_bit_clear() like the following below.
	* @code
	* static void
	* m_filter(struct qb_log_callsite *cs)
	* {
	* if ((cs->priority >= LOG_ALERT &&
	* cs->priority <= LOG_DEBUG) &&
	* strcmp(cs->filename, "my_c_file.c") == 0) {
	* qb_bit_set(cs->targets, QB_LOG_SYSLOG);
	* } else {
	* qb_bit_clear(cs->targets, QB_LOG_SYSLOG);
	* }
	* }
	* @endcode
	*/
	int32_t qb_log_filter_fn_set(qb_log_filter_fn fn);

	/**
	* Set the callback to map the 'tags' bit map to a string.
	*/
	void qb_log_tags_stringify_fn_set(qb_log_tags_stringify_fn fn);

	/**
	* Set the format specifiers.
	*
	* %n FUNCTION NAME
	* %f FILENAME
	* %l FILELINE
	* %p PRIORITY
	* %t TIMESTAMP
	* %b BUFFER
	* %g TAGS
	* %N name (passed into qb_log_init)
	* %P PID
	* %H hostname
	*
	* any number between % and character specify field length to pad or chop
	*/
	void qb_log_format_set(int32_t t, const char* format);

	/**
	* Open a log file.
	*
	* @retval -errno on error
	* @retval 3 to 31 (to be passed into other qb_log_* functions)
	*/
	int32_t qb_log_file_open(const char *filename);

	/**
	* Close a log file and release is resources.
	*/
	void qb_log_file_close(int32_t t);

	/**
	* When using threaded logging set the pthread policy and priority.
	*
	* @retval -errno on error
	* @retval 0 success
	*/
	int32_t qb_log_thread_priority_set(int32_t policy, int32_t priority);

	/**
	* Start the logging pthread.
	*/
	int32_t qb_log_thread_start(void);

	/**
	* Write the blackbox to file.
	*/
	ssize_t qb_log_blackbox_write_to_file(const char *filename);

	/**
	* Read the blackbox for file and print it out.
	*/
	void qb_log_blackbox_print_from_file(const char* filename);

	/**
	* Open a custom log target.
	*
	* @retval -errno on error
	* @retval 3 to 31 (to be passed into other qb_log_* functions)
	*/
	int32_t qb_log_custom_open(qb_log_logger_fn log_fn,
	qb_log_close_fn close_fn,
	qb_log_reload_fn reload_fn,
	void *user_data);

	/**
	* Close a custom log target and release is resources.
	*/
	void qb_log_custom_close(int32_t t);

	/**
	* Retrieve the user data set by either qb_log_custom_open or
	* qb_log_target_user_data_set.
	*/
	void *qb_log_target_user_data_get(int32_t t);

	/**
	* Associate user data with this log target
	* @note only use this with custom targets
	*/
	int32_t qb_log_target_user_data_set(int32_t t, void *user_data);

	/**
	* format the callsite and timestamp info according to the format
	* set using qb_log_format_set()
	* It is intended to be used from your custom logger function.
	*/
	void qb_log_target_format(int32_t target,
	struct qb_log_callsite *cs,
	time_t timestamp,
	const char* formatted_message,
	char *output_buffer);

	/**
	* Convert string "auth" to equivalent number "LOG_AUTH" etc.
	*/
	int32_t qb_log_facility2int(const char *fname);

	/**
	* Convert number "LOG_AUTH" to equivalent string "auth" etc.
	*/
	const char * qb_log_facility2str(int32_t fnum);

	/* INDENT-OFF */
	#ifdef __cplusplus
	}
	#endif /* __cplusplus */
	/* INDENT-ON */
	#endif /* QB_LOG_H_DEFINED */
	diff --git a/lib/log.c b/lib/log.c
	index 3336af9..b6eb3ce 100644
	--- a/lib/log.c
	+++ b/lib/log.c
	@@ -1,1116 +1,1125 @@
	/*
	* Copyright (C) 2011 Red Hat, Inc.
	*
	* All rights reserved.
	*
	* Author: Angus Salkeld <asalkeld@redhat.com>
	*
	* libqb is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Lesser General Public License as published by
	* the Free Software Foundation, either version 2.1 of the License, or
	* (at your option) any later version.
	*
	* libqb is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public License
	* along with libqb. If not, see <http://www.gnu.org/licenses/>.
	*/
	#include "os_base.h"
	#include <ctype.h>
	#ifdef HAVE_LINK_H
	#include <link.h>
	#endif /* HAVE_LINK_H */
	#include <stdarg.h>
	#include <pthread.h>
	#ifdef HAVE_DLFCN_H
	#include <dlfcn.h>
	#endif /* HAVE_DLFCN_H */
	#include <stdarg.h>
	#include <string.h>

	#include <qb/qbdefs.h>
	#include <qb/qblist.h>
	#include <qb/qblog.h>
	#include <qb/qbutil.h>
	#include <qb/qbarray.h>
	#include "log_int.h"
	#include "util_int.h"
	#include <regex.h>

	static struct qb_log_target conf[QB_LOG_TARGET_MAX];
	static uint32_t conf_active_max = 0;
	static int32_t in_logger = QB_FALSE;
	static int32_t logger_inited = QB_FALSE;
	static pthread_rwlock_t _listlock;
	static qb_log_filter_fn _custom_filter_fn = NULL;

	static QB_LIST_DECLARE(dlnames);
	static QB_LIST_DECLARE(tags_head);
	static QB_LIST_DECLARE(callsite_sections);

	struct dlname {
	char *dln_name;
	struct qb_list_head list;
	};

	struct callsite_section {
	struct qb_log_callsite *start;
	struct qb_log_callsite *stop;
	struct qb_list_head list;
	};

	static int32_t _log_target_enable(struct qb_log_target *t);
	static void _log_target_disable(struct qb_log_target *t);
	static void _log_filter_apply(struct callsite_section *sect,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority);
	static void _log_filter_apply_to_cs(struct qb_log_callsite *cs,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority);

	/* deprecated method of getting internal log messages */
	static qb_util_log_fn_t old_internal_log_fn = NULL;
	void
	qb_util_set_log_function(qb_util_log_fn_t fn)
	{
	old_internal_log_fn = fn;
	}

	static void
	_log_free_filter(struct qb_log_filter *flt)
	{
	if (flt->regex) {
	regfree(flt->regex);
	}
	free(flt->regex);
	free(flt->text);
	free(flt);
	}

	static int32_t
	_cs_matches_filter_(struct qb_log_callsite *cs,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority,
	uint8_t low_priority)
	{
	int32_t match = QB_FALSE;
	const char *offset = NULL;
	const char *next = NULL;

	if (cs->priority > low_priority \|\|
	cs->priority < high_priority) {
	return QB_FALSE;
	}
	if (strcmp(text, "*") == 0) {
	return QB_TRUE;
	}

	switch (type) {
	case QB_LOG_FILTER_FILE:
	case QB_LOG_FILTER_FUNCTION:
	next = text;
	do {
	char token[500];
	offset = next;
	next = strchrnul(offset, ',');
	snprintf(token, 499, "%.*s", (int)(next - offset), offset);

	if (type == QB_LOG_FILTER_FILE) {
	match = (strcmp(cs->filename, token) == 0) ? 1 : 0;
	} else {
	match = (strcmp(cs->function, token) == 0) ? 1 : 0;
	}
	if (!match && next[0] != 0) {
	next++;
	}

	} while (match == QB_FALSE && next != NULL && next[0] != 0);
	break;
	case QB_LOG_FILTER_FILE_REGEX:
	next = next ? next : cs->filename;
	case QB_LOG_FILTER_FUNCTION_REGEX:
	next = next ? next : cs->function;
	case QB_LOG_FILTER_FORMAT_REGEX:
	next = next ? next : cs->format;

	if (regex == NULL) {
	return QB_FALSE;
	}
	match = regexec(regex, next, 0, NULL, 0);
	if (match == 0) {
	match = QB_TRUE;
	} else {
	match = QB_FALSE;
	}
	break;
	case QB_LOG_FILTER_FORMAT:
	if (strstr(cs->format, text)) {
	match = QB_TRUE;
	}
	break;
	}

	return match;
	}

	/**
	* @internal
	* @brief Format a log message into a string buffer
	*
	* @param[out] str Destination buffer to contain formatted string
	* @param[in] cs Callsite containing format to use
	* @param[in] ap Variable arguments for format
	*/
	+#ifdef HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT
	+/* suppress suggestion that we currently can do nothing better about
	+ as the format specification is hidden in cs argument */
	+#pragma GCC diagnostic push
	+#pragma GCC diagnostic ignored "-Wsuggest-attribute=format"
	+#endif
	static inline void
	cs_format(char str, struct qb_log_callsite cs, va_list ap)
	{
	va_list ap_copy;
	int len;

	va_copy(ap_copy, ap);
	len = vsnprintf(str, QB_LOG_MAX_LEN, cs->format, ap_copy);
	va_end(ap_copy);
	if (len > QB_LOG_MAX_LEN) {
	len = QB_LOG_MAX_LEN;
	}
	if (str[len - 1] == '\n') {
	str[len - 1] = '\0';
	}
	}
	+#ifdef HAVE_GCC_SUGGEST_ATTRIBUTE_FORMAT
	+#pragma GCC diagnostic pop
	+#endif

	void
	qb_log_real_va_(struct qb_log_callsite *cs, va_list ap)
	{
	int32_t found_threaded = QB_FALSE;
	struct qb_log_target *t;
	struct timespec tv;
	int32_t pos;
	int32_t formatted = QB_FALSE;
	char buf[QB_LOG_MAX_LEN];
	char *str = buf;
	va_list ap_copy;

	if (in_logger \|\| cs == NULL) {
	return;
	}
	in_logger = QB_TRUE;

	if (old_internal_log_fn &&
	qb_bit_is_set(cs->tags, QB_LOG_TAG_LIBQB_MSG_BIT)) {
	if (formatted == QB_FALSE) {
	cs_format(str, cs, ap);
	formatted = QB_TRUE;
	}
	qb_do_extended(str, QB_TRUE,
	old_internal_log_fn(cs->filename, cs->lineno,
	cs->priority, str));
	}

	qb_util_timespec_from_epoch_get(&tv);

	/*
	* 1 if we can find a threaded target that needs this log then post it
	* 2 foreach non-threaded target call it's logger function
	*/
	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if ((t->state == QB_LOG_STATE_ENABLED)
	&& qb_bit_is_set(cs->targets, pos)) {
	if (t->threaded) {
	if (!found_threaded) {
	found_threaded = QB_TRUE;
	if (formatted == QB_FALSE) {
	cs_format(str, cs, ap);
	formatted = QB_TRUE;
	}
	}

	} else if (t->vlogger) {
	va_copy(ap_copy, ap);
	t->vlogger(t->pos, cs, tv.tv_sec, ap_copy);
	va_end(ap_copy);

	} else if (t->logger) {
	if (formatted == QB_FALSE) {
	cs_format(str, cs, ap);
	formatted = QB_TRUE;
	}
	qb_do_extended(str, t->extended,
	t->logger(t->pos, cs, tv.tv_sec, str));
	}
	}
	}

	if (found_threaded) {
	qb_log_thread_log_post(cs, tv.tv_sec, str);
	}
	in_logger = QB_FALSE;
	}

	void
	qb_log_real_(struct qb_log_callsite *cs, ...)
	{
	va_list ap;

	va_start(ap, cs);
	qb_log_real_va_(cs, ap);
	va_end(ap);
	}

	void
	qb_log_thread_log_write(struct qb_log_callsite *cs,
	time_t timestamp, const char *buffer)
	{
	struct qb_log_target *t;
	int32_t pos;

	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if ((t->state == QB_LOG_STATE_ENABLED) && t->threaded
	&& qb_bit_is_set(cs->targets, t->pos)) {
	qb_do_extended(buffer, t->extended,
	t->logger(t->pos, cs, timestamp, buffer));
	}
	}
	}

	struct qb_log_callsite*
	qb_log_callsite_get(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno,
	uint32_t tags)
	{
	struct qb_log_target *t;
	struct qb_log_filter *flt;
	struct qb_log_callsite *cs;
	int32_t new_dcs = QB_FALSE;
	struct qb_list_head *f_item;
	int32_t pos;

	if (!logger_inited) {
	return NULL;
	}

	cs = qb_log_dcs_get(&new_dcs, function, filename,
	format, priority, lineno, tags);
	if (cs == NULL) {
	return NULL;
	}

	if (new_dcs) {
	pthread_rwlock_rdlock(&_listlock);
	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if (t->state != QB_LOG_STATE_ENABLED) {
	continue;
	}
	qb_list_for_each(f_item, &t->filter_head) {
	flt = qb_list_entry(f_item, struct qb_log_filter, list);
	_log_filter_apply_to_cs(cs, t->pos, flt->conf, flt->type,
	flt->text, flt->regex, flt->high_priority,
	flt->low_priority);
	}
	}
	if (tags == 0) {
	qb_list_for_each(f_item, &tags_head) {
	flt = qb_list_entry(f_item, struct qb_log_filter, list);
	_log_filter_apply_to_cs(cs, flt->new_value, flt->conf, flt->type,
	flt->text, flt->regex, flt->high_priority,
	flt->low_priority);
	}
	} else {
	cs->tags = tags;
	}
	if (_custom_filter_fn) {
	_custom_filter_fn(cs);
	}
	pthread_rwlock_unlock(&_listlock);
	} else if (cs->tags != tags) {
	cs->tags = tags;
	if (_custom_filter_fn) {
	_custom_filter_fn(cs);
	}
	}
	return cs;
	}

	void
	qb_log_from_external_source_va(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno, uint32_t tags, va_list ap)
	{
	struct qb_log_callsite *cs;

	if (!logger_inited) {
	return;
	}

	cs = qb_log_callsite_get(function, filename,
	format, priority, lineno, tags);
	qb_log_real_va_(cs, ap);
	}

	void
	qb_log_from_external_source(const char *function,
	const char *filename,
	const char *format,
	uint8_t priority,
	uint32_t lineno, uint32_t tags, ...)
	{
	struct qb_log_callsite *cs;
	va_list ap;

	if (!logger_inited) {
	return;
	}

	cs = qb_log_callsite_get(function, filename,
	format, priority, lineno, tags);
	va_start(ap, tags);
	qb_log_real_va_(cs, ap);
	va_end(ap);
	}

	int32_t
	qb_log_callsites_register(struct qb_log_callsite *_start,
	struct qb_log_callsite *_stop)
	{
	struct callsite_section *sect;
	struct qb_log_callsite *cs;
	struct qb_log_target *t;
	struct qb_log_filter *flt;
	int32_t pos;

	if (_start == NULL \|\| _stop == NULL) {
	return -EINVAL;
	}

	pthread_rwlock_rdlock(&_listlock);
	qb_list_for_each_entry(sect, &callsite_sections, list) {
	if (sect->start == _start \|\| sect->stop == _stop) {
	pthread_rwlock_unlock(&_listlock);
	return -EEXIST;
	}
	}
	pthread_rwlock_unlock(&_listlock);

	sect = calloc(1, sizeof(struct callsite_section));
	if (sect == NULL) {
	return -ENOMEM;
	}
	sect->start = _start;
	sect->stop = _stop;
	qb_list_init(&sect->list);

	pthread_rwlock_wrlock(&_listlock);
	qb_list_add(&sect->list, &callsite_sections);

	/*
	* Now apply the filters on these new callsites
	*/
	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	if (t->state != QB_LOG_STATE_ENABLED) {
	continue;
	}
	qb_list_for_each_entry(flt, &t->filter_head, list) {
	_log_filter_apply(sect, t->pos, flt->conf,
	flt->type, flt->text, flt->regex,
	flt->high_priority, flt->low_priority);
	}
	}
	qb_list_for_each_entry(flt, &tags_head, list) {
	_log_filter_apply(sect, flt->new_value, flt->conf,
	flt->type, flt->text, flt->regex,
	flt->high_priority, flt->low_priority);
	}
	pthread_rwlock_unlock(&_listlock);
	if (_custom_filter_fn) {
	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	_custom_filter_fn(cs);
	}
	}
	}
	/* qb_log_callsites_dump_sect(sect); */

	return 0;
	}

	static void
	qb_log_callsites_dump_sect(struct callsite_section *sect)
	{
	struct qb_log_callsite *cs;

	printf(" start %p - stop %p\n", sect->start, sect->stop);
	printf("filename lineno targets tags\n");
	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	printf("%12s %6d %16d %16d\n", cs->filename, cs->lineno,
	cs->targets, cs->tags);
	}
	}
	}

	void
	qb_log_callsites_dump(void)
	{
	struct callsite_section *sect;
	int32_t l;

	pthread_rwlock_rdlock(&_listlock);
	l = qb_list_length(&callsite_sections);
	printf("Callsite Database [%d]\n", l);
	printf("---------------------\n");
	qb_list_for_each_entry(sect, &callsite_sections, list) {
	qb_log_callsites_dump_sect(sect);
	}
	pthread_rwlock_unlock(&_listlock);
	}

	static int32_t
	_log_filter_exists(struct qb_list_head *list_head,
	enum qb_log_filter_type type,
	const char *text,
	uint8_t high_priority,
	uint8_t low_priority,
	uint32_t new_value)
	{
	struct qb_log_filter *flt;

	qb_list_for_each_entry(flt, list_head, list) {
	if (flt->type == type &&
	flt->high_priority == high_priority &&
	flt->low_priority == low_priority &&
	flt->new_value == new_value &&
	strcmp(flt->text, text) == 0) {
	return QB_TRUE;
	}
	}
	return QB_FALSE;
	}

	static int32_t
	_log_filter_store(uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	uint8_t high_priority,
	uint8_t low_priority,
	struct qb_log_filter **new)
	{
	struct qb_log_filter *flt;
	struct qb_list_head *iter;
	struct qb_list_head *next;
	struct qb_list_head *list_head;

	switch (c) {
	case QB_LOG_FILTER_ADD:
	case QB_LOG_FILTER_REMOVE:
	case QB_LOG_FILTER_CLEAR_ALL:
	list_head = &conf[t].filter_head;
	break;

	case QB_LOG_TAG_SET:
	case QB_LOG_TAG_CLEAR:
	case QB_LOG_TAG_CLEAR_ALL:
	list_head = &tags_head;
	break;
	default:
	return -ENOSYS;
	}

	if (c == QB_LOG_FILTER_ADD \|\| c == QB_LOG_TAG_SET) {
	if (text == NULL) {
	return -EINVAL;
	}
	if (_log_filter_exists(list_head, type, text,
	high_priority, low_priority, t)) {
	return -EEXIST;
	}
	flt = calloc(1, sizeof(struct qb_log_filter));
	if (flt == NULL) {
	return -ENOMEM;
	}
	qb_list_init(&flt->list);
	flt->conf = c;
	flt->type = type;
	flt->text = strdup(text);
	if (flt->text == NULL) {
	_log_free_filter(flt);
	return -ENOMEM;
	}

	if (type == QB_LOG_FILTER_FUNCTION_REGEX \|\|
	type == QB_LOG_FILTER_FILE_REGEX \|\|
	type == QB_LOG_FILTER_FORMAT_REGEX) {
	int res;

	flt->regex = calloc(1, sizeof(regex_t));
	if (flt->regex == NULL) {
	_log_free_filter(flt);
	return -ENOMEM;
	}
	res = regcomp(flt->regex, flt->text, 0);
	if (res) {
	_log_free_filter(flt);
	return -EINVAL;
	}
	}
	flt->high_priority = high_priority;
	flt->low_priority = low_priority;
	flt->new_value = t;
	qb_list_add_tail(&flt->list, list_head);
	if (new) {
	*new = flt;
	}
	} else if (c == QB_LOG_FILTER_REMOVE \|\| c == QB_LOG_TAG_CLEAR) {
	qb_list_for_each_safe(iter, next, list_head) {
	flt = qb_list_entry(iter, struct qb_log_filter, list);
	if (flt->type == type &&
	flt->low_priority <= low_priority &&
	flt->high_priority >= high_priority &&
	(strcmp(flt->text, text) == 0 \|\|
	strcmp("*", text) == 0)) {
	qb_list_del(iter);
	_log_free_filter(flt);
	return 0;
	}
	}

	} else if (c == QB_LOG_FILTER_CLEAR_ALL \|\| c == QB_LOG_TAG_CLEAR_ALL) {
	qb_list_for_each_safe(iter, next, list_head) {
	flt = qb_list_entry(iter, struct qb_log_filter, list);
	qb_list_del(iter);
	_log_free_filter(flt);
	}
	}
	return 0;
	}

	static void
	_log_filter_apply(struct callsite_section *sect,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority)
	{
	struct qb_log_callsite *cs;

	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	_log_filter_apply_to_cs(cs, t, c, type, text, regex,
	high_priority, low_priority);
	}
	}
	}

	/* #define _QB_FILTER_DEBUGGING_ 1 */
	static void
	_log_filter_apply_to_cs(struct qb_log_callsite *cs,
	uint32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text,
	regex_t *regex,
	uint8_t high_priority, uint8_t low_priority)
	{

	if (c == QB_LOG_FILTER_CLEAR_ALL) {
	qb_bit_clear(cs->targets, t);
	return;
	} else if (c == QB_LOG_TAG_CLEAR_ALL) {
	cs->tags = 0;
	return;
	}

	if (_cs_matches_filter_(cs, type, text, regex, high_priority, low_priority)) {
	#ifdef _QB_FILTER_DEBUGGING_
	uint32_t old_targets = cs->targets;
	uint32_t old_tags = cs->tags;
	#endif /* _QB_FILTER_DEBUGGING_ */
	if (c == QB_LOG_FILTER_ADD) {
	qb_bit_set(cs->targets, t);
	} else if (c == QB_LOG_FILTER_REMOVE) {
	qb_bit_clear(cs->targets, t);
	} else if (c == QB_LOG_TAG_SET) {
	cs->tags = t;
	} else if (c == QB_LOG_TAG_CLEAR) {
	cs->tags = 0;
	}
	#ifdef _QB_FILTER_DEBUGGING_
	if (old_targets != cs->targets) {
	printf("targets: %s:%u value(%d) %d -> %d\n",
	cs->filename, cs->lineno, t,
	old_targets, cs->targets);
	}
	if (old_tags != cs->tags) {
	printf("tags: %s:%u value(%d) %d -> %d\n",
	cs->filename, cs->lineno, t, old_tags, cs->tags);
	}
	#endif /* _QB_FILTER_DEBUGGING_ */
	}
	}

	int32_t
	qb_log_filter_ctl2(int32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type, const char * text,
	uint8_t high_priority, uint8_t low_priority)
	{
	struct qb_log_filter *new_flt = NULL;
	regex_t *regex = NULL;
	struct callsite_section *sect;
	int32_t rc;

	if (!logger_inited) {
	return -EINVAL;
	}

	if (c == QB_LOG_FILTER_ADD \|\|
	c == QB_LOG_FILTER_CLEAR_ALL \|\|
	c == QB_LOG_FILTER_REMOVE) {
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return -EBADF;
	}
	}

	if (text == NULL \|\|
	low_priority < high_priority \|\|
	type > QB_LOG_FILTER_FORMAT_REGEX \|\|
	c > QB_LOG_TAG_CLEAR_ALL) {
	return -EINVAL;
	}
	pthread_rwlock_rdlock(&_listlock);
	rc = _log_filter_store(t, c, type, text, high_priority, low_priority, &new_flt);
	if (rc < 0) {
	pthread_rwlock_unlock(&_listlock);
	return rc;
	}

	if (new_flt && new_flt->regex) {
	regex = new_flt->regex;
	}
	qb_list_for_each_entry(sect, &callsite_sections, list) {
	_log_filter_apply(sect, t, c, type, text, regex, high_priority, low_priority);
	}
	pthread_rwlock_unlock(&_listlock);
	return 0;
	}

	int32_t
	qb_log_filter_fn_set(qb_log_filter_fn fn)
	{
	struct callsite_section *sect;
	struct qb_log_callsite *cs;

	if (!logger_inited) {
	return -EINVAL;
	}
	_custom_filter_fn = fn;
	if (_custom_filter_fn == NULL) {
	return 0;
	}

	qb_list_for_each_entry(sect, &callsite_sections, list) {
	for (cs = sect->start; cs < sect->stop; cs++) {
	if (cs->lineno > 0) {
	_custom_filter_fn(cs);
	}
	}
	}
	return 0;
	}

	int32_t
	qb_log_filter_ctl(int32_t t, enum qb_log_filter_conf c,
	enum qb_log_filter_type type,
	const char *text, uint8_t priority)
	{
	return qb_log_filter_ctl2(t, c, type, text, LOG_EMERG, priority);
	}

	#ifdef QB_HAVE_ATTRIBUTE_SECTION
	/* Some platforms (eg. FreeBSD 10+) don't support calling dlopen() from
	* within a dl_iterate_phdr() callback; so save all of the dlpi_names to
	* a list and iterate over them afterwards. */
	static int32_t
	_log_so_walk_callback(struct dl_phdr_info info, size_t size, void data)
	{
	struct dlname *dlname;

	if (strlen(info->dlpi_name) > 0) {
	dlname = calloc(1, sizeof(struct dlname));
	if (!dlname)
	return 0;
	dlname->dln_name = strdup(info->dlpi_name);
	qb_list_add_tail(&dlname->list, &dlnames);
	}

	return 0;
	}

	static void
	_log_so_walk_dlnames(void)
	{
	struct dlname *dlname;
	struct qb_list_head *iter;
	struct qb_list_head *next;

	void *handle;
	void *start;
	void *stop;
	const char *error;

	qb_list_for_each_safe(iter, next, &dlnames) {
	dlname = qb_list_entry(iter, struct dlname, list);

	handle = dlopen(dlname->dln_name, RTLD_LAZY);
	error = dlerror();
	if (!handle \|\| error) {
	qb_log(LOG_ERR, "%s", error);
	goto done;
	}

	start = dlsym(handle, "__start___verbose");
	error = dlerror();
	if (error) {
	goto done;
	}

	stop = dlsym(handle, "__stop___verbose");
	error = dlerror();
	if (error) {
	goto done;

	} else {
	qb_log_callsites_register(start, stop);
	}
	done:
	if (handle)
	dlclose(handle);
	qb_list_del(iter);
	if (dlname->dln_name)
	free(dlname->dln_name);
	free(dlname);
	}
	}
	#endif /* QB_HAVE_ATTRIBUTE_SECTION */

	static void
	_log_target_state_set(struct qb_log_target *t, enum qb_log_target_state s)
	{
	int32_t i;
	int32_t a_set = QB_FALSE;
	int32_t u_set = QB_FALSE;

	t->state = s;

	for (i = 31; i >= 0; i--) {
	if (!a_set && conf[i].state == QB_LOG_STATE_ENABLED) {
	a_set = QB_TRUE;
	conf_active_max = i;
	}
	if (!u_set && conf[i].state != QB_LOG_STATE_UNUSED) {
	u_set = QB_TRUE;
	}
	}
	}

	void
	qb_log_init(const char *name, int32_t facility, uint8_t priority)
	{
	int32_t i;

	i = pthread_rwlock_init(&_listlock, NULL);
	assert(i == 0);
	qb_log_format_init();

	for (i = 0; i < QB_LOG_TARGET_MAX; i++) {
	conf[i].pos = i;
	conf[i].debug = QB_FALSE;
	conf[i].file_sync = QB_FALSE;
	conf[i].extended = QB_TRUE;
	conf[i].state = QB_LOG_STATE_UNUSED;
	(void)strlcpy(conf[i].name, name, PATH_MAX);
	conf[i].facility = facility;
	qb_list_init(&conf[i].filter_head);
	}

	qb_log_dcs_init();
	#ifdef QB_HAVE_ATTRIBUTE_SECTION
	qb_log_callsites_register(__start___verbose, __stop___verbose);
	dl_iterate_phdr(_log_so_walk_callback, NULL);
	_log_so_walk_dlnames();
	#endif /* QB_HAVE_ATTRIBUTE_SECTION */

	conf[QB_LOG_STDERR].state = QB_LOG_STATE_DISABLED;
	conf[QB_LOG_BLACKBOX].state = QB_LOG_STATE_DISABLED;
	conf[QB_LOG_STDOUT].state = QB_LOG_STATE_DISABLED;

	logger_inited = QB_TRUE;
	(void)qb_log_syslog_open(&conf[QB_LOG_SYSLOG]);
	_log_target_state_set(&conf[QB_LOG_SYSLOG], QB_LOG_STATE_ENABLED);
	(void)qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD,
	QB_LOG_FILTER_FILE, "*", priority);
	}

	void
	qb_log_fini(void)
	{
	struct qb_log_target *t;
	struct qb_log_filter *flt;
	struct callsite_section *s;
	struct qb_list_head *iter;
	struct qb_list_head *iter2;
	struct qb_list_head *next;
	struct qb_list_head *next2;
	int32_t pos;

	if (!logger_inited) {
	return;
	}
	logger_inited = QB_FALSE;
	qb_log_thread_stop();
	pthread_rwlock_destroy(&_listlock);

	for (pos = 0; pos <= conf_active_max; pos++) {
	t = &conf[pos];
	_log_target_disable(t);
	qb_list_for_each_safe(iter2, next2, &t->filter_head) {
	flt = qb_list_entry(iter2, struct qb_log_filter, list);
	qb_list_del(iter2);
	_log_free_filter(flt);
	}
	}
	qb_log_format_fini();
	qb_log_dcs_fini();
	qb_list_for_each_safe(iter, next, &callsite_sections) {
	s = qb_list_entry(iter, struct callsite_section, list);
	qb_list_del(iter);
	free(s);
	}
	qb_list_for_each_safe(iter, next, &tags_head) {
	flt = qb_list_entry(iter, struct qb_log_filter, list);
	qb_list_del(iter);
	_log_free_filter(flt);
	}
	}

	struct qb_log_target *
	qb_log_target_alloc(void)
	{
	int32_t i;
	for (i = 0; i < QB_LOG_TARGET_MAX; i++) {
	if (conf[i].state == QB_LOG_STATE_UNUSED) {
	_log_target_state_set(&conf[i], QB_LOG_STATE_DISABLED);
	return &conf[i];
	}
	}
	return NULL;
	}

	void
	qb_log_target_free(struct qb_log_target *t)
	{
	(void)qb_log_filter_ctl(t->pos, QB_LOG_FILTER_CLEAR_ALL,
	QB_LOG_FILTER_FILE, NULL, 0);
	t->debug = QB_FALSE;
	t->filename[0] = '\0';
	qb_log_format_set(t->pos, NULL);
	_log_target_state_set(t, QB_LOG_STATE_UNUSED);
	}

	struct qb_log_target *
	qb_log_target_get(int32_t pos)
	{
	return &conf[pos];
	}

	void *
	qb_log_target_user_data_get(int32_t t)
	{
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	errno = -EBADF;
	return NULL;
	}

	return conf[t].instance;
	}

	int32_t
	qb_log_target_user_data_set(int32_t t, void *user_data)
	{
	if (!logger_inited) {
	return -EINVAL;
	}
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return -EBADF;
	}

	conf[t].instance = user_data;
	return 0;
	}

	int32_t
	qb_log_custom_open(qb_log_logger_fn log_fn,
	qb_log_close_fn close_fn,
	qb_log_reload_fn reload_fn, void *user_data)
	{
	struct qb_log_target *t;

	t = qb_log_target_alloc();
	if (t == NULL) {
	return -errno;
	}

	t->instance = user_data;
	snprintf(t->filename, PATH_MAX, "custom-%d", t->pos);

	t->logger = log_fn;
	t->vlogger = NULL;
	t->reload = reload_fn;
	t->close = close_fn;

	return t->pos;
	}

	void
	qb_log_custom_close(int32_t t)
	{
	struct qb_log_target *target;

	if (!logger_inited) {
	return;
	}
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return;
	}

	target = qb_log_target_get(t);

	if (target->close) {
	in_logger = QB_TRUE;
	target->close(t);
	in_logger = QB_FALSE;
	}
	qb_log_target_free(target);
	}

	static int32_t
	_log_target_enable(struct qb_log_target *t)
	{
	int32_t rc = 0;

	if (t->state == QB_LOG_STATE_ENABLED) {
	return 0;
	}
	if (t->pos == QB_LOG_STDERR \|\|
	t->pos == QB_LOG_STDOUT) {
	rc = qb_log_stderr_open(t);
	} else if (t->pos == QB_LOG_SYSLOG) {
	rc = qb_log_syslog_open(t);
	} else if (t->pos == QB_LOG_BLACKBOX) {
	rc = qb_log_blackbox_open(t);
	}
	if (rc == 0) {
	_log_target_state_set(t, QB_LOG_STATE_ENABLED);
	}
	return rc;
	}

	static void
	_log_target_disable(struct qb_log_target *t)
	{
	if (t->state != QB_LOG_STATE_ENABLED) {
	return;
	}
	_log_target_state_set(t, QB_LOG_STATE_DISABLED);
	if (t->close) {
	in_logger = QB_TRUE;
	t->close(t->pos);
	in_logger = QB_FALSE;
	}
	}

	int32_t
	qb_log_ctl(int32_t t, enum qb_log_conf c, int32_t arg)
	{
	int32_t rc = 0;
	int32_t need_reload = QB_FALSE;

	if (!logger_inited) {
	return -EINVAL;
	}
	if (t < 0 \|\| t >= QB_LOG_TARGET_MAX \|\|
	conf[t].state == QB_LOG_STATE_UNUSED) {
	return -EBADF;
	}
	switch (c) {
	case QB_LOG_CONF_ENABLED:
	if (arg) {
	rc = _log_target_enable(&conf[t]);
	} else {
	_log_target_disable(&conf[t]);
	}
	break;
	case QB_LOG_CONF_STATE_GET:
	rc = conf[t].state;
	break;
	case QB_LOG_CONF_FACILITY:
	conf[t].facility = arg;
	if (t == QB_LOG_SYSLOG) {
	need_reload = QB_TRUE;
	}
	break;
	case QB_LOG_CONF_FILE_SYNC:
	conf[t].file_sync = arg;
	break;
	case QB_LOG_CONF_PRIORITY_BUMP:
	conf[t].priority_bump = arg;
	break;
	case QB_LOG_CONF_SIZE:
	if (t == QB_LOG_BLACKBOX) {
	if (arg <= 0) {
	return -EINVAL;
	}
	conf[t].size = arg;
	need_reload = QB_TRUE;
	} else {
	return -ENOSYS;
	}
	break;
	case QB_LOG_CONF_THREADED:
	conf[t].threaded = arg;
	break;
	case QB_LOG_CONF_EXTENDED:
	conf[t].extended = arg;
	break;

	default:
	rc = -EINVAL;
	}
	if (rc == 0 && need_reload && conf[t].reload) {
	in_logger = QB_TRUE;
	conf[t].reload(t);
	in_logger = QB_FALSE;
	}
	return rc;
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Feb 25, 9:45 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1459238
Default Alt Text: (64 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions