UTF-8

zlog @ 5de0ce76

-Subproject commit 5de0ce7607ae70a8a654f6fb050a5d25d96a6728

zlog/src/README.md

+# zlog
+
+zlog is a reliable, high-performance, thread safe, flexible, clear-model, pure C logging library.
+
+Actually, in the C world there was NO good logging library for applications like logback in java or log4cxx in c++.
+Using printf can work, but can not be redirected or reformatted easily. syslog is slow and is designed for system use.
+So I wrote zlog.
+It is faster, safer and more powerful than log4c. So it can be widely used.
+
+## 1. Install
+
+Downloads: <https://github.com/HardySimpson/zlog/releases>
+
+```bash
+tar -zxvf zlog-latest-stable.tar.gz
+cd zlog-latest-stable/
+make 
+sudo make install
+```
+
+Or
+
+```bash
+make PREFIX=/usr/local/
+sudo make PREFIX=/usr/local/ install
+```
+
+PREFIX indicates the installation destination for zlog. After installation, refresh your dynamic linker to make sure
+your program can find zlog library.
+
+```bash
+$ sudo vi /etc/ld.so.conf
+/usr/local/lib
+$ sudo ldconfig
+```
+
+Before running a real program, make sure libzlog.so is in the directory where the system's dynamic lib loader can find
+it. The command metioned above are for linux. Other systems will need a similar set of actions.
+
+## 2. Configuration file
+
+There are 3 important concepts in zlog: categories, formats and rules.
+
+Categories specify different kinds of log entries. In the zlog source code, category is a `zlog_category_t *` variable.
+In your program, different categories for the log entries will distinguish them from each other.
+
+Formats describe log patterns, such as: with or without time stamp, source file, source line.
+
+Rules consist of category, level, output file (or other channel) and format. In brief, if the category string in a rule
+in the configuration file equals the name of a category variable in the source, then they match. Still there is complex
+match range of category. Rule decouples variable conditions. For example, log4j must specify a level for each logger(or
+inherit from father logger). That's not convenient when each grade of logger has its own level for output(child logger
+output at the level of debug, when father logger output at the level of error)
+
+Now create a configuration file. The function zlog_init takes the files path as its only argument.
+
+```bash
+$ cat /etc/zlog.conf
+
+[formats]
+simple = "%m%n"
+[rules]
+my_cat.DEBUG    >stdout; simple
+```
+
+In the configuration file log messages in the category `my_cat` and a level of DEBUG or higher are output to standard
+output, with the format of simple `%m - usermessage %n - newline`. If you want to direct out to a file and limit the
+files maximum size, use this configuration
+
+```config
+my_cat.DEBUG            "/var/log/aa.log", 1M; simple
+```
+
+## 3. Using zlog API in C source file
+
+### 3.1 Sample code
+
+```bash
+$ vi test_hello.c
+
+#include <stdio.h> 
+
+#include "zlog.h"
+
+int main(int argc, char** argv)
+{
+    int rc;
+    zlog_category_t *c;
+
+    rc = zlog_init("/etc/zlog.conf");
+    if (rc) {
+    printf("init failed\n");
+    return -1;
+    }
+
+    c = zlog_get_category("my_cat");
+    if (!c) {
+    printf("get cat fail\n");
+    zlog_fini();
+    return -2;
+    }
+
+    zlog_info(c, "hello, zlog");
+
+    zlog_fini();
+
+    return 0;
+}
+```
+
+### 3.2 Compile, and run it
+
+```bash
+$ cc -c -o test_hello.o test_hello.c -I/usr/local/include
+$ cc -o test_hello test_hello.o -L/usr/local/lib -lzlog -lpthread
+$ ./test_hello
+hello, zlog
+```
+
+## 4. Advanced Usage
+
+* syslog model, better than log4j model
+* log format customization
+* multiple output destinations including static file path, dynamic file path, stdout, stderr, syslog, user-defined
+  output
+* runtime manually or automatically refresh configure(safely)
+* high-performance, 250'000 logs/second on my laptop, about 1000 times faster than syslog(3) with rsyslogd
+* user-defined log level
+* thread-safe and process-safe log file rotation
+* microsecond accuracy
+* dzlog, a default category log API for easy use
+* MDC, a log4j style key-value map
+* self debuggable, can output zlog's self debug&error log at runtime
+* No external dependencies, just based on a POSIX system and a C99 compliant vsnprintf.
+
+## 5. Reference
+
+* Homepage: <http://hardysimpson.github.io/zlog>
+* Downloads: <https://github.com/HardySimpson/zlog/releases>
+* Author's Email: <HardySimpson1984@gmail.com>
+* Auto tools version: <https://github.com/bmanojlovic/zlog>
+* CMake verion: <https://github.com/lisongmin/zlog>
+* Windows version: <https://github.com/lopsd07/WinZlog>

zlog/src/buf.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/category.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#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/src/category.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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 && (zlog_env_conf->level > lv || !((a_category->level_bitmap[lv/8] >> (7 - lv % 8)) & 0x01))
+
+#endif

zlog/src/category_table.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/category_table.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/conf.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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 cfg_ptr[MAXLEN_CFG_LINE*MAXLINES_NO];
+	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;
+	char log_level[MAXLEN_CFG_LINE + 1];
+	int level;
+} zlog_conf_t;
+
+extern zlog_conf_t * zlog_env_conf;
+
+zlog_conf_t *zlog_conf_new(const char *config);
+zlog_conf_t *zlog_conf_new_from_string(const char *config_string);
+void zlog_conf_del(zlog_conf_t * a_conf);
+void zlog_conf_profile(zlog_conf_t * a_conf, int flag);
+
+#endif

zlog/src/event.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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 <stdint.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"
+#ifdef _WIN32
+#include <Winsock2.h>
+#endif
+
+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 = (pthread_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/src/event.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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_utc_sec;
+	struct tm time_utc;
+	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/src/fmacros.h

+#ifndef __zlog_fmacro_h
+#define __zlog_fmacro_h
+
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+
+#if defined(__linux__) || defined(__OpenBSD__) || defined(_AIX)
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 700
+#endif
+#ifndef _XOPEN_SOURCE_EXTENDED
+#define _XOPEN_SOURCE_EXTENDED
+#endif
+#if defined(__APPLE__)
+#include <AvailabilityMacros.h>
+#else
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#endif
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE
+#endif
+#endif
+
+#ifndef _LARGEFILE_SOURCE
+#define _LARGEFILE_SOURCE
+#endif
+
+#ifndef _LARGEFILE_SOURCE
+#define _LARGEFILE_SOURCE
+#endif
+#ifndef _FILE_OFFSET_BITS
+#define _FILE_OFFSET_BITS 64
+#endif
+
+#endif

zlog/src/format.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/format.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/level.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#ifndef _WIN32
+#include <syslog.h>
+#else
+#include "zlog_win.h"
+#endif
+
+#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/src/level.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/level_list.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#ifdef _WIN32
+#include "zlog_win.h"
+#endif
+
+#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/src/level_list.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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 output 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/src/lockfile.c

+/**
+ * =============================================================================
+ *
+ * \file lockfile.c
+ * \breif
+ * \version 1.0
+ * \date 2013-07-07 11:55:38
+ * \author  Song min.Li (Li), lisongmin@126.com
+ * \copyright Copyright (c) 2013, skybility
+ *
+ * =============================================================================
+ */
+
+#include "lockfile.h"
+#include "zc_profile.h"
+
+LOCK_FD lock_file(char* path) {
+    if (!path || strlen(path) <= 0) {
+        return INVALID_LOCK_FD;
+    }
+#ifdef _WIN32
+    LOCK_FD fd = CreateFile(path, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (fd == INVALID_LOCK_FD) {
+        DWORD err = GetLastError();
+        zc_error("lock file error : %d ", err);
+    }
+#else
+    LOCK_FD fd = open(path, O_RDWR | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
+    if (fd == INVALID_LOCK_FD) {
+        zc_error("lock file error : %s ", strerror(errno));
+    }
+#endif
+    return fd;
+}
+
+bool unlock_file(LOCK_FD fd) {
+    if (fd == INVALID_LOCK_FD) {
+        return true;
+    }
+#ifdef _WIN32
+    bool ret = CloseHandle(fd);
+    if (ret == false) {
+        DWORD err = GetLastError();
+        zc_error("unlock file error : %d ", err);
+    }
+#else
+    bool ret = close(fd) == 0;
+    if (ret == false) {
+        zc_error("unlock file error : %s ", strerror(errno));
+    }
+#endif
+    return ret;
+}

zlog/src/lockfile.h

+/**
+ * =============================================================================
+ *
+ * \file lockfile.h
+ * \breif
+ * \version 1.0
+ * \date 2013-07-07 12:34:20
+ * \author  Song min.Li (Li), lisongmin@126.com
+ * \copyright Copyright (c) 2013, skybility
+ *
+ * =============================================================================
+ */
+
+#ifndef __ZLOG_LOCK_FILE_H__
+#define __ZLOG_LOCK_FILE_H__
+
+#ifdef _WIN32
+#include <Windows.h>
+#include <WinBase.h>
+#define LOCK_FD         HANDLE
+#define INVALID_LOCK_FD INVALID_HANDLE_VALUE
+#else //_WIN32
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#define LOCK_FD         int
+#define INVALID_LOCK_FD -1
+#endif
+#include <stdbool.h>
+
+/**
+ * lock file.
+ */
+LOCK_FD lock_file(char* path);
+
+/**
+ * unlock file.
+ */
+bool unlock_file(LOCK_FD fd);
+
+#endif //__ZLOG_LOCK_FILE_H__

zlog/src/mdc.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/mdc.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/record.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#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/src/record.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/record_table.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/record_table.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/rotater.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __zlog_rotater_h
+#define __zlog_rotater_h
+
+#include "zc_defs.h"
+#include "lockfile.h"
+
+typedef struct zlog_rotater_s {
+	pthread_mutex_t lock_mutex;
+	char *lock_file;
+	LOCK_FD 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/src/rule.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @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 output 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/src/spec.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/thread.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/thread.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/version.h

+#define ZLOG_VERSION "1.2.12"

zlog/src/zc_arraylist.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zc_arraylist.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zc_defs.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zc_hashtable.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zc_hashtable.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zc_profile.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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;
+
+	time(&tt);
+#ifdef _WIN32
+	struct tm *local_time;
+	local_time = localtime(&tt);
+	strftime(time_str, time_str_size, "%m-%d %H:%M:%S", local_time);
+#else
+	struct tm local_time;
+	localtime_r(&tt, &local_time);
+	strftime(time_str, time_str_size, "%m-%d %H:%M:%S", &local_time);
+#endif
+
+	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/src/zc_profile.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zc_util.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string.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/src/zc_util.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#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/src/zc_xplatform.h

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#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 MAXLINES_NO 128
+
+#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
+#elif defined(_WIN32)
+#define zlog_fstat _fstat
+#define zlog_stat _stat
+#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/src/zlog-chk-conf.c

+/* Copyright (c) Hardy Simpson
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#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/src/zlog_win.c

+
+#include <string.h>
+#include <windows.h>
+#include <stdio.h>
+#include <tchar.h>
+#include <stdlib.h>
+#include "zlog_win.h"
+#include <errno.h>
+#include <unistd.h>
+
+int gethostname_w(char *name, size_t len)
+{
+	int rc = gethostname(name, len);
+	DWORD newlen = len;
+
+	if (rc != 0) {
+		rc = GetComputerNameEx(ComputerNameDnsHostname, name, &newlen);
+		if (rc == 0) {
+			sprintf(name, "noname");
+		}
+	}
+	return 0;
+}
+#ifndef strcasecmp
+int strcasecmp (const char *sz1, const char *sz2)
+{
+  return stricmp (sz1, sz2);
+}
+#endif
+#ifndef localtime_r
+struct tm *localtime_r(const time_t *timep, struct tm *result)
+{
+    struct tm *ret = localtime(timep);
+    if (ret)
+    {
+        memcpy(result, ret, sizeof(struct tm));
+    }
+    return ret;
+}
+#endif
+int fsync (int fd)
+{
+    HANDLE h = (HANDLE) _get_osfhandle (fd);
+    DWORD err;
+
+    if (h == INVALID_HANDLE_VALUE)
+    {
+        errno = EBADF;
+        return -1;
+    }
+
+    if (!FlushFileBuffers (h))
+    {
+        /* Translate some Windows errors into rough approximations of Unix
+         * errors.  MSDN is useless as usual - in this case it doesn't
+         * document the full range of errors.
+         */
+        err = GetLastError ();
+        switch (err)
+        {
+        /* eg. Trying to fsync a tty. */
+        case ERROR_INVALID_HANDLE:
+            errno = EINVAL;
+            break;
+        default:
+            errno = EIO;
+        }
+        return -1;
+    }
+    return 0;
+}
+
+void setenv(const char *name, const char *value)
+{
+#ifdef HAVE_SETENV
+    setenv(name, value, 1);
+#else
+    int len = strlen(value)+1+strlen(value)+1;
+    char *str = malloc(len);
+    sprintf(str, "%s=%s", name, value);
+    putenv(str);
+#endif
+}

zlog/src/zlog_win.h

+#ifndef _ZLOG_WIN_H_
+#define _ZLOG_WIN_H_
+
+#include <time.h>
+
+#ifndef localtime_r
+struct tm *localtime_r(const time_t *timep, struct tm *result);
+#endif
+#ifndef strcasecmp
+int strcasecmp (const char *sz1, const char *sz2);
+#endif
+int fsync (int fd);
+void setenv(const char *name, const char *value);
+int gethostname_w(char *name, size_t len);
+
+/* facility codes */
+#define	LOG_KERN	(0<<3)	/* kernel messages */
+#define	LOG_USER	(1<<3)	/* random user-level messages */
+#define	LOG_MAIL	(2<<3)	/* mail system */
+#define	LOG_DAEMON	(3<<3)	/* system daemons */
+#define	LOG_AUTH	(4<<3)	/* authorization messages */
+#define	LOG_SYSLOG	(5<<3)	/* messages generated internally by syslogd */
+#define	LOG_LPR		(6<<3)	/* line printer subsystem */
+#define	LOG_NEWS	(7<<3)	/* network news subsystem */
+#define	LOG_UUCP	(8<<3)	/* UUCP subsystem */
+#define	LOG_CRON	(9<<3)	/* clock daemon */
+#define	LOG_AUTHPRIV	(10<<3)	/* authorization messages (private) */
+				/* Facility #10 clashes in DEC UNIX, where */
+				/* it's defined as LOG_MEGASAFE for AdvFS  */
+				/* event logging.                          */
+#define	LOG_FTP		(11<<3)	/* ftp daemon */
+#define	LOG_NTP		(12<<3)	/* NTP subsystem */
+#define	LOG_SECURITY	(13<<3) /* security subsystems (firewalling, etc.) */
+#define	LOG_CONSOLE	(14<<3) /* /dev/console output */
+
+	/* other codes through 15 reserved for system use */
+#define	LOG_LOCAL0	(16<<3)	/* reserved for local use */
+#define	LOG_LOCAL1	(17<<3)	/* reserved for local use */
+#define	LOG_LOCAL2	(18<<3)	/* reserved for local use */
+#define	LOG_LOCAL3	(19<<3)	/* reserved for local use */
+#define	LOG_LOCAL4	(20<<3)	/* reserved for local use */
+#define	LOG_LOCAL5	(21<<3)	/* reserved for local use */
+#define	LOG_LOCAL6	(22<<3)	/* reserved for local use */
+#define	LOG_LOCAL7	(23<<3)	/* reserved for local use */
+
+/*
+ * Option flags for openlog.
+ *
+ * LOG_ODELAY no longer does anything.
+ * LOG_NDELAY is the inverse of what it used to be.
+ */
+#define	LOG_PID		0x01	/* log the pid with each message */
+#define	LOG_CONS	0x02	/* log on the console if errors in sending */
+#define	LOG_ODELAY	0x04	/* delay open until first syslog() (default) */
+#define	LOG_NDELAY	0x08	/* don't delay open */
+#define	LOG_NOWAIT	0x10	/* don't wait for console forks: DEPRECATED */
+#define	LOG_PERROR	0x20	/* log to stderr as well */
+
+/*
+ * priorities/facilities are encoded into a single 32-bit quantity, where the
+ * bottom 3 bits are the priority (0-7) and the top 28 bits are the facility
+ * (0-big number).  Both the priorities and the facilities map roughly
+ * one-to-one to strings in the syslogd(8) source code.  This mapping is
+ * included in this file.
+ *
+ * priorities (these are ordered)
+ */
+#define	LOG_EMERG	0	/* system is unusable */
+#define	LOG_ALERT	1	/* action must be taken immediately */
+#define	LOG_CRIT	2	/* critical conditions */
+#define	LOG_ERR		3	/* error conditions */
+#define	LOG_WARNING	4	/* warning conditions */
+#define	LOG_NOTICE	5	/* normal but significant condition */
+#define	LOG_INFO	6	/* informational */
+#define	LOG_DEBUG	7	/* debug-level messages */
+
+#define	LOG_PRIMASK	0x07	/* mask to extract priority part (internal) */
+				/* extract priority */
+#define	LOG_PRI(p)	((p) & LOG_PRIMASK)
+#define	LOG_MAKEPRI(fac, pri)	((fac) | (pri))
+
+#endif
\ No newline at end of file