Adding upstream version 3.8.1.upstream/3.8.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1574 insertions, 0 deletions

diff --git a/contrib/libucl/lua_ucl.c b/contrib/libucl/lua_ucl.c
new file mode 100644
index 0000000..c2e39c4
--- /dev/null
+++ b/contrib/libucl/lua_ucl.c
@@ -0,0 +1,1574 @@
+/* Copyright (c) 2014, Vsevolod Stakhov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *       * Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *       * Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED ''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 AUTHOR 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.
+ */
+
+/**
+ * @file lua ucl bindings
+ */
+
+#include "ucl.h"
+#include "ucl_internal.h"
+#include "lua_ucl.h"
+#include <strings.h>
+
+/***
+ * @module ucl
+ * This lua module allows to parse objects from strings and to store data into
+ * ucl objects. It uses `libucl` C library to parse and manipulate with ucl objects.
+ * @example
+local ucl = require("ucl")
+
+local parser = ucl.parser()
+local res,err = parser:parse_string('{key=value}')
+
+if not res then
+	print('parser error: ' .. err)
+else
+	local obj = parser:get_object()
+	local got = ucl.to_format(obj, 'json')
+endif
+
+local table = {
+  str = 'value',
+  num = 100500,
+  null = ucl.null,
+  func = function ()
+    return 'huh'
+  end
+}
+
+print(ucl.to_format(table, 'ucl'))
+-- Output:
+--[[
+num = 100500;
+str = "value";
+null = null;
+func = "huh";
+--]]
+ */
+
+#define PARSER_META "ucl.parser.meta"
+#define EMITTER_META "ucl.emitter.meta"
+#define NULL_META "ucl.null.meta"
+#define OBJECT_META "ucl.object.meta"
+#define UCL_OBJECT_TYPE_META "ucl.type.object"
+#define UCL_ARRAY_TYPE_META "ucl.type.array"
+#define UCL_IMPL_ARRAY_TYPE_META "ucl.type.impl_array"
+
+static int ucl_object_lua_push_array (lua_State *L, const ucl_object_t *obj, int flags);
+static int ucl_object_lua_push_scalar (lua_State *L, const ucl_object_t *obj, int flags);
+static int ucl_object_push_lua_common (lua_State *L, const ucl_object_t *obj, int flags);
+static ucl_object_t* ucl_object_lua_fromtable (lua_State *L, int idx, ucl_string_flags_t flags);
+static ucl_object_t* ucl_object_lua_fromelt (lua_State *L, int idx, ucl_string_flags_t flags);
+
+static void *ucl_null;
+
+struct _rspamd_lua_text {
+	const char *start;
+	unsigned int len;
+	unsigned int flags;
+};
+
+enum lua_ucl_push_flags {
+	LUA_UCL_DEFAULT_FLAGS = 0,
+	LUA_UCL_ALLOW_ARRAY = (1u << 0u),
+	LUA_UCL_CONVERT_NIL = (1u << 1u),
+};
+
+/**
+ * Push a single element of an object to lua
+ * @param L
+ * @param key
+ * @param obj
+ */
+static void
+ucl_object_lua_push_element (lua_State *L, const char *key,
+		const ucl_object_t *obj, int flags)
+{
+	lua_pushstring (L, key);
+	ucl_object_push_lua_common (L, obj, flags|LUA_UCL_ALLOW_ARRAY);
+	lua_settable (L, -3);
+}
+
+static void
+lua_ucl_userdata_dtor (void *ud)
+{
+	struct ucl_lua_funcdata *fd = (struct ucl_lua_funcdata *)ud;
+
+	luaL_unref (fd->L, LUA_REGISTRYINDEX, fd->idx);
+	if (fd->ret != NULL) {
+		free (fd->ret);
+	}
+	free (fd);
+}
+
+static const char *
+lua_ucl_userdata_emitter (void *ud)
+{
+	struct ucl_lua_funcdata *fd = (struct ucl_lua_funcdata *)ud;
+	const char *out = "";
+
+	lua_rawgeti (fd->L, LUA_REGISTRYINDEX, fd->idx);
+
+	lua_pcall (fd->L, 0, 1, 0);
+	out = lua_tostring (fd->L, -1);
+
+	if (out != NULL) {
+		/* We need to store temporary string in a more appropriate place */
+		if (fd->ret) {
+			free (fd->ret);
+		}
+		fd->ret = strdup (out);
+	}
+
+	lua_settop (fd->L, 0);
+
+	return fd->ret;
+}
+
+/**
+ * Push a single object to lua
+ * @param L
+ * @param obj
+ * @return
+ */
+static int
+ucl_object_lua_push_object (lua_State *L, const ucl_object_t *obj,
+		int flags)
+{
+	const ucl_object_t *cur;
+	ucl_object_iter_t it = NULL;
+
+	if ((flags & LUA_UCL_ALLOW_ARRAY) && obj->next != NULL) {
+		/* Actually we need to push this as an array */
+		return ucl_object_lua_push_array (L, obj, flags);
+	}
+
+	lua_createtable (L, 0, obj->len);
+	it = NULL;
+
+	while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
+		ucl_object_lua_push_element (L, ucl_object_key (cur), cur, flags);
+	}
+
+	luaL_getmetatable (L, UCL_OBJECT_TYPE_META);
+	lua_setmetatable (L, -2);
+
+	return 1;
+}
+
+/**
+ * Push an array to lua as table indexed by integers
+ * @param L
+ * @param obj
+ * @return
+ */
+static int
+ucl_object_lua_push_array (lua_State *L, const ucl_object_t *obj, int flags)
+{
+	const ucl_object_t *cur;
+	ucl_object_iter_t it;
+	int i = 1, nelt = 0;
+
+	if (obj->type == UCL_ARRAY) {
+		nelt = obj->len;
+		it = ucl_object_iterate_new (obj);
+		lua_createtable (L, nelt, 0);
+
+		while ((cur = ucl_object_iterate_safe (it, true))) {
+			ucl_object_push_lua (L, cur, (flags & ~LUA_UCL_ALLOW_ARRAY));
+			lua_rawseti (L, -2, i);
+			i ++;
+		}
+
+		luaL_getmetatable (L, UCL_ARRAY_TYPE_META);
+		lua_setmetatable (L, -2);
+
+		ucl_object_iterate_free (it);
+	}
+	else {
+		/* Optimize allocation by preallocation of table */
+		LL_FOREACH (obj, cur) {
+			nelt ++;
+		}
+
+		lua_createtable (L, nelt, 0);
+
+		LL_FOREACH (obj, cur) {
+			ucl_object_push_lua (L, cur, (flags & ~LUA_UCL_ALLOW_ARRAY));
+			lua_rawseti (L, -2, i);
+			i ++;
+		}
+
+		luaL_getmetatable (L, UCL_IMPL_ARRAY_TYPE_META);
+		lua_setmetatable (L, -2);
+	}
+
+	return 1;
+}
+
+/**
+ * Push a simple object to lua depending on its actual type
+ */
+static int
+ucl_object_lua_push_scalar (lua_State *L, const ucl_object_t *obj,
+		int flags)
+{
+	struct ucl_lua_funcdata *fd;
+
+	if ((flags & LUA_UCL_ALLOW_ARRAY) && obj->next != NULL) {
+		/* Actually we need to push this as an array */
+		return ucl_object_lua_push_array (L, obj, flags);
+	}
+
+	switch (obj->type) {
+	case UCL_BOOLEAN:
+		lua_pushboolean (L, ucl_obj_toboolean (obj));
+		break;
+	case UCL_STRING:
+		lua_pushlstring (L, ucl_obj_tostring (obj), obj->len);
+		break;
+	case UCL_INT:
+#if LUA_VERSION_NUM >= 501
+		lua_pushinteger (L, ucl_obj_toint (obj));
+#else
+		lua_pushnumber (L, ucl_obj_toint (obj));
+#endif
+		break;
+	case UCL_FLOAT:
+	case UCL_TIME:
+		lua_pushnumber (L, ucl_obj_todouble (obj));
+		break;
+	case UCL_NULL:
+		if (flags & LUA_UCL_CONVERT_NIL) {
+			lua_pushboolean (L, false);
+		}
+		else {
+			lua_getfield (L, LUA_REGISTRYINDEX, "ucl.null");
+		}
+		break;
+	case UCL_USERDATA:
+		fd = (struct ucl_lua_funcdata *)obj->value.ud;
+		lua_rawgeti (L, LUA_REGISTRYINDEX, fd->idx);
+		break;
+	default:
+		lua_pushnil (L);
+		break;
+	}
+
+	return 1;
+}
+
+static int
+ucl_object_push_lua_common (lua_State *L, const ucl_object_t *obj, int flags)
+{
+	switch (obj->type) {
+	case UCL_OBJECT:
+		return ucl_object_lua_push_object (L, obj, flags);
+	case UCL_ARRAY:
+		return ucl_object_lua_push_array (L, obj, flags);
+	default:
+		return ucl_object_lua_push_scalar (L, obj, flags);
+	}
+}
+
+/***
+ * @function ucl_object_push_lua(L, obj, allow_array)
+ * This is a `C` function to push `UCL` object as lua variable. This function
+ * converts `obj` to lua representation using the following conversions:
+ *
+ * - *scalar* values are directly presented by lua objects
+ * - *userdata* values are converted to lua function objects using `LUA_REGISTRYINDEX`,
+ * this can be used to pass functions from lua to c and vice-versa
+ * - *arrays* are converted to lua tables with numeric indicies suitable for `ipairs` iterations
+ * - *objects* are converted to lua tables with string indicies
+ * @param {lua_State} L lua state pointer
+ * @param {ucl_object_t} obj object to push
+ * @param {bool} allow_array expand implicit arrays (should be true for all but partial arrays)
+ * @return {int} `1` if an object is pushed to lua
+ */
+int
+ucl_object_push_lua (lua_State *L, const ucl_object_t *obj, bool allow_array)
+{
+	return ucl_object_push_lua_common (L, obj,
+			allow_array ? LUA_UCL_ALLOW_ARRAY : LUA_UCL_DEFAULT_FLAGS);
+}
+
+int
+ucl_object_push_lua_filter_nil (lua_State *L, const ucl_object_t *obj, bool allow_array)
+{
+	return ucl_object_push_lua_common (L, obj,
+			allow_array ? (LUA_UCL_ALLOW_ARRAY|LUA_UCL_CONVERT_NIL) :
+			(LUA_UCL_DEFAULT_FLAGS|LUA_UCL_CONVERT_NIL));
+}
+
+/**
+ * Parse lua table into object top
+ * @param L
+ * @param top
+ * @param idx
+ */
+static ucl_object_t *
+ucl_object_lua_fromtable (lua_State *L, int idx, ucl_string_flags_t flags)
+{
+	ucl_object_t *obj, *top = NULL, *cur;
+	size_t keylen;
+	const char *k;
+	bool is_array = true, is_implicit = false, found_mt = false;
+	size_t max = 0, nelts = 0;
+
+	if (idx < 0) {
+		/* For negative indicies we want to invert them */
+		idx = lua_gettop (L) + idx + 1;
+	}
+
+	/* First, we check from metatable */
+	if (luaL_getmetafield (L, idx, "class") != 0) {
+
+		if (lua_type (L, -1) == LUA_TSTRING) {
+			const char *classname = lua_tostring (L, -1);
+
+			if (strcmp (classname, UCL_OBJECT_TYPE_META) == 0) {
+				is_array = false;
+				found_mt = true;
+			} else if (strcmp (classname, UCL_ARRAY_TYPE_META) == 0) {
+				is_array = true;
+				found_mt = true;
+#if LUA_VERSION_NUM >= 502
+				max = lua_rawlen (L, idx);
+#else
+				max = lua_objlen (L, idx);
+#endif
+				nelts = max;
+			} else if (strcmp (classname, UCL_IMPL_ARRAY_TYPE_META) == 0) {
+				is_array = true;
+				is_implicit = true;
+				found_mt = true;
+#if LUA_VERSION_NUM >= 502
+				max = lua_rawlen (L, idx);
+#else
+				max = lua_objlen (L, idx);
+#endif
+				nelts = max;
+			}
+		}
+
+		lua_pop (L, 1);
+	}
+
+	if (!found_mt) {
+		/* Check for array (it is all inefficient) */
+		lua_pushnil (L);
+
+		while (lua_next (L, idx) != 0) {
+			lua_pushvalue (L, -2);
+
+			if (lua_type (L, -1) == LUA_TNUMBER) {
+				double num = lua_tonumber (L, -1);
+				if (num == (int) num) {
+					if (num > max) {
+						max = num;
+					}
+				}
+				else {
+					/* Keys are not integer */
+					is_array = false;
+				}
+			}
+			else {
+				/* Keys are not numeric */
+				is_array = false;
+			}
+
+			lua_pop (L, 2);
+			nelts ++;
+		}
+	}
+
+	/* Table iterate */
+	if (is_array) {
+		int i;
+
+		if (!is_implicit) {
+			top = ucl_object_typed_new (UCL_ARRAY);
+			ucl_object_reserve (top, nelts);
+		}
+		else {
+			top = NULL;
+		}
+
+		for (i = 1; i <= max; i ++) {
+			lua_pushinteger (L, i);
+			lua_gettable (L, idx);
+
+			obj = ucl_object_lua_fromelt (L, lua_gettop (L), flags);
+
+			if (obj != NULL) {
+				if (is_implicit) {
+					DL_APPEND (top, obj);
+				}
+				else {
+					ucl_array_append (top, obj);
+				}
+			}
+			lua_pop (L, 1);
+		}
+	}
+	else {
+		lua_pushnil (L);
+		top = ucl_object_typed_new (UCL_OBJECT);
+		ucl_object_reserve (top, nelts);
+
+		while (lua_next (L, idx) != 0) {
+			/* copy key to avoid modifications */
+			lua_pushvalue (L, -2);
+			k = lua_tolstring (L, -1, &keylen);
+			obj = ucl_object_lua_fromelt (L, lua_gettop (L) - 1, flags);
+
+			if (obj != NULL) {
+				ucl_object_insert_key (top, obj, k, keylen, true);
+
+				DL_FOREACH (obj, cur) {
+					if (cur->keylen == 0) {
+						cur->keylen = obj->keylen;
+						cur->key = obj->key;
+					}
+				}
+			}
+			lua_pop (L, 2);
+		}
+	}
+
+	return top;
+}
+
+/**
+ * Get a single element from lua to object obj
+ * @param L
+ * @param obj
+ * @param idx
+ */
+static ucl_object_t *
+ucl_object_lua_fromelt (lua_State *L, int idx, ucl_string_flags_t flags)
+{
+	int type;
+	double num;
+	ucl_object_t *obj = NULL;
+	struct ucl_lua_funcdata *fd;
+	const char *str;
+	size_t sz;
+
+	type = lua_type (L, idx);
+
+	switch (type) {
+	case LUA_TSTRING:
+		str = lua_tolstring (L, idx, &sz);
+
+		if (str) {
+			/*
+			 * ucl_object_fromstring_common has a `logic` to use strlen if sz is zero
+			 * which is totally broken...
+			 */
+			if (sz > 0) {
+				obj = ucl_object_fromstring_common(str, sz, flags);
+			}
+			else {
+				obj = ucl_object_fromstring_common("", sz, flags);
+			}
+		}
+		else {
+			obj = ucl_object_typed_new (UCL_NULL);
+		}
+		break;
+	case LUA_TNUMBER:
+		num = lua_tonumber (L, idx);
+		if (num == (int64_t)num) {
+			obj = ucl_object_fromint (num);
+		}
+		else {
+			obj = ucl_object_fromdouble (num);
+		}
+		break;
+	case LUA_TBOOLEAN:
+		obj = ucl_object_frombool (lua_toboolean (L, idx));
+		break;
+	case LUA_TUSERDATA:
+		if (lua_topointer (L, idx) == ucl_null) {
+			obj = ucl_object_typed_new (UCL_NULL);
+		}
+		else {
+			/* Assume it is a text like object */
+			struct _rspamd_lua_text *t = lua_touserdata (L, idx);
+
+			if (t) {
+				if (t->len >0) {
+					obj = ucl_object_fromstring_common(t->start, t->len, 0);
+				}
+				else {
+					obj = ucl_object_fromstring_common("", 0, 0);
+				}
+
+				/* Binary text */
+				if (t->flags & (1u << 5u)) {
+					obj->flags |= UCL_OBJECT_BINARY;
+				}
+			}
+		}
+		break;
+	case LUA_TTABLE:
+	case LUA_TFUNCTION:
+	case LUA_TTHREAD:
+		if (luaL_getmetafield (L, idx, "__gen_ucl")) {
+			if (lua_isfunction (L, -1)) {
+				lua_settop (L, 3); /* gen, obj, func */
+				lua_insert (L, 1); /* func, gen, obj */
+				lua_insert (L, 2); /* func, obj, gen */
+				lua_call(L, 2, 1);
+				obj = ucl_object_lua_fromelt (L, 1, flags);
+			}
+			lua_pop (L, 2);
+		}
+		else {
+			if (type == LUA_TTABLE) {
+				obj = ucl_object_lua_fromtable (L, idx, flags);
+			}
+			else if (type == LUA_TFUNCTION) {
+				fd = malloc (sizeof (*fd));
+				if (fd != NULL) {
+					lua_pushvalue (L, idx);
+					fd->L = L;
+					fd->ret = NULL;
+					fd->idx = luaL_ref (L, LUA_REGISTRYINDEX);
+
+					obj = ucl_object_new_userdata (lua_ucl_userdata_dtor,
+							lua_ucl_userdata_emitter, (void *)fd);
+				}
+			}
+		}
+		break;
+	}
+
+	return obj;
+}
+
+/**
+ * @function ucl_object_lua_import(L, idx)
+ * Extracts ucl object from lua variable at `idx` position,
+ * @see ucl_object_push_lua for conversion definitions
+ * @param {lua_state} L lua state machine pointer
+ * @param {int} idx index where the source variable is placed
+ * @return {ucl_object_t} new ucl object extracted from lua variable. Reference count of this object is 1,
+ * this object thus needs to be unref'ed after usage.
+ */
+ucl_object_t *
+ucl_object_lua_import (lua_State *L, int idx)
+{
+	ucl_object_t *obj;
+	int t;
+
+	t = lua_type (L, idx);
+	switch (t) {
+	case LUA_TTABLE:
+		obj = ucl_object_lua_fromtable (L, idx, UCL_STRING_RAW);
+		break;
+	default:
+		obj = ucl_object_lua_fromelt (L, idx, UCL_STRING_RAW);
+		break;
+	}
+
+	return obj;
+}
+
+/**
+ * @function ucl_object_lua_import_escape(L, idx)
+ * Extracts ucl object from lua variable at `idx` position escaping JSON strings
+ * @see ucl_object_push_lua for conversion definitions
+ * @param {lua_state} L lua state machine pointer
+ * @param {int} idx index where the source variable is placed
+ * @return {ucl_object_t} new ucl object extracted from lua variable. Reference count of this object is 1,
+ * this object thus needs to be unref'ed after usage.
+ */
+ucl_object_t *
+ucl_object_lua_import_escape (lua_State *L, int idx)
+{
+	ucl_object_t *obj;
+	int t;
+
+	t = lua_type (L, idx);
+	switch (t) {
+	case LUA_TTABLE:
+		obj = ucl_object_lua_fromtable (L, idx, UCL_STRING_ESCAPE);
+		break;
+	default:
+		obj = ucl_object_lua_fromelt (L, idx, UCL_STRING_ESCAPE);
+		break;
+	}
+
+	return obj;
+}
+
+static int
+lua_ucl_to_string (lua_State *L, const ucl_object_t *obj, enum ucl_emitter type)
+{
+	unsigned char *result;
+	size_t outlen;
+
+	result = ucl_object_emit_len (obj, type, &outlen);
+
+	if (result != NULL) {
+		lua_pushlstring (L, (const char *)result, outlen);
+		free (result);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return 1;
+}
+
+static int
+lua_ucl_parser_init (lua_State *L)
+{
+	struct ucl_parser *parser, **pparser;
+	int flags = UCL_PARSER_NO_FILEVARS;
+
+	if (lua_gettop (L) >= 1) {
+		flags = lua_tonumber (L, 1);
+	}
+
+	parser = ucl_parser_new (flags);
+	if (parser == NULL) {
+		lua_pushnil (L);
+	}
+
+	pparser = lua_newuserdata (L, sizeof (parser));
+	*pparser = parser;
+	luaL_getmetatable (L, PARSER_META);
+	lua_setmetatable (L, -2);
+
+	return 1;
+}
+
+static struct ucl_parser *
+lua_ucl_parser_get (lua_State *L, int index)
+{
+	return *((struct ucl_parser **) luaL_checkudata(L, index, PARSER_META));
+}
+
+static ucl_object_t *
+lua_ucl_object_get (lua_State *L, int index)
+{
+	return *((ucl_object_t **) luaL_checkudata(L, index, OBJECT_META));
+}
+
+static void
+lua_ucl_push_opaque (lua_State *L, ucl_object_t *obj)
+{
+	ucl_object_t **pobj;
+
+	pobj = lua_newuserdata (L, sizeof (*pobj));
+	*pobj = obj;
+	luaL_getmetatable (L, OBJECT_META);
+	lua_setmetatable (L, -2);
+}
+
+static inline enum ucl_parse_type
+lua_ucl_str_to_parse_type (const char *str)
+{
+	enum ucl_parse_type type = UCL_PARSE_UCL;
+
+	if (str != NULL) {
+		if (strcasecmp (str, "msgpack") == 0) {
+			type = UCL_PARSE_MSGPACK;
+		}
+		else if (strcasecmp (str, "sexp") == 0 ||
+				strcasecmp (str, "csexp") == 0) {
+			type = UCL_PARSE_CSEXP;
+		}
+		else if (strcasecmp (str, "auto") == 0) {
+			type = UCL_PARSE_AUTO;
+		}
+	}
+
+	return type;
+}
+
+/***
+ * @method parser:parse_file(name)
+ * Parse UCL object from file.
+ * @param {string} name filename to parse
+ * @return {bool[, string]} if res is `true` then file has been parsed successfully, otherwise an error string is also returned
+@example
+local parser = ucl.parser()
+local res,err = parser:parse_file('/some/file.conf')
+
+if not res then
+	print('parser error: ' .. err)
+else
+	-- Do something with object
+end
+ */
+static int
+lua_ucl_parser_parse_file (lua_State *L)
+{
+	struct ucl_parser *parser;
+	const char *file;
+	int ret = 2;
+
+	parser = lua_ucl_parser_get (L, 1);
+	file = luaL_checkstring (L, 2);
+
+	if (parser != NULL && file != NULL) {
+		if (ucl_parser_add_file (parser, file)) {
+			lua_pushboolean (L, true);
+			ret = 1;
+		}
+		else {
+			lua_pushboolean (L, false);
+			lua_pushstring (L, ucl_parser_get_error (parser));
+		}
+	}
+	else {
+		lua_pushboolean (L, false);
+		lua_pushstring (L, "invalid arguments");
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:register_variable(name, value)
+ * Register parser variable
+ * @param {string} name name of variable
+ * @param {string} value value of variable
+ * @return {bool} success
+@example
+local parser = ucl.parser()
+local res = parser:register_variable('CONFDIR', '/etc/foo')
+ */
+static int
+lua_ucl_parser_register_variable (lua_State *L)
+{
+	struct ucl_parser *parser;
+	const char *name, *value;
+	int ret = 2;
+
+	parser = lua_ucl_parser_get (L, 1);
+	name = luaL_checkstring (L, 2);
+	value = luaL_checkstring (L, 3);
+
+	if (parser != NULL && name != NULL && value != NULL) {
+		ucl_parser_register_variable (parser, name, value);
+		lua_pushboolean (L, true);
+		ret = 1;
+	}
+	else {
+		return luaL_error (L, "invalid arguments");
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:register_variables(vars)
+ * Register parser variables
+ * @param {table} vars names/values of variables
+ * @return {bool} success
+@example
+local parser = ucl.parser()
+local res = parser:register_variables({CONFDIR = '/etc/foo', VARDIR = '/var'})
+ */
+static int
+lua_ucl_parser_register_variables (lua_State *L)
+{
+	struct ucl_parser *parser;
+	const char *name, *value;
+	int ret = 2;
+
+	parser = lua_ucl_parser_get (L, 1);
+
+	if (parser != NULL && lua_type (L, 2) == LUA_TTABLE) {
+		for (lua_pushnil (L); lua_next (L, 2); lua_pop (L, 1)) {
+			lua_pushvalue (L, -2);
+			name = luaL_checkstring (L, -1);
+			value = luaL_checkstring (L, -2);
+			ucl_parser_register_variable (parser, name, value);
+			lua_pop (L, 1);
+		}
+
+		lua_pushboolean (L, true);
+		ret = 1;
+	}
+	else {
+		return luaL_error (L, "invalid arguments");
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:parse_string(input)
+ * Parse UCL object from file.
+ * @param {string} input string to parse
+ * @return {bool[, string]} if res is `true` then file has been parsed successfully, otherwise an error string is also returned
+ */
+static int
+lua_ucl_parser_parse_string (lua_State *L)
+{
+	struct ucl_parser *parser;
+	const char *string;
+	size_t llen;
+	enum ucl_parse_type type = UCL_PARSE_UCL;
+	int ret = 2;
+
+	parser = lua_ucl_parser_get (L, 1);
+	string = luaL_checklstring (L, 2, &llen);
+
+	if (lua_type (L, 3) == LUA_TSTRING) {
+		type = lua_ucl_str_to_parse_type (lua_tostring (L, 3));
+	}
+
+	if (parser != NULL && string != NULL) {
+		if (ucl_parser_add_chunk_full (parser, (const unsigned char *)string,
+				llen, 0, UCL_DUPLICATE_APPEND, type)) {
+			lua_pushboolean (L, true);
+			ret = 1;
+		}
+		else {
+			lua_pushboolean (L, false);
+			lua_pushstring (L, ucl_parser_get_error (parser));
+		}
+	}
+	else {
+		lua_pushboolean (L, false);
+		lua_pushstring (L, "invalid arguments");
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:parse_text(input)
+ * Parse UCL object from text object (Rspamd specific).
+ * @param {rspamd_text} input text to parse
+ * @return {bool[, string]} if res is `true` then file has been parsed successfully, otherwise an error string is also returned
+ */
+static int
+lua_ucl_parser_parse_text (lua_State *L)
+{
+	struct ucl_parser *parser;
+	struct _rspamd_lua_text *t;
+	enum ucl_parse_type type = UCL_PARSE_UCL;
+	int ret = 2;
+
+	parser = lua_ucl_parser_get (L, 1);
+
+	if (lua_type (L, 2) == LUA_TUSERDATA) {
+		t = lua_touserdata (L, 2);
+	}
+	else if (lua_type (L, 2) == LUA_TSTRING) {
+		const gchar *s;
+		gsize len;
+		static struct _rspamd_lua_text st_t;
+
+		s = lua_tolstring (L, 2, &len);
+		st_t.start = s;
+		st_t.len = len;
+
+		t = &st_t;
+	}
+	else {
+		return luaL_error(L, "invalid argument as input, expected userdata or a string");
+	}
+
+	if (lua_type (L, 3) == LUA_TSTRING) {
+		type = lua_ucl_str_to_parse_type (lua_tostring (L, 3));
+	}
+
+	if (parser != NULL && t != NULL) {
+		if (ucl_parser_add_chunk_full (parser, (const unsigned char *)t->start,
+				t->len, 0, UCL_DUPLICATE_APPEND, type)) {
+			lua_pushboolean (L, true);
+			ret = 1;
+		}
+		else {
+			lua_pushboolean (L, false);
+			lua_pushstring (L, ucl_parser_get_error (parser));
+		}
+	}
+	else {
+		lua_pushboolean (L, false);
+		lua_pushstring (L, "invalid arguments");
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:get_object()
+ * Get top object from parser and export it to lua representation.
+ * @return {variant or nil} ucl object as lua native variable
+ */
+static int
+lua_ucl_parser_get_object (lua_State *L)
+{
+	struct ucl_parser *parser;
+	ucl_object_t *obj;
+	int ret = 1;
+
+	parser = lua_ucl_parser_get (L, 1);
+	obj = ucl_parser_get_object (parser);
+
+	if (obj != NULL) {
+		ret = ucl_object_push_lua (L, obj, false);
+		/* no need to keep reference */
+		ucl_object_unref (obj);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:get_object_wrapped()
+ * Get top object from parser and export it to userdata object without
+ * unwrapping to lua.
+ * @return {ucl.object or nil} ucl object wrapped variable
+ */
+static int
+lua_ucl_parser_get_object_wrapped (lua_State *L)
+{
+	struct ucl_parser *parser;
+	ucl_object_t *obj;
+	int ret = 1;
+
+	parser = lua_ucl_parser_get (L, 1);
+	obj = ucl_parser_get_object (parser);
+
+	if (obj != NULL) {
+		lua_ucl_push_opaque (L, obj);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return ret;
+}
+
+/***
+ * @method parser:validate(schema)
+ * Validates the top object in the parser against schema. Schema might be
+ * another object or a string that represents file to load schema from.
+ *
+ * @param {string/table} schema input schema
+ * @return {result,err} two values: boolean result and the corresponding error
+ *
+ */
+static int
+lua_ucl_parser_validate (lua_State *L)
+{
+	struct ucl_parser *parser, *schema_parser;
+	ucl_object_t *schema;
+	const char *schema_file;
+	struct ucl_schema_error err;
+
+	parser = lua_ucl_parser_get (L, 1);
+
+	if (parser && parser->top_obj) {
+		if (lua_type (L, 2) == LUA_TTABLE) {
+			schema = ucl_object_lua_import (L, 2);
+
+			if (schema == NULL) {
+				lua_pushboolean (L, false);
+				lua_pushstring (L, "cannot load schema from lua table");
+
+				return 2;
+			}
+		}
+		else if (lua_type (L, 2) == LUA_TSTRING) {
+			schema_parser = ucl_parser_new (0);
+			schema_file = luaL_checkstring (L, 2);
+
+			if (!ucl_parser_add_file (schema_parser, schema_file)) {
+				lua_pushboolean (L, false);
+				lua_pushfstring (L, "cannot parse schema file \"%s\": "
+						"%s", schema_file, ucl_parser_get_error (parser));
+				ucl_parser_free (schema_parser);
+
+				return 2;
+			}
+
+			schema = ucl_parser_get_object (schema_parser);
+			ucl_parser_free (schema_parser);
+		}
+		else {
+			lua_pushboolean (L, false);
+			lua_pushstring (L, "invalid schema argument");
+
+			return 2;
+		}
+
+		if (!ucl_object_validate (schema, parser->top_obj, &err)) {
+			lua_pushboolean (L, false);
+			lua_pushfstring (L, "validation error: "
+					"%s", err.msg);
+		}
+		else {
+			lua_pushboolean (L, true);
+			lua_pushnil (L);
+		}
+
+		ucl_object_unref (schema);
+	}
+	else {
+		lua_pushboolean (L, false);
+		lua_pushstring (L, "invalid parser or empty top object");
+	}
+
+	return 2;
+}
+
+static int
+lua_ucl_parser_gc (lua_State *L)
+{
+	struct ucl_parser *parser;
+
+	parser = lua_ucl_parser_get (L, 1);
+	ucl_parser_free (parser);
+
+	return 0;
+}
+
+/***
+ * @method object:unwrap()
+ * Unwraps opaque ucl object to the native lua object (performing copying)
+ * @return {variant} any lua object
+ */
+static int
+lua_ucl_object_unwrap (lua_State *L)
+{
+	ucl_object_t *obj;
+
+	obj = lua_ucl_object_get (L, 1);
+
+	if (obj) {
+		ucl_object_push_lua (L, obj, true);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return 1;
+}
+
+static inline enum ucl_emitter
+lua_ucl_str_to_emit_type (const char *strtype)
+{
+	enum ucl_emitter format = UCL_EMIT_JSON_COMPACT;
+
+	if (strcasecmp (strtype, "json") == 0) {
+		format = UCL_EMIT_JSON;
+	}
+	else if (strcasecmp (strtype, "json-compact") == 0) {
+		format = UCL_EMIT_JSON_COMPACT;
+	}
+	else if (strcasecmp (strtype, "yaml") == 0) {
+		format = UCL_EMIT_YAML;
+	}
+	else if (strcasecmp (strtype, "config") == 0 ||
+			strcasecmp (strtype, "ucl") == 0) {
+		format = UCL_EMIT_CONFIG;
+	}
+
+	return format;
+}
+
+/***
+ * @method object:tostring(type)
+ * Unwraps opaque ucl object to string (json by default). Optionally you can
+ * specify output format:
+ *
+ * - `json` - fine printed json
+ * - `json-compact` - compacted json
+ * - `config` - fine printed configuration
+ * - `ucl` - same as `config`
+ * - `yaml` - embedded yaml
+ * @param {string} type optional
+ * @return {string} string representation of the opaque ucl object
+ */
+static int
+lua_ucl_object_tostring (lua_State *L)
+{
+	ucl_object_t *obj;
+	enum ucl_emitter format = UCL_EMIT_JSON_COMPACT;
+
+	obj = lua_ucl_object_get (L, 1);
+
+	if (obj) {
+		if (lua_gettop (L) > 1) {
+			if (lua_type (L, 2) == LUA_TSTRING) {
+				const char *strtype = lua_tostring (L, 2);
+
+				format = lua_ucl_str_to_emit_type (strtype);
+			}
+		}
+
+		return lua_ucl_to_string (L, obj, format);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return 1;
+}
+
+/***
+ * @method object:validate(schema[, path[, ext_refs]])
+ * Validates the given ucl object using schema object represented as another
+ * opaque ucl object. You can also specify path in the form `#/path/def` to
+ * specify the specific schema element to perform validation.
+ *
+ * @param {ucl.object} schema schema object
+ * @param {string} path optional path for validation procedure
+ * @return {result,err} two values: boolean result and the corresponding
+ * error, if `ext_refs` are also specified, then they are returned as opaque
+ * ucl object as {result,err,ext_refs}
+ */
+static int
+lua_ucl_object_validate (lua_State *L)
+{
+	ucl_object_t *obj, *schema, *ext_refs = NULL;
+	const ucl_object_t *schema_elt;
+	bool res = false;
+	struct ucl_schema_error err;
+	const char *path = NULL;
+
+	obj = lua_ucl_object_get (L, 1);
+	schema = lua_ucl_object_get (L, 2);
+
+	if (schema && obj && ucl_object_type (schema) == UCL_OBJECT) {
+		if (lua_gettop (L) > 2) {
+			if (lua_type (L, 3) == LUA_TSTRING) {
+				path = lua_tostring (L, 3);
+				if (path[0] == '#') {
+					path++;
+				}
+			}
+			else if (lua_type (L, 3) == LUA_TUSERDATA || lua_type (L, 3) ==
+						LUA_TTABLE) {
+				/* External refs */
+				ext_refs = lua_ucl_object_get (L, 3);
+			}
+
+			if (lua_gettop (L) > 3) {
+				if (lua_type (L, 4) == LUA_TUSERDATA || lua_type (L, 4) ==
+						LUA_TTABLE) {
+					/* External refs */
+					ext_refs = lua_ucl_object_get (L, 4);
+				}
+			}
+		}
+
+		if (path) {
+			schema_elt = ucl_object_lookup_path_char (schema, path, '/');
+		}
+		else {
+			/* Use the top object */
+			schema_elt = schema;
+		}
+
+		if (schema_elt) {
+			res = ucl_object_validate_root_ext (schema_elt, obj, schema,
+					ext_refs, &err);
+
+			if (res) {
+				lua_pushboolean (L, res);
+				lua_pushnil (L);
+
+				if (ext_refs) {
+					lua_ucl_push_opaque (L, ext_refs);
+				}
+			}
+			else {
+				lua_pushboolean (L, res);
+				lua_pushfstring (L, "validation error: %s", err.msg);
+
+				if (ext_refs) {
+					lua_ucl_push_opaque (L, ext_refs);
+				}
+			}
+		}
+		else {
+			lua_pushboolean (L, res);
+
+			lua_pushfstring (L, "cannot find the requested path: %s", path);
+
+			if (ext_refs) {
+				lua_ucl_push_opaque (L, ext_refs);
+			}
+		}
+	}
+	else {
+		lua_pushboolean (L, res);
+		lua_pushstring (L, "invalid object or schema");
+	}
+
+	if (ext_refs) {
+		return 3;
+	}
+
+	return 2;
+}
+
+static int
+lua_ucl_object_gc (lua_State *L)
+{
+	ucl_object_t *obj;
+
+	obj = lua_ucl_object_get (L, 1);
+
+	ucl_object_unref (obj);
+
+	return 0;
+}
+
+static void
+lua_ucl_parser_mt (lua_State *L)
+{
+	luaL_newmetatable (L, PARSER_META);
+
+	lua_pushvalue(L, -1);
+	lua_setfield(L, -2, "__index");
+
+	lua_pushcfunction (L, lua_ucl_parser_gc);
+	lua_setfield (L, -2, "__gc");
+
+	lua_pushcfunction (L, lua_ucl_parser_parse_file);
+	lua_setfield (L, -2, "parse_file");
+
+	lua_pushcfunction (L, lua_ucl_parser_parse_string);
+	lua_setfield (L, -2, "parse_string");
+
+	lua_pushcfunction (L, lua_ucl_parser_parse_text);
+	lua_setfield (L, -2, "parse_text");
+
+	lua_pushcfunction (L, lua_ucl_parser_register_variable);
+	lua_setfield (L, -2, "register_variable");
+
+	lua_pushcfunction (L, lua_ucl_parser_register_variables);
+	lua_setfield (L, -2, "register_variables");
+
+	lua_pushcfunction (L, lua_ucl_parser_get_object);
+	lua_setfield (L, -2, "get_object");
+
+	lua_pushcfunction (L, lua_ucl_parser_get_object_wrapped);
+	lua_setfield (L, -2, "get_object_wrapped");
+
+	lua_pushcfunction (L, lua_ucl_parser_validate);
+	lua_setfield (L, -2, "validate");
+
+	lua_pop (L, 1);
+}
+
+static void
+lua_ucl_object_mt (lua_State *L)
+{
+	luaL_newmetatable (L, OBJECT_META);
+
+	lua_pushvalue(L, -1);
+	lua_setfield(L, -2, "__index");
+
+	lua_pushcfunction (L, lua_ucl_object_gc);
+	lua_setfield (L, -2, "__gc");
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "__tostring");
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "tostring");
+
+	lua_pushcfunction (L, lua_ucl_object_unwrap);
+	lua_setfield (L, -2, "unwrap");
+
+	lua_pushcfunction (L, lua_ucl_object_unwrap);
+	lua_setfield (L, -2, "tolua");
+
+	lua_pushcfunction (L, lua_ucl_object_validate);
+	lua_setfield (L, -2, "validate");
+
+	lua_pushstring (L, OBJECT_META);
+	lua_setfield (L, -2, "class");
+
+	lua_pop (L, 1);
+}
+
+static void
+lua_ucl_types_mt (lua_State *L)
+{
+	luaL_newmetatable (L, UCL_OBJECT_TYPE_META);
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "__tostring");
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "tostring");
+
+	lua_pushstring (L, UCL_OBJECT_TYPE_META);
+	lua_setfield (L, -2, "class");
+
+	lua_pop (L, 1);
+
+	luaL_newmetatable (L, UCL_ARRAY_TYPE_META);
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "__tostring");
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "tostring");
+
+	lua_pushstring (L, UCL_ARRAY_TYPE_META);
+	lua_setfield (L, -2, "class");
+
+	lua_pop (L, 1);
+
+	luaL_newmetatable (L, UCL_IMPL_ARRAY_TYPE_META);
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "__tostring");
+
+	lua_pushcfunction (L, lua_ucl_object_tostring);
+	lua_setfield (L, -2, "tostring");
+
+	lua_pushstring (L, UCL_IMPL_ARRAY_TYPE_META);
+	lua_setfield (L, -2, "class");
+
+	lua_pop (L, 1);
+}
+
+static int
+lua_ucl_to_json (lua_State *L)
+{
+	ucl_object_t *obj;
+	int format = UCL_EMIT_JSON;
+
+	if (lua_gettop (L) > 1) {
+		if (lua_toboolean (L, 2)) {
+			format = UCL_EMIT_JSON_COMPACT;
+		}
+	}
+
+	obj = ucl_object_lua_import (L, 1);
+	if (obj != NULL) {
+		lua_ucl_to_string (L, obj, format);
+		ucl_object_unref (obj);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return 1;
+}
+
+static int
+lua_ucl_to_config (lua_State *L)
+{
+	ucl_object_t *obj;
+
+	obj = ucl_object_lua_import (L, 1);
+	if (obj != NULL) {
+		lua_ucl_to_string (L, obj, UCL_EMIT_CONFIG);
+		ucl_object_unref (obj);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return 1;
+}
+
+/***
+ * @function ucl.to_format(var, format)
+ * Converts lua variable `var` to the specified `format`. Formats supported are:
+ *
+ * - `json` - fine printed json
+ * - `json-compact` - compacted json
+ * - `config` - fine printed configuration
+ * - `ucl` - same as `config`
+ * - `yaml` - embedded yaml
+ *
+ * If `var` contains function, they are called during output formatting and if
+ * they return string value, then this value is used for output.
+ * @param {variant} var any sort of lua variable (if userdata then metafield `__to_ucl` is searched for output)
+ * @param {string} format any available format
+ * @return {string} string representation of `var` in the specific `format`.
+ * @example
+local table = {
+  str = 'value',
+  num = 100500,
+  null = ucl.null,
+  func = function ()
+    return 'huh'
+  end
+}
+
+print(ucl.to_format(table, 'ucl'))
+-- Output:
+--[[
+num = 100500;
+str = "value";
+null = null;
+func = "huh";
+--]]
+ */
+static int
+lua_ucl_to_format (lua_State *L)
+{
+	ucl_object_t *obj;
+	int format = UCL_EMIT_JSON;
+	bool sort = false;
+
+	if (lua_gettop (L) > 1) {
+		if (lua_type (L, 2) == LUA_TNUMBER) {
+			format = lua_tonumber (L, 2);
+			if (format < 0 || format >= UCL_EMIT_YAML) {
+				lua_pushnil (L);
+				return 1;
+			}
+		}
+		else if (lua_type (L, 2) == LUA_TSTRING) {
+			const char *strtype = lua_tostring (L, 2);
+
+			if (strcasecmp (strtype, "json") == 0) {
+				format = UCL_EMIT_JSON;
+			}
+			else if (strcasecmp (strtype, "json-compact") == 0) {
+				format = UCL_EMIT_JSON_COMPACT;
+			}
+			else if (strcasecmp (strtype, "yaml") == 0) {
+				format = UCL_EMIT_YAML;
+			}
+			else if (strcasecmp (strtype, "config") == 0 ||
+					 strcasecmp (strtype, "ucl") == 0) {
+				format = UCL_EMIT_CONFIG;
+			}
+			else if (strcasecmp (strtype, "msgpack") == 0 ||
+					 strcasecmp (strtype, "messagepack") == 0) {
+				format = UCL_EMIT_MSGPACK;
+			}
+		}
+
+		if (lua_isboolean (L, 3)) {
+			sort = lua_toboolean (L, 3);
+		}
+	}
+
+	obj = ucl_object_lua_import (L, 1);
+
+	if (obj != NULL) {
+
+		if (sort) {
+			if (ucl_object_type (obj) == UCL_OBJECT) {
+				ucl_object_sort_keys (obj, UCL_SORT_KEYS_RECURSIVE);
+			}
+		}
+
+		lua_ucl_to_string (L, obj, format);
+		ucl_object_unref (obj);
+	}
+	else {
+		lua_pushnil (L);
+	}
+
+	return 1;
+}
+
+static int
+lua_ucl_null_tostring (lua_State* L)
+{
+	lua_pushstring (L, "null");
+	return 1;
+}
+
+static void
+lua_ucl_null_mt (lua_State *L)
+{
+	luaL_newmetatable (L, NULL_META);
+
+	lua_pushcfunction (L, lua_ucl_null_tostring);
+	lua_setfield (L, -2, "__tostring");
+
+	lua_pop (L, 1);
+}
+
+int
+luaopen_ucl (lua_State *L)
+{
+	lua_ucl_parser_mt (L);
+	lua_ucl_null_mt (L);
+	lua_ucl_object_mt (L);
+	lua_ucl_types_mt (L);
+
+	/* Create the refs weak table: */
+	lua_createtable (L, 0, 2);
+	lua_pushliteral (L, "v"); /* tbl, "v" */
+	lua_setfield (L, -2, "__mode");
+	lua_pushvalue (L, -1); /* tbl, tbl */
+	lua_setmetatable (L, -2); /* tbl */
+	lua_setfield (L, LUA_REGISTRYINDEX, "ucl.refs");
+
+	lua_newtable (L);
+
+	lua_pushcfunction (L, lua_ucl_parser_init);
+	lua_setfield (L, -2, "parser");
+
+	lua_pushcfunction (L, lua_ucl_to_json);
+	lua_setfield (L, -2, "to_json");
+
+	lua_pushcfunction (L, lua_ucl_to_config);
+	lua_setfield (L, -2, "to_config");
+
+	lua_pushcfunction (L, lua_ucl_to_format);
+	lua_setfield (L, -2, "to_format");
+
+	ucl_null = lua_newuserdata (L, 0);
+	luaL_getmetatable (L, NULL_META);
+	lua_setmetatable (L, -2);
+
+	lua_pushvalue (L, -1);
+	lua_setfield (L, LUA_REGISTRYINDEX, "ucl.null");
+
+	lua_setfield (L, -2, "null");
+
+	return 1;
+}
+
+struct ucl_lua_funcdata*
+ucl_object_toclosure (const ucl_object_t *obj)
+{
+	if (obj == NULL || obj->type != UCL_USERDATA) {
+		return NULL;
+	}
+
+	return (struct ucl_lua_funcdata*)obj->value.ud;
+}