#include <pthread.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <assert.h>

#include <event2/bufferevent_ssl.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/dns.h>

#include <openssl/ssl.h>
#include <openssl/err.h>

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

#include "common.h"
#include "command.h"
#include "db.h"
#include "notify.h"
#include "lua_interface.h"
#include "server.h"
#include "workqueue.h"
#include "version.h"


/*  Wrapper struct for passing multiple values through a voidstar.
 *  Used when calling server_add_listener_addrinfo_().
 */
struct server_listener_convenience_ {
	struct server *s;
	evconnlistener_cb cb;
	char *type;
};


/**
 * Load all lua libs except for io and os modules,
 * TODO: this should be more fine-grained and properly sandboxed.  Also, add server lib (needs to be created).
 */
static void
server_lua_openlibs_(lua_State *L)
{
	const luaL_Reg lualibs[] = {
		{ "", luaopen_base },
		{ LUA_LOADLIBNAME, luaopen_package },
		{ LUA_TABLIBNAME, luaopen_table },
		{ LUA_STRLIBNAME, luaopen_string },
		{ LUA_MATHLIBNAME, luaopen_math },
		// { LUA_DBLIBNAME, luaopen_debug },
		{ NULL, NULL }
	};
	const luaL_Reg *lib;
	for (lib = lualibs ; lib->func; lib++) {
		lua_pushcfunction(L, lib->func);
		lua_pushstring(L, lib->name);
		lua_call(L, 1, 0);
	}

	lemu_connection_luainit(L);
}


/**
 * Allocate and initialize a new per-thread context.
 */
static struct server_worker_context *
server_worker_context_create_(struct server *server)
{
	struct server_worker_context *ctx;

	ctx = calloc(1, sizeof *ctx);
	if (ctx == NULL) {
		NOTIFY_ERROR("%s:%s", "calloc", strerror(errno));
		return NULL;
	}
	ctx->server = server;
	ctx->L = luaL_newstate();
	if (!ctx->L) {
		NOTIFY_ERROR("%s:%s", "luaL_newstate", "failed");
		free(ctx);
		return NULL;
	}
	server_lua_openlibs_(ctx->L);

	return ctx;	
}

/**
 * Free a thread context.
 * workqueue:worker_ctx_free_fn
 */
static void
server_worker_context_destroy_(void *data)
{
	struct server_worker_context *ctx = data;
	lua_close(ctx->L);
	free(ctx);
}

/**
 * Adds a worker thread to the pool.
 */
static int
server_init_add_thread_(struct server *s)
{
	struct server_worker_context *ctx;
	ssize_t worker_id;

	ctx = server_worker_context_create_(s);
	if (ctx == NULL) {
		NOTIFY_ERROR("%s:%s", "server_worker_context_create_", "failed");
		return -1;
	}

	worker_id = workqueue_worker_add(&s->workqueue, ctx, 0);
	if (worker_id < 0) {
		NOTIFY_ERROR("%s:%s", "workqueue_worker_add", "failed");
		server_worker_context_destroy_(ctx);
		return -1;
	}

	NOTIFY_DEBUG("added worker thread %zd", worker_id);

	return 0;
}

/**
 * Handle accept errors.
 */
static void
server_accept_error_cb_(struct evconnlistener *listener UNUSED, void *ctx UNUSED)
{
	int err = EVUTIL_SOCKET_ERROR();
	NOTIFY_ERROR("%s (%d)", evutil_socket_error_to_string(err), err);
}


/**
 * Move incoming data to connection queue.
 * TBD: is it worth work-queueing this data shuffling, or just let main thread handle it?
 */
static void
server_read_event_(struct bufferevent *bev, void *ctx)
{
	struct connection *c = ctx;
	struct evbuffer *input = bufferevent_get_input(bev);
	size_t line_len;
	unsigned char *line;

	while ( (line = (unsigned char *)evbuffer_readln(input, &line_len, EVBUFFER_EOL_CRLF)) ) {
		c->total_read += line_len; /* this drops the newlines from the total_read tally */

		struct command *command = command_new(line, line_len, 0);
		if (command == NULL) {
			NOTIFY_ERROR("%s:%s", "command_new", "failed");
			free(line);
			return;
		}

		if (connection_command_enqueue(c, command)) {
			NOTIFY_ERROR("%s:%s", "connection_command_enqueue", "failed");
			command_free(command);
			return;
		}
	}
}


/**
 * Handle write events.
 */
static void
server_write_event_(struct bufferevent *bev UNUSED, void *ctx)
{
	struct connection *c = ctx;

	if (c->state == CONNECTION_STATE_WANT_CLOSE) {
		c->state = CONNECTION_STATE_CLOSED;

		struct command *command = command_new(NULL, 0, COMMAND_FLAG_EVENT_DISCONNECT);
		if (command == NULL) {
			NOTIFY_ERROR("%s:%s", "command_new", "failed");
			return;
		}
		if (connection_command_enqueue(c, command)) {
			NOTIFY_ERROR("%s:%s", "connection_command_enqueue", "failed");
			command_free(command);
		}
		connection_free(c);
	}
}


/**
 * Handle some events.
 */
static void
server_event_(struct bufferevent *bev UNUSED, short events, void *ctx)
{
	struct connection *c = ctx;
	int finished = 0;

	if (events & BEV_EVENT_READING) {
		NOTIFY_ERROR("reading error from '%s'", c->name);
		finished = 1;
	}

	if (events & BEV_EVENT_WRITING) {
		NOTIFY_ERROR("writing error from '%s'", c->name);
		finished = 1;
	}

	if (events & BEV_EVENT_EOF) {
		NOTIFY_DEBUG("eof from '%s'", c->name);
		finished = 1;
	}

	if (events & BEV_EVENT_ERROR) {
		NOTIFY_ERROR("unrecoverable error from '%s': %s",
		             c->name,
		             evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR()) );
		finished = 1;
	}

	if (events & BEV_EVENT_TIMEOUT) {
		NOTIFY_ERROR("timeout from '%s'", c->name);
		finished = 1;
	}

	if (events & BEV_EVENT_CONNECTED) {
		NOTIFY_DEBUG("connected from '%s'", c->name);
	}

	if (events & ~(BEV_EVENT_READING|BEV_EVENT_WRITING|BEV_EVENT_EOF|BEV_EVENT_ERROR|BEV_EVENT_TIMEOUT|BEV_EVENT_CONNECTED)) {
		NOTIFY_ERROR("unrecognized event from '%s': %hd", c->name, events);
	}

	if (finished) {
		struct command *command = command_new(NULL, 0, COMMAND_FLAG_EVENT_DISCONNECT);
		if (command == NULL) {
			NOTIFY_ERROR("%s:%s", "command_new", "failed");
		} else {
			if (connection_command_enqueue(c, command)) {
				NOTIFY_ERROR("%s:%s", "connection_comand_enqueue", "failed");
				command_free(command);
			}
		}
		connection_free(c);
	}
}


/**
 * Everything needed to accept a new connection, regardless of transport type.
 */
static void
server_accept_conn_common_(struct server *server, struct bufferevent *bev, struct sockaddr *sock, int socklen, connection_flags_t flags)
{
	struct connection *c;

	c = calloc(1, sizeof *c);
	if (!c) {
		NOTIFY_ERROR("%s:%s", "calloc", strerror(errno));
		bufferevent_free(bev);
		return;
	}

	if (connection_init(server, c, bev, sock, socklen, flags)) {
		NOTIFY_ERROR("%s:%s", "connection_init", "failed");
		bufferevent_free(bev);
		free(c);
		return;
	}
	c->state = CONNECTION_STATE_CONNECTED;

	/* a bufferevent_add_cb interface would be better, but there isn't one yet */
	bufferevent_setcb(c->bev, server_read_event_, server_write_event_, server_event_, c);
	bufferevent_enable(c->bev, EV_READ|EV_WRITE);

	connections_append(c);

	struct command *command = command_new(NULL, 0, COMMAND_FLAG_EVENT_CONNECT);
	if (command == NULL) {
		NOTIFY_ERROR("%s:%s", "command_new", "failed");
		return;
	}
	if (connection_command_enqueue(c, command)) {
		NOTIFY_ERROR("%s:%s", "connection_command_enqueue", "failed");
		command_free(command);
	}
}


/**
 * Accept a new plain-text connection.
 */
static void
server_accept_conn_event_(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sock, int socklen, void *ctx)
{
	struct server *server = ctx;
	struct event_base *base = evconnlistener_get_base(listener);
	struct bufferevent *bev;

	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE | BEV_OPT_DEFER_CALLBACKS);
	if (!bev) {
		NOTIFY_ERROR("%s:%s", "bufferevent_socket_new", "failed");
		return;
	}

	server_accept_conn_common_(server, bev, sock, socklen, 0);
}

/**
 * Accept a new ssl connection.
 */
static void
server_accept_ssl_conn_event_(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sock, int socklen, void *ctx)
{
	struct server *server = ctx;
	struct event_base *base = evconnlistener_get_base(listener);
	struct bufferevent *bev;
	SSL *ssl;

	ssl = SSL_new(server->ssl_ctx);

	bev = bufferevent_openssl_socket_new(base, fd, ssl, BUFFEREVENT_SSL_ACCEPTING, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE | BEV_OPT_DEFER_CALLBACKS);
	if (!bev) {
		NOTIFY_ERROR("%s:%s", "bufferevent_openssl_socket_new", "failed");
		SSL_free(ssl);
		return;
	}

	server_accept_conn_common_(server, bev, sock, socklen, CONN_TYPE_SSL);
}


/**
 * Add a new listener binding to server for the provided address.
 */
static int
server_add_listener_addrinfo_(struct addrinfo *ai, void *data)
{
	struct server *s = ((struct server_listener_convenience_ *)data)->s;
	evconnlistener_cb cb = ((struct server_listener_convenience_ *)data)->cb;
	struct evconnlistener **l;
	int retval = 0;
	int r;

	if ( (r = pthread_mutex_lock(&s->listeners_mutex)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutex_lock", strerror(r));
		return -1;
	}

	if (s->listeners_used == s->listeners_allocated) {
		void *new_ptr;
		size_t new_allocated = s->listeners_allocated + 8;

		new_ptr = realloc(s->listeners, new_allocated * sizeof *(s->listeners));
		if (!new_ptr) {
			NOTIFY_ERROR("realloc(%zu): %s", new_allocated * sizeof *(s->listeners), strerror(errno));
			retval = -1;
			goto done;
		}
		s->listeners = new_ptr;
		s->listeners_allocated = new_allocated;

		/* recalloc */
		memset(&s->listeners[s->listeners_used], 0, (s->listeners_allocated - s->listeners_used - 1) * sizeof *s->listeners);
	}

#if DEBUG_SILLY
	NOTIFY_DEBUG("new listener in slot %zu", s->listeners_used);
#endif

	s->listeners_used++;
	l = &(s->listeners[s->listeners_used - 1]);
	*l = evconnlistener_new_bind(s->base, cb, s, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, ai->ai_addr, ai->ai_addrlen);
	if (!*l) {
		NOTIFY_ERROR("%s:%s", "evconnlistener_new_bind", strerror(errno));
		*l = NULL;
		s->listeners_used--;
		retval = -1;
		goto done;
	}
	evconnlistener_set_error_cb(*l, server_accept_error_cb_);

done:
	if ( (r = pthread_mutex_unlock(&s->listeners_mutex)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutex_unlock", strerror(r));
		retval = -1;
	}

	return retval;
}


/**
 * Allocates a new server structure, initializes all the structures which don't need
 * any specific configuration.  Such further setup is handled by server_init().
 */
struct server *
server_new(void)
{
	pthread_mutexattr_t attr;
	struct server *s;
	int r;

	s = calloc(1, sizeof *s);
	if (!s) {
		NOTIFY_ERROR("calloc(%zu, %zu): %s", (size_t)1, sizeof *s, strerror(errno));
		return NULL;
	}

	s->base = event_base_new();
	if (!s->base) {
		NOTIFY_ERROR("%s:%s", "event_base_new", "failed");
		goto err_free_server;
	}

	s->evdns_base = evdns_base_new(s->base, 1);
	if (!s->evdns_base) {
		NOTIFY_ERROR("%s:%s", "evdns_base", "failed");
		goto err_free_event_base;
	}

	if (workqueue_init(&s->workqueue, server_worker_context_destroy_, 0)) {
		NOTIFY_ERROR("%s:%s", "workqueue_init", "failed");
		goto err_free_evdns_base;
	}

	if ( (r = pthread_mutexattr_init(&attr)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutexattr_init", strerror(r));
		goto err_fini_workqueue;
	}

	if ( (r = pthread_mutex_init(&s->listeners_mutex, &attr)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutex_init", strerror(r));
		goto err_destroy_attr;
	}

	if (connections_init(&s->connections) < 0) {
		NOTIFY_ERROR("%s:%s", "connections_init", "&s->connections failed");
		goto err_destroy_mutex;
	}

	s->L = luaL_newstate();
	if (!s->L) {
		NOTIFY_ERROR("%s:%s", "luaL_newstate", "failed");
		goto err_free_connections;
	}

	if ( (r = pthread_mutexattr_destroy(&attr)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutexattr_destroy", strerror(r));
		goto err_close_lua;
	}

	return s;

err_close_lua:
	lua_close(s->L);
err_free_connections:
	connections_fini(&s->connections);
err_destroy_mutex:
	pthread_mutex_destroy(&s->listeners_mutex);
err_destroy_attr:
	pthread_mutexattr_destroy(&attr);
err_fini_workqueue:
	workqueue_fini(&s->workqueue, true);
err_free_evdns_base:
	evdns_base_free(s->evdns_base, 0);
err_free_event_base:
	event_base_free(s->base);
err_free_server:
	free(s);
	return NULL;
}

/**
 * Looking at top of lua stack as string, parse as address and port,
 * then add as listener to server.
 */
static void
server_init_listener_directive_a_string_(lua_State *L, struct server_listener_convenience_ *c_data)
{
	char *l_str;

	l_str = (char *)lua_tostring(L, -1);
	if (string_to_addrinfo_call(l_str, 0, server_add_listener_addrinfo_, c_data)) {
		NOTIFY_ERROR("failed to add '%s' value '%s'", c_data->type, l_str ? l_str : "[unknown]");
	}
	NOTIFY_INFO("listening on %s (%s)", l_str, c_data->type);
}

/**
 * Using configuration key provided in c_data->type, create all listeners.
 */
static void
server_init_listener_directive_(lua_State *L, struct server_listener_convenience_ *c_data)
{
	lua_getglobal(L, "server_config");
	lua_getfield(L, -1, c_data->type);
	if (lua_istable(L, -1)) {
		lua_pushnil(L);
		while (lua_next(L, -2) != 0) {
			if (lua_isstring(L, -1)) {
				server_init_listener_directive_a_string_(L, c_data);
			} else {
				char *l_str = (char *)lua_tostring(L, -2); /* table key name */
				NOTIFY_ERROR("could not fathom value for '%s' at index '%s'", c_data->type, l_str ? l_str : "[unknown]");
			}
			lua_pop(L, 1);
		}
	} else if (lua_isstring(L, -1)) {
		server_init_listener_directive_a_string_(L, c_data);
	} else {
		NOTIFY_ERROR("could not fathom '%s' value", c_data->type);
	}
	lua_pop(L, 2);
}

/**
 * Return an allocated copy of value of global lua variable.
 */
static int
get_lua_config_string_(lua_State *L, const char *key, char **value, size_t *value_len)
{
	int retval = 0;
	const char *l_str;
	size_t l_str_len;
	assert(key);
	assert(value);
	*value = NULL;

	lua_getglobal(L, "server_config");
	lua_getfield(L, -1, key);

	if (!lua_isstring(L, -1)) {
		NOTIFY_ERROR("'%s' needs to be %s, but is %s", key, "string", lua_typename(L, lua_type(L, -1)));
		retval = -1;
		goto done;
	}
	l_str = lua_tolstring(L, -1, &l_str_len);
	if (!l_str) {
		NOTIFY_ERROR("'%s' value invalid", key);
		retval = -1;
		goto done;
	}
	if (value_len) {
		*value_len = l_str_len;
	}
	l_str_len += 1; // \0
	*value = malloc(l_str_len);
	if (!*value) {
		NOTIFY_ERROR("%s:%s", "malloc", strerror(errno));
		retval = -1;
		goto done;
	}
	memcpy(*value, l_str, l_str_len);
done:
	lua_pop(L, 1);
	return retval;
}

static int
get_lua_config_integer_(lua_State *L, const char *key, int *value)
{
	int retval = 0;
	assert(key);
	assert(value);

	lua_getglobal(L, "server_config");
	lua_getfield(L, -1, key);

	if (!lua_isinteger(L, -1)) {
		NOTIFY_ERROR("'%s' needs to be %s, but is %s", key, "integer", lua_typename(L, lua_type(L, -1)));
		retval = -1;
		goto done;
	}
	*value = (int)lua_tointeger(L, -1);
done:
	lua_pop(L, 1);
	return retval;
}

/**
 * Load or reload the ssl context, with cert and settings.
 */
int
server_refresh_ssl_context(lua_State *L, struct server *s)
{
	SSL_CTX *new_ssl_ctx, *old_ssl_ctx;
	char *l_str;

	new_ssl_ctx = SSL_CTX_new(SSLv23_server_method());
	if (!new_ssl_ctx) {
		NOTIFY_ERROR("%s:%s", "SSL_CTX_new", ERR_error_string(ERR_get_error(), NULL));
		return -1;
	}

	// load cert
	if (get_lua_config_string_(L, "ssl_keyfile", &l_str, NULL)) {
		return -1;
	}
	if (SSL_CTX_use_PrivateKey_file(new_ssl_ctx, l_str, SSL_FILETYPE_PEM) < 1) {
		NOTIFY_ERROR("%s file '%s': %s", "key", l_str, ERR_error_string(ERR_get_error(), NULL));
		free(l_str);
		return -1;
	}
	free(l_str);

	if (get_lua_config_string_(L, "ssl_certfile", &l_str, NULL)) {
		return -1;
	}
	if (SSL_CTX_use_certificate_file(new_ssl_ctx, l_str, SSL_FILETYPE_PEM) < 1) {
		NOTIFY_ERROR("%s file '%s': %s", "certificate", l_str, ERR_error_string(ERR_get_error(), NULL));
		free(l_str);
		return -1;
	}
	free(l_str);

	old_ssl_ctx = s->ssl_ctx;
	s->ssl_ctx = new_ssl_ctx;

	if (old_ssl_ctx) {
		SSL_CTX_free(old_ssl_ctx);
	}

	return 0;
}


/**
 * Example heartbeat worker job.
 * N.B. server as data instead of connection.
 */
static void
server_heartbeat_worker_(void *data, void *context UNUSED, size_t id UNUSED)
{
	struct server *s = data;
	struct connection **clist, **clist_iter;
	char *message;
	int r;

	clist = connections_all_as_array(&(s->connections), NULL);
	if (!clist) {
		return;
	}

	message = strdup("[heartbeat]\n");
	if (!message) {
		NOTIFY_ERROR("%s:%s", "strdup", strerror(errno));
		return;
	}

	r = connection_multi_send(clist, message, strlen(message));
	if (r < 0) {
		NOTIFY_ERROR("could not broadcast heartbeat");
	} else {
		NOTIFY_DEBUG("broadcast heartbeat to %d connection%s", r, (r > 1) ? "s" : "");
	}

	clist_iter = clist;
	while (*clist_iter) {
		connection_free(*clist_iter);
		clist_iter++;
	}
	free(clist);
}


/**
 * Periodic heartbeat handler.
 */
static void
server_heartbeat_event_(evutil_socket_t fd UNUSED, short what UNUSED, void *arg)
{
	struct server *server = arg;

	if (workqueue_add(&server->workqueue, server_heartbeat_worker_, server)) {
		NOTIFY_ERROR("%s:%s", "workqueue_add", "failed");
	}
}


/**
 * Configure the server based on the provided lua file.
 */
int
server_init(struct server *s, char *conf_file)
{
	struct server_listener_convenience_ c_data;
	int l_int;

	/* Set up initial server state, in order to process configuration file. */
	server_lua_openlibs_(s->L);

	/* Create config table, which will be used as global env for loading config file. */
	lua_newtable(s->L);
	lua_setglobal(s->L, "server_config");


	if (luaL_loadfile(s->L, conf_file)) {
		NOTIFY_ERROR("could not %s configuration file '%s': %s",
		             "load",
		             conf_file,
		             lua_tostring(s->L, -1));
		return -1;
	}
	/* server_config table becomes global env for executing config file */
	lua_getglobal(s->L, "server_config");
	lua_setupvalue(s->L, -2, 1);

	if (lua_pcall(s->L, 0, 0, 0) != LUA_OK) {
		NOTIFY_ERROR("could not %s configuration file '%s': %s",
		             "parse",
		             conf_file,
		             lua_tostring(s->L, -1));
		return -1;
	}

	// FIXME: let db fetch its own options
	struct database_options db_options =  { 0 };
	if (get_lua_config_string_(s->L, "db_file", &db_options.db_file, NULL)) {
		return -1;
	}

	if (db_init(&s->db, &db_options)) {
		NOTIFY_ERROR("%s:%s", "db_init", "failed");
		free(db_options.db_file);
		return -1;
	}
	free(db_options.db_file);

	if (server_refresh_ssl_context(s->L, s)) {
		return -1;
	}

	if (get_lua_config_integer_(s->L, "processing_threads", &l_int)) {
		return -1;
	}
	/* FIXME: define reasonable limits */
	if (l_int < 1 || l_int > 64) {
		NOTIFY_ERROR("'%s' is not a reasonable value", "processing_threads");
		return -1;
	}
	// FIXME: while l_int != workqueue_workers()
	while (l_int) {
		if (server_init_add_thread_(s)) {
			NOTIFY_ERROR("could not start processing thread");
			return -1;
		}
		l_int--;
	}

	c_data.s = s;
	c_data.cb = server_accept_conn_event_;
	c_data.type = "listen";
	server_init_listener_directive_(s->L, &c_data);

	c_data.cb = server_accept_ssl_conn_event_;
	c_data.type = "listen_ssl";
	server_init_listener_directive_(s->L, &c_data);

	do {
		struct timeval _seconds = {30, 0};
		struct event *ev;
		/* FIXME: instead of persist, reset from event */
		ev = event_new(s->base, -1, EV_TIMEOUT | EV_PERSIST, server_heartbeat_event_, s);
		event_add(ev, &_seconds);
	} while (0);

	NOTIFY_INFO("server starting...\n"
	             "\t%s %s (%s)\n"
	             "\tlibevent %s [%s]\n"
	             "\t%s %s\n"
	             "\t%s\n"
	             "\t%s",
	             "lemu", VERSION_STR, VERSION_DATE,
	             event_get_version(), event_base_get_method(s->base),
	             db_engine(), db_version(),
	             OpenSSL_version(OPENSSL_VERSION),
	             LUA_RELEASE);

	event_base_dispatch(s->base);

	return 0;
}

void
server_free(struct server *s)
{
	int r;

	while (s->listeners_used > 0) {
		s->listeners_used--;
		if (s->listeners[s->listeners_used]) {
			evconnlistener_free(s->listeners[s->listeners_used]);
			s->listeners[s->listeners_used] = NULL;
		}
		NOTIFY_DEBUG("freed listener %zu", s->listeners_used);
	}
	free(s->listeners);
	s->listeners = NULL;

	workqueue_fini(&s->workqueue, false);

	if (s->ssl_ctx) {
		SSL_CTX_free(s->ssl_ctx);
		s->ssl_ctx = NULL;
	}

	if (s->evdns_base) {
		evdns_base_free(s->evdns_base, 0);
		s->evdns_base = NULL;
	}

	if (s->base) {
		event_base_free(s->base);
		s->base = NULL;
	}

	if ( (r = pthread_mutex_destroy(&s->connections.mutex)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutex_destroy", strerror(r));
	}

	if ( (r = pthread_mutex_destroy(&s->listeners_mutex)) ) {
		NOTIFY_ERROR("%s:%s", "pthread_mutex_destroy", strerror(r));
	}

	lua_close(s->L);

	db_fini(&s->db);

	free(s);
}