lwtarantool 0.0.2

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/CMakeLists.txt

@@ -0,0 +1,69 @@
+#============================================================================#
+# build flags
+#============================================================================#
+
+# default flags
+if (${CMAKE_BUILD_TYPE} STREQUAL "None")
+    set (tntrpl_cflags "-std=gnu99")
+else()
+    set (tntrpl_cflags "-std=gnu99 -Wall -Wextra")
+    set (tntrpl_cflags "${tntrpl_cflags} -Wno-sign-compare -Wno-strict-aliasing")
+endif()
+
+# Only add -Werror if it's a debug build, done by developers.
+if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+    set (tntrpl_cflags "${tntrpl_cflags} -Werror")
+endif()
+
+#============================================================================#
+# Build tnt rpl project
+#============================================================================#
+
+#
+# source files
+#
+
+set (tntrpl_sources tnt_log.c tnt_dir.c tnt_xlog.c tnt_snapshot.c tnt_rpl.c
+     ${CMAKE_SOURCE_DIR}/third_party/crc32.c)
+
+#----------------------------------------------------------------------------#
+# Builds
+#----------------------------------------------------------------------------#
+
+# Here we manage to build static/dynamic libraries ourselves,
+# do not use the top level settings.
+string(REPLACE "-static-libgcc" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+string(REPLACE "-static" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+
+if (CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_COMPILER_IS_CLANG)
+    set (tnt_cflags "${tnt_cflags} -static-libgcc")
+endif()
+
+#
+# Static library
+#
+
+project(tntrpl)
+add_library(tntrpl STATIC ${tntrpl_sources})
+set_target_properties(tntrpl PROPERTIES COMPILE_FLAGS "${tntrpl_cflags}")
+set_target_properties(tntrpl PROPERTIES VERSION ${LIBTNT_VERSION} SOVERSION ${LIBTNT_SOVERSION})
+set_target_properties(tntrpl PROPERTIES OUTPUT_NAME "tarantoolrpl")
+
+#
+# Shared library
+#
+
+project(tntrpl_shared)
+add_library(tntrpl_shared SHARED ${tntrpl_sources})
+target_link_libraries(tntrpl_shared tnt_shared tntnet_shared)
+set_target_properties(tntrpl_shared PROPERTIES OUTPUT_NAME tntrpl)
+set_target_properties(tntrpl_shared PROPERTIES COMPILE_FLAGS "${tntrpl_cflags}")
+set_target_properties(tntrpl_shared PROPERTIES VERSION ${LIBTNT_VERSION} SOVERSION ${LIBTNT_SOVERSION})
+set_target_properties(tntrpl_shared PROPERTIES OUTPUT_NAME "tarantoolrpl")
+
+#----------------------------------------------------------------------------#
+# Install
+#----------------------------------------------------------------------------#
+
+install (TARGETS tntrpl ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install (TARGETS tntrpl_shared LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_dir.c

@@ -0,0 +1,173 @@
+
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <limits.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+
+#include <tarantool.h>
+#include <tnt_dir.h>
+
+void tnt_dir_init(struct tnt_dir *d, enum tnt_dir_type type) {
+	d->type = type;
+	d->path = NULL;
+	d->files = NULL;
+	d->count = 0;
+}
+
+void tnt_dir_free(struct tnt_dir *d) {
+	if (d->path) {
+		tnt_mem_free(d->path);
+		d->path = NULL;
+	}
+	if (d->files) {
+		int i = 0;
+		while (i < d->count) {
+			if (d->files[i].name)
+				tnt_mem_free(d->files[i].name);
+			i++;
+		}
+		tnt_mem_free(d->files);
+		d->files = NULL;
+	}
+}
+
+static int tnt_dir_put(struct tnt_dir *d,
+		       int *top, char *name, uint64_t lsn)
+{
+	if (d->count == *top) {
+		*top = (*top == 0) ? 128 : *top * 2;
+		d->files = tnt_mem_realloc(d->files, sizeof(struct tnt_dir_file) * *top);
+		if (d->files == NULL)
+			return -1;
+	}
+	struct tnt_dir_file *current = &d->files[d->count];
+	current->lsn = lsn;
+	current->name = (char*)tnt_mem_dup(name);
+	if (current->name == NULL)
+		return -1;
+	d->count++;
+	return 0;
+}
+
+static int tnt_dir_cmp(const void *_a, const void *_b) {
+	const struct tnt_dir_file *a = _a;
+	const struct tnt_dir_file *b = _b;
+	if (a->lsn == b->lsn)
+		return 0;
+	return (a->lsn > b->lsn) ? 1: -1;
+}
+
+int tnt_dir_scan(struct tnt_dir *d, char *path) {
+	d->path = tnt_mem_dup(path);
+	if (d->path == NULL)
+		return -1;
+	DIR *dir = opendir(d->path);
+	if (dir == NULL)
+		goto error;
+
+	struct dirent *dep = NULL;
+	struct dirent de;
+	int rc, top = 0;
+	while ((rc = readdir_r(dir, &de, &dep)) == 0) {
+		if (dep == NULL)
+			break;
+		if (strcmp(de.d_name, ".") == 0 ||
+		    strcmp(de.d_name, "..") == 0)
+			continue;
+
+		char *ext = strchr(de.d_name, '.');
+		if (ext == NULL)
+			continue;
+
+		switch (d->type) {
+		case TNT_DIR_XLOG:
+			if (strcmp(ext, ".xlog") != 0)
+				continue;
+			break;
+		case TNT_DIR_SNAPSHOT:
+			if (strcmp(ext, ".snap") != 0)
+				continue;
+			break;
+		}
+
+		uint64_t lsn = strtoll(de.d_name, &ext, 10);
+		if (lsn == LLONG_MAX || lsn == LLONG_MIN)
+			continue;
+
+		rc = tnt_dir_put(d, &top, de.d_name, lsn);
+		if (rc == -1)
+			goto error;
+	}
+	if (rc != 0)
+		goto error;
+
+	qsort(d->files, d->count, sizeof(struct tnt_dir_file),
+	      tnt_dir_cmp);
+
+	closedir(dir);
+	return 0;
+error:
+	if (dir)
+		closedir(dir);
+	tnt_dir_free(d);
+	return -1;
+}
+
+int tnt_dir_match_gt(struct tnt_dir *d, uint64_t *out) {
+	if (d->count == 0)
+		return -1;
+	*out = d->files[d->count -1].lsn;
+	return 0;
+}
+
+int tnt_dir_match_inc(struct tnt_dir *d, uint64_t lsn, uint64_t *out) {
+	if (d->count == 0)
+		return -1;
+	int current = 0;
+	int count = d->count;
+	while (count > 1) {
+		if (d->files[current].lsn <= lsn && lsn <= d->files[current + 1].lsn) {
+			*out = d->files[current].lsn;
+			return 0;
+		}
+		current++;
+		count--;
+	}
+	*out = d->files[current].lsn;
+	return 0;
+}

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_dir.h

@@ -0,0 +1,58 @@
+#ifndef TNT_DIR_H_INCLUDED
+#define TNT_DIR_H_INCLUDED
+
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+enum tnt_dir_type {
+	TNT_DIR_XLOG,
+	TNT_DIR_SNAPSHOT
+};
+
+struct tnt_dir_file {
+	uint64_t lsn;
+	char *name;
+};
+
+struct tnt_dir {
+	enum tnt_dir_type type;
+	char *path;
+	struct tnt_dir_file *files;
+	int count;
+};
+
+void tnt_dir_init(struct tnt_dir *d, enum tnt_dir_type type);
+void tnt_dir_free(struct tnt_dir *d);
+
+int tnt_dir_scan(struct tnt_dir *d, char *path);
+
+int tnt_dir_match_gt(struct tnt_dir *d, uint64_t *out);
+int tnt_dir_match_inc(struct tnt_dir *d, uint64_t lsn, uint64_t *out);
+
+#endif

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_log.c

@@ -0,0 +1,329 @@
+
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <third_party/crc32.h>
+
+#include <tarantool.h>
+#include <tnt_log.h>
+
+enum tnt_log_type tnt_log_guess(char *file) {
+	if (file == NULL)
+		return TNT_LOG_XLOG;
+	char *ext = strrchr(file, '.');
+	if (ext == NULL)
+		return TNT_LOG_NONE;
+	if (strcasecmp(ext, ".snap") == 0)
+		return TNT_LOG_SNAPSHOT;
+	if (strcasecmp(ext, ".xlog") == 0)
+		return TNT_LOG_XLOG;
+	return TNT_LOG_NONE;
+}
+
+inline static int
+tnt_log_seterr(struct tnt_log *l, enum tnt_log_error e) {
+	l->error = e;
+	if (e == TNT_LOG_ESYSTEM)
+		l->errno_ = errno;
+	return -1;
+}
+
+const uint32_t tnt_log_marker_v11 = 0xba0babed;
+const uint32_t tnt_log_marker_eof_v11 = 0x10adab1e;
+
+inline static int
+tnt_log_eof(struct tnt_log *l, char *data) {
+	uint32_t marker = 0;
+	if (data)
+		tnt_mem_free(data);
+	/* checking eof condition */
+	if (ftello(l->fd) == l->offset + sizeof(tnt_log_marker_eof_v11)) {
+		fseeko(l->fd, l->offset, SEEK_SET);
+		if (fread(&marker, sizeof(marker), 1, l->fd) != 1)
+			return tnt_log_seterr(l, TNT_LOG_ESYSTEM);
+		else
+		if (marker != tnt_log_marker_eof_v11)
+			return tnt_log_seterr(l, TNT_LOG_ECORRUPT);
+		l->offset = ftello(l->fd);
+	}
+	/* eof */
+	return 1;
+}
+
+static int tnt_log_read(struct tnt_log *l, char **buf, uint32_t *size)
+{
+	/* current record offset (before marker) */
+	l->current_offset = ftello(l->fd);
+
+	/* reading marker */
+	char *data = NULL;
+	uint32_t marker = 0;
+	if (fread(&marker, sizeof(marker), 1, l->fd) != 1)
+		return tnt_log_eof(l, data);
+
+	/* seeking for marker if necessary */
+	while (marker != tnt_log_marker_v11) {
+		int c = fgetc(l->fd);
+		if (c == EOF)
+			return tnt_log_eof(l, data);
+		marker = marker >> 8 | ((uint32_t) c & 0xff) <<
+			 (sizeof(marker) * 8 - 8);
+	}
+
+	/* reading header */
+	if (fread(&l->current.hdr, sizeof(l->current.hdr), 1, l->fd) != 1)
+		return tnt_log_eof(l, data);
+
+	/* updating offset */
+	l->offset = ftello(l->fd);
+
+	/* checking header crc, starting from lsn */
+	uint32_t crc32_hdr =
+		crc32c(0, (unsigned char*)&l->current.hdr + sizeof(uint32_t),
+		       sizeof(struct tnt_log_header_v11) -
+		       sizeof(uint32_t));
+	if (crc32_hdr != l->current.hdr.crc32_hdr)
+		return tnt_log_seterr(l, TNT_LOG_ECORRUPT);
+
+	/* allocating memory and reading data */
+	data = tnt_mem_alloc(l->current.hdr.len);
+	if (data == NULL)
+		return tnt_log_seterr(l, TNT_LOG_EMEMORY);
+	if (fread(data, l->current.hdr.len, 1, l->fd) != 1)
+		return tnt_log_eof(l, data);
+
+	/* checking data crc */
+	uint32_t crc32_data = crc32c(0, (unsigned char*)data, l->current.hdr.len);
+	if (crc32_data != l->current.hdr.crc32_data) {
+		tnt_mem_free(data);
+		return tnt_log_seterr(l, TNT_LOG_ECORRUPT);
+	}
+
+	*buf = data;
+	*size = l->current.hdr.len;
+	return 0;
+}
+
+static int
+tnt_log_process_xlog(struct tnt_log *l, char *buf, uint32_t size,
+		     union tnt_log_value *value)
+{
+	(void)size;
+	/* copying row data */
+	memcpy(&l->current.row, buf, sizeof(l->current.row));
+
+	/* preparing pseudo iproto header */
+	struct tnt_header hdr_iproto;
+	hdr_iproto.type = l->current.row.op;
+	hdr_iproto.len = l->current.hdr.len - sizeof(l->current.row);
+	hdr_iproto.reqid = 0;
+
+	/* deserializing operation */
+	tnt_request_init(&value->r);
+	size_t off = 0;
+	int rc = tnt_request(&value->r,
+			     buf + sizeof(l->current.row),
+			     l->current.hdr.len - sizeof(l->current.row),
+			     &off,
+			     &hdr_iproto);
+
+	/* in case of not completed request or parsing error */
+	if (rc != 0)
+		return tnt_log_seterr(l, TNT_LOG_ECORRUPT);
+	return 0;
+}
+
+static int
+tnt_log_process_snapshot(struct tnt_log *l, char *buf, uint32_t size,
+		         union tnt_log_value *value)
+{
+	(void)size;
+
+	/* freeing previously allocated tuple */
+	tnt_tuple_free(&value->t);
+
+	/* copying snapshot row data */
+	memcpy(&l->current.row_snap, buf, sizeof(l->current.row_snap));
+
+	/* reading and validating tuple */
+	struct tnt_tuple *tu =
+		tnt_tuple_set_as(&value->t, buf + sizeof(l->current.row_snap),
+				 l->current.row_snap.data_size,
+				 l->current.row_snap.tuple_size);
+	if (tu == NULL)
+		return tnt_log_seterr(l, TNT_LOG_ECORRUPT);
+
+	return (tu) ? 0 : -1;
+}
+
+struct tnt_log_row*
+tnt_log_next_to(struct tnt_log *l, union tnt_log_value *value) {
+	char *buf = NULL;
+	uint32_t size = 0;
+	int rc = l->read(l, &buf, &size);
+	if (rc != 0)
+		return NULL;
+	rc = l->process(l, buf, size, value);
+	if (rc != 0) {
+		tnt_mem_free(buf);
+		return NULL;
+	}
+	if (l->type == TNT_LOG_XLOG) {
+		tnt_request_setorigin(&value->r, buf, size);
+	} else {
+		tnt_mem_free(buf);
+	}
+	return &l->current;
+}
+
+struct tnt_log_row *tnt_log_next(struct tnt_log *l) {
+	return tnt_log_next_to(l, &l->current_value);
+}
+
+inline static int
+tnt_log_open_err(struct tnt_log *l, enum tnt_log_error e) {
+	tnt_log_seterr(l, e);
+	tnt_log_close(l);
+	return -1;
+}
+
+enum tnt_log_error
+tnt_log_open(struct tnt_log *l, char *file, enum tnt_log_type type)
+{
+	char filetype[32];
+	char version[32];
+	char *rc, *magic = "\0";
+	l->type = type;
+	/* trying to open file */
+	if (file) {
+		l->fd = fopen(file, "r");
+		if (l->fd == NULL)
+			return tnt_log_open_err(l, TNT_LOG_ESYSTEM);
+	} else {
+		l->fd = stdin;
+	}
+	/* reading xlog filetype */
+	rc = fgets(filetype, sizeof(filetype), l->fd);
+	if (rc == NULL)
+		return tnt_log_open_err(l, TNT_LOG_ESYSTEM);
+	/* reading log version */
+	rc = fgets(version, sizeof(version), l->fd);
+	if (rc == NULL)
+		return tnt_log_open_err(l, TNT_LOG_ESYSTEM);
+	/* checking file type and setting read/process
+	 * interfaces */
+	l->read = tnt_log_read;
+	switch (type) {
+	case TNT_LOG_XLOG:
+		magic = TNT_LOG_MAGIC_XLOG;
+		l->process = tnt_log_process_xlog;
+		break;
+	case TNT_LOG_SNAPSHOT:
+		magic = TNT_LOG_MAGIC_SNAP;
+		l->process = tnt_log_process_snapshot;
+		break;
+	case TNT_LOG_NONE:
+		break;
+	}
+	if (strcmp(filetype, magic))
+		return tnt_log_open_err(l, TNT_LOG_ETYPE);
+	/* checking version */
+	if (strcmp(version, TNT_LOG_VERSION))
+		return tnt_log_open_err(l, TNT_LOG_EVERSION);
+	for (;;) {
+		char buf[256];
+		rc = fgets(buf, sizeof(buf), l->fd);
+		if (rc == NULL)
+			return tnt_log_open_err(l, TNT_LOG_EFAIL);
+		if (strcmp(rc, "\n") == 0 || strcmp(rc, "\r\n") == 0)
+			break;
+	}
+	/* getting current offset */
+	l->offset = ftello(l->fd);
+	l->current_offset = 0;
+	memset(&l->current_value, 0, sizeof(l->current_value));
+	return 0;
+}
+
+void tnt_log_close(struct tnt_log *l) {
+	if (l->fd && l->fd != stdin)
+		fclose(l->fd);
+	l->fd = NULL;
+}
+
+int tnt_log_seek(struct tnt_log *l, off_t offset) 
+{
+	l->offset = offset;
+	return fseeko(l->fd, offset, SEEK_SET);
+}
+
+enum tnt_log_error tnt_log_error(struct tnt_log *l) {
+	return l->error;
+}
+
+struct tnt_log_error_desc {
+	enum tnt_log_error type;
+	char *desc;
+};
+
+static struct tnt_log_error_desc tnt_log_error_list[] = 
+{
+	{ TNT_LOG_EOK,      "ok"                                },
+	{ TNT_LOG_EFAIL,    "fail"                              },
+	{ TNT_LOG_EMEMORY,  "memory allocation failed"          },
+	{ TNT_LOG_ETYPE,    "file type mismatch"                },
+	{ TNT_LOG_EVERSION, "file version mismatch"             },
+	{ TNT_LOG_ECORRUPT, "file crc failed or bad eof marker" },
+	{ TNT_LOG_ESYSTEM,  "system error"                      },
+	{ TNT_LOG_LAST,      NULL                               }
+};
+
+char *tnt_log_strerror(struct tnt_log *l) {
+	if (l->error == TNT_LOG_ESYSTEM) {
+		static char msg[256];
+		snprintf(msg, sizeof(msg), "%s (errno: %d)",
+			 strerror(l->errno_),
+			 l->errno_);
+		return msg;
+	}
+	return tnt_log_error_list[(int)l->error].desc;
+}
+
+int tnt_log_errno(struct tnt_log *l) {
+	return l->errno_;
+}