Update Files

Kinc/Sources/kinc/libs/event-libs/libev/CMakeLists.txt

@@ -0,0 +1,88 @@
+#
+# libwebsockets - small server side websockets and web server implementation
+#
+# Copyright (C) 2010 - 2020 Andy Green <andy@warmcat.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+# The strategy is to only export to PARENT_SCOPE
+#
+#  - changes to LIB_LIST
+#  - includes via include_directories
+#
+# and keep everything else private
+
+include_directories(.)
+
+set(LWS_LIBEV_LIBRARIES CACHE PATH "Path to the libev library")
+set(LWS_LIBEV_INCLUDE_DIRS CACHE PATH "Path to the libev include directory")
+
+if (NOT LIBEV_FOUND)
+	find_path(LIBEV_INCLUDE_DIRS NAMES ev.h)
+	find_library(LIBEV_LIBRARIES NAMES ev)
+endif()
+message("libev include dir: ${LIBEV_INCLUDE_DIRS}")
+message("libev libraries: ${LIBEV_LIBRARIES}")
+include_directories("${LIBEV_INCLUDE_DIRS}")
+
+if ("${LWS_LIBEV_LIBRARIES}" STREQUAL "" OR "${LWS_LIBEV_INCLUDE_DIRS}" STREQUAL "")
+else()
+	set(LIBEV_LIBRARIES ${LWS_LIBEV_LIBRARIES})
+	set(LIBEV_INCLUDE_DIRS ${LWS_LIBEV_INCLUDE_DIRS})
+endif()
+
+if (LWS_WITH_EVLIB_PLUGINS)
+
+	create_evlib_plugin(
+		evlib_ev
+		libev.c
+		private-lib-event-libs-libev.h
+		${LIBEV_LIBRARIES})
+
+else()
+
+	list(APPEND LIB_LIST ${LIBEV_LIBRARIES})
+
+	list(APPEND SOURCES
+			event-libs/libev/libev.c)
+# see README.build.md for discussion of why of the supported event libs,
+# only libev cannot cope with -Werror
+	set_source_files_properties(event-libs/libev/libev.c
+				    PROPERTIES COMPILE_FLAGS "-Wno-error" )
+endif()
+
+set(CMAKE_REQUIRED_LIBRARIES ${LIB_LIST})
+
+CHECK_C_SOURCE_COMPILES(
+	"#include <ev.h>
+	 int main(int argc, char **argv) { return EVBACKEND_LINUXAIO; }
+	" LWS_HAVE_EVBACKEND_LINUXAIO)
+
+CHECK_C_SOURCE_COMPILES(
+	"#include <ev.h>
+	 int main(int argc, char **argv) { return EVBACKEND_IOURING; }
+	 " LWS_HAVE_EVBACKEND_IOURING)
+
+#
+# Keep explicit parent scope exports at end
+#
+
+exports_to_parent_scope()
+set(LWS_HAVE_EVBACKEND_LINUXAIO ${LWS_HAVE_EVBACKEND_LINUXAIO} PARENT_SCOPE)
+set(LWS_HAVE_EVBACKEND_IOURING ${LWS_HAVE_EVBACKEND_IOURING} PARENT_SCOPE)

Kinc/Sources/kinc/libs/event-libs/libev/libev.c

@@ -0,0 +1,468 @@
+/*
+ * libwebsockets - small server side websockets and web server implementation
+ *
+ * Copyright (C) 2010 - 2020 Andy Green <andy@warmcat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "private-lib-core.h"
+#include "private-lib-event-libs-libev.h"
+
+#define pt_to_priv_ev(_pt) ((struct lws_pt_eventlibs_libev *)(_pt)->evlib_pt)
+#define vh_to_priv_ev(_vh) ((struct lws_vh_eventlibs_libev *)(_vh)->evlib_vh)
+#define wsi_to_priv_ev(_w) ((struct lws_wsi_eventlibs_libev *)(_w)->evlib_wsi)
+
+static void
+lws_ev_hrtimer_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
+{
+	struct lws_pt_eventlibs_libev *ptpr = lws_container_of(watcher,
+					struct lws_pt_eventlibs_libev, hrtimer);
+	struct lws_context_per_thread *pt = ptpr->pt;
+	lws_usec_t us;
+
+	lws_pt_lock(pt, __func__);
+	us = __lws_sul_service_ripe(pt->pt_sul_owner, LWS_COUNT_PT_SUL_OWNERS,
+				    lws_now_usecs());
+	if (us) {
+		ev_timer_set(&ptpr->hrtimer, ((float)us) / 1000000.0, 0);
+		ev_timer_start(ptpr->io_loop, &ptpr->hrtimer);
+	}
+	lws_pt_unlock(pt);
+}
+
+static void
+lws_ev_idle_cb(struct ev_loop *loop, struct ev_idle *handle, int revents)
+{
+	struct lws_pt_eventlibs_libev *ptpr = lws_container_of(handle,
+					struct lws_pt_eventlibs_libev, idle);
+	struct lws_context_per_thread *pt = ptpr->pt;
+	int reschedule = 0;
+	lws_usec_t us;
+
+	lws_service_do_ripe_rxflow(pt);
+
+	/*
+	 * is there anybody with pending stuff that needs service forcing?
+	 */
+	if (!lws_service_adjust_timeout(pt->context, 1, pt->tid))
+		/* -1 timeout means just do forced service */
+		reschedule = _lws_plat_service_forced_tsi(pt->context, pt->tid);
+
+	/* account for hrtimer */
+
+	lws_pt_lock(pt, __func__);
+	us = __lws_sul_service_ripe(pt->pt_sul_owner, LWS_COUNT_PT_SUL_OWNERS,
+				    lws_now_usecs());
+	if (us) {
+		ev_timer_set(&ptpr->hrtimer, ((float)us) / 1000000.0, 0);
+		ev_timer_start(ptpr->io_loop, &ptpr->hrtimer);
+	}
+	lws_pt_unlock(pt);
+
+	/* there is nobody who needs service forcing, shut down idle */
+	if (!reschedule)
+		ev_idle_stop(loop, handle);
+
+	if (pt->destroy_self)
+		lws_context_destroy(pt->context);
+}
+
+static void
+lws_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
+{
+	struct lws_io_watcher_libev *lws_io = lws_container_of(watcher,
+					struct lws_io_watcher_libev, watcher);
+	struct lws_context *context = lws_io->context;
+	struct lws_pt_eventlibs_libev *ptpr;
+	struct lws_context_per_thread *pt;
+	struct lws_pollfd eventfd;
+	struct lws *wsi;
+	int tsi = 0;
+
+	if (revents & EV_ERROR)
+		return;
+
+	eventfd.fd = watcher->fd;
+	eventfd.events = 0;
+	eventfd.revents = EV_NONE;
+
+	if (revents & EV_READ) {
+		eventfd.events |= LWS_POLLIN;
+		eventfd.revents |= LWS_POLLIN;
+	}
+	if (revents & EV_WRITE) {
+		eventfd.events |= LWS_POLLOUT;
+		eventfd.revents |= LWS_POLLOUT;
+	}
+
+	wsi = wsi_from_fd(context, watcher->fd);
+	if (wsi)
+		tsi = (int)wsi->tsi;
+	pt = &context->pt[tsi];
+	ptpr = pt_to_priv_ev(pt);
+
+	lws_service_fd_tsi(context, &eventfd, tsi);
+
+	ev_idle_start(ptpr->io_loop, &ptpr->idle);
+}
+
+void
+lws_ev_sigint_cb(struct ev_loop *loop, struct ev_signal *watcher, int revents)
+{
+	struct lws_context *context = watcher->data;
+
+	if (context->eventlib_signal_cb) {
+		context->eventlib_signal_cb((void *)watcher, watcher->signum);
+
+		return;
+	}
+	ev_break(loop, EVBREAK_ALL);
+}
+
+static int
+elops_listen_init_ev(struct lws_dll2 *d, void *user)
+{
+#if defined(LWS_WITH_SERVER)
+	struct lws *wsi = lws_container_of(d, struct lws, listen_list);
+	struct lws_context *context = (struct lws_context *)user;
+	struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
+	struct lws_pt_eventlibs_libev *ptpr = pt_to_priv_ev(pt);
+	struct lws_wsi_eventlibs_libev *w = wsi_to_priv_ev(wsi);
+	struct lws_vhost *vh = wsi->a.vhost;
+
+	w->w_read.context = context;
+	w->w_write.context = context;
+	vh_to_priv_ev(vh)->w_accept.context = context;
+
+	ev_io_init(&vh_to_priv_ev(vh)->w_accept.watcher,
+		   lws_accept_cb, wsi->desc.sockfd, EV_READ);
+	ev_io_start(ptpr->io_loop, &vh_to_priv_ev(vh)->w_accept.watcher);
+#endif
+
+	return 0;
+}
+
+static int
+elops_init_pt_ev(struct lws_context *context, void *_loop, int tsi)
+{
+	struct lws_context_per_thread *pt = &context->pt[tsi];
+	struct lws_pt_eventlibs_libev *ptpr = pt_to_priv_ev(pt);
+	struct ev_signal *w_sigint = &ptpr->w_sigint.watcher;
+	struct ev_loop *loop = (struct ev_loop *)_loop;
+	const char *backend_name;
+	unsigned int backend;
+	int status = 0;
+
+	lwsl_cx_info(context, "loop %p", _loop);
+
+	ptpr->pt = pt;
+
+	if (!loop)
+		loop = ev_loop_new(0);
+	else
+		context->pt[tsi].event_loop_foreign = 1;
+
+	if (!loop) {
+		lwsl_cx_err(context, "creating event base failed");
+
+		return -1;
+	}
+
+	ptpr->io_loop = loop;
+
+	lws_vhost_foreach_listen_wsi(context, context, elops_listen_init_ev);
+
+	/* Register the signal watcher unless it's a foreign loop */
+	if (!context->pt[tsi].event_loop_foreign) {
+		ev_signal_init(w_sigint, lws_ev_sigint_cb, SIGINT);
+		w_sigint->data = context;
+		ev_signal_start(loop, w_sigint);
+	}
+
+	backend = ev_backend(loop);
+	switch (backend) {
+	case EVBACKEND_SELECT:
+		backend_name = "select";
+		break;
+	case EVBACKEND_POLL:
+		backend_name = "poll";
+		break;
+	case EVBACKEND_EPOLL:
+		backend_name = "epoll";
+		break;
+#if defined(LWS_HAVE_EVBACKEND_LINUXAIO)
+       case EVBACKEND_LINUXAIO:
+               backend_name = "Linux AIO";
+               break;
+#endif
+#if defined(LWS_HAVE_EVBACKEND_IOURING)
+       case EVBACKEND_IOURING:
+               backend_name = "Linux io_uring";
+               break;
+#endif
+       case EVBACKEND_KQUEUE:
+		backend_name = "kqueue";
+		break;
+	case EVBACKEND_DEVPOLL:
+		backend_name = "/dev/poll";
+		break;
+	case EVBACKEND_PORT:
+		backend_name = "Solaris 10 \"port\"";
+		break;
+	default:
+		backend_name = "Unknown libev backend";
+		break;
+	}
+
+	lwsl_cx_info(context, " libev backend: %s", backend_name);
+	(void)backend_name;
+
+	ev_timer_init(&ptpr->hrtimer, lws_ev_hrtimer_cb, 0, 0);
+	ptpr->hrtimer.data = pt;
+
+	ev_idle_init(&ptpr->idle, lws_ev_idle_cb);
+
+	return status;
+}
+
+static int
+elops_listen_destroy_ev(struct lws_dll2 *d, void *user)
+{
+#if defined(LWS_WITH_SERVER)
+	struct lws *wsi = lws_container_of(d, struct lws, listen_list);
+	struct lws_context *context = (struct lws_context *)user;
+	struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
+	struct lws_pt_eventlibs_libev *ptpr = pt_to_priv_ev(pt);
+	struct lws_vhost *vh = wsi->a.vhost;
+
+	ev_io_stop(ptpr->io_loop, &vh_to_priv_ev(vh)->w_accept.watcher);
+#endif
+	return 0;
+}
+
+static void
+elops_destroy_pt_ev(struct lws_context *context, int tsi)
+{
+	struct lws_context_per_thread *pt = &context->pt[tsi];
+	struct lws_pt_eventlibs_libev *ptpr = pt_to_priv_ev(pt);
+
+	lws_vhost_foreach_listen_wsi(context, context, elops_listen_destroy_ev);
+
+	/* static assets */
+
+	ev_timer_stop(ptpr->io_loop, &ptpr->hrtimer);
+	ev_idle_stop(ptpr->io_loop, &ptpr->idle);
+
+	if (!pt->event_loop_foreign)
+		ev_signal_stop(ptpr->io_loop, &ptpr->w_sigint.watcher);
+}
+
+static int
+elops_init_context_ev(struct lws_context *context,
+		      const struct lws_context_creation_info *info)
+{
+	int n;
+
+	context->eventlib_signal_cb = info->signal_cb;
+
+	for (n = 0; n < context->count_threads; n++)
+		pt_to_priv_ev(&context->pt[n])->w_sigint.context = context;
+
+	return 0;
+}
+
+static int
+elops_accept_ev(struct lws *wsi)
+{
+	struct lws_wsi_eventlibs_libev *w = wsi_to_priv_ev(wsi);
+	int fd;
+
+	if (wsi->role_ops->file_handle)
+		fd = wsi->desc.filefd;
+	else
+		fd = wsi->desc.sockfd;
+
+	w->w_read.context = wsi->a.context;
+	w->w_write.context = wsi->a.context;
+
+	ev_io_init(&w->w_read.watcher, lws_accept_cb, fd, EV_READ);
+	ev_io_init(&w->w_write.watcher, lws_accept_cb, fd, EV_WRITE);
+
+	return 0;
+}
+
+static void
+elops_io_ev(struct lws *wsi, unsigned int flags)
+{
+	struct lws_context_per_thread *pt = &wsi->a.context->pt[(int)wsi->tsi];
+	struct lws_pt_eventlibs_libev *ptpr = pt_to_priv_ev(pt);
+	struct lws_wsi_eventlibs_libev *w = wsi_to_priv_ev(wsi);
+
+	lwsl_wsi_debug(wsi, "%s flags 0x%x %p %d", wsi->role_ops->name, flags,
+						   ptpr->io_loop,
+						   pt->is_destroyed);
+
+	if (!ptpr->io_loop || pt->is_destroyed)
+		return;
+
+	assert((flags & (LWS_EV_START | LWS_EV_STOP)) &&
+	       (flags & (LWS_EV_READ | LWS_EV_WRITE)));
+
+	if (flags & LWS_EV_START) {
+		if (flags & LWS_EV_WRITE)
+			ev_io_start(ptpr->io_loop, &w->w_write.watcher);
+		if (flags & LWS_EV_READ)
+			ev_io_start(ptpr->io_loop, &w->w_read.watcher);
+	} else {
+		if (flags & LWS_EV_WRITE)
+			ev_io_stop(ptpr->io_loop, &w->w_write.watcher);
+		if (flags & LWS_EV_READ)
+			ev_io_stop(ptpr->io_loop, &w->w_read.watcher);
+	}
+
+	if (pt->destroy_self)
+		lws_context_destroy(pt->context);
+}
+
+static void
+elops_run_pt_ev(struct lws_context *context, int tsi)
+{
+	if (pt_to_priv_ev(&context->pt[tsi])->io_loop)
+		ev_run(pt_to_priv_ev(&context->pt[tsi])->io_loop, 0);
+}
+
+static int
+elops_destroy_context2_ev(struct lws_context *context)
+{
+	struct lws_context_per_thread *pt;
+	struct lws_pt_eventlibs_libev *ptpr;
+	int n, m;
+
+	for (n = 0; n < context->count_threads; n++) {
+		int budget = 1000;
+
+		pt = &context->pt[n];
+		ptpr = pt_to_priv_ev(pt);
+
+		/* only for internal loops... */
+
+		if (pt->event_loop_foreign || !ptpr->io_loop)
+			continue;
+
+		if (!context->evlib_finalize_destroy_after_int_loops_stop) {
+			ev_break(ptpr->io_loop, EVBREAK_ONE);
+			continue;
+		}
+		while (budget-- &&
+		       (m = ev_run(ptpr->io_loop, 0)))
+			;
+
+		ev_loop_destroy(ptpr->io_loop);
+	}
+
+	return 0;
+}
+
+static int
+elops_init_vhost_listen_wsi_ev(struct lws *wsi)
+{
+	struct lws_wsi_eventlibs_libev *w;
+	int fd;
+
+	if (!wsi) {
+		assert(0);
+		return 0;
+	}
+
+	w = wsi_to_priv_ev(wsi);
+	w->w_read.context = wsi->a.context;
+	w->w_write.context = wsi->a.context;
+
+	if (wsi->role_ops->file_handle)
+		fd = wsi->desc.filefd;
+	else
+		fd = wsi->desc.sockfd;
+
+	ev_io_init(&w->w_read.watcher, lws_accept_cb, fd, EV_READ);
+	//ev_io_init(&w->w_write.watcher, lws_accept_cb, fd, EV_WRITE);
+
+	elops_io_ev(wsi, LWS_EV_START | LWS_EV_READ);
+
+	return 0;
+}
+
+static void
+elops_destroy_wsi_ev(struct lws *wsi)
+{
+	struct lws_context_per_thread *pt = &wsi->a.context->pt[(int)wsi->tsi];
+	struct lws_pt_eventlibs_libev *ptpr = pt_to_priv_ev(pt);
+	struct lws_wsi_eventlibs_libev *w = wsi_to_priv_ev(wsi);
+
+	ev_io_stop(ptpr->io_loop, &w->w_read.watcher);
+	ev_io_stop(ptpr->io_loop, &w->w_write.watcher);
+}
+
+static int
+elops_wsi_logical_close_ev(struct lws *wsi)
+{
+        elops_destroy_wsi_ev(wsi);
+
+        return 0;
+}
+
+static const struct lws_event_loop_ops event_loop_ops_ev = {
+	/* name */			"libev",
+	/* init_context */		elops_init_context_ev,
+	/* destroy_context1 */		NULL,
+	/* destroy_context2 */		elops_destroy_context2_ev,
+	/* init_vhost_listen_wsi */	elops_init_vhost_listen_wsi_ev,
+	/* init_pt */			elops_init_pt_ev,
+	/* wsi_logical_close */		elops_wsi_logical_close_ev,
+	/* check_client_connect_ok */	NULL,
+	/* close_handle_manually */	NULL,
+	/* accept */			elops_accept_ev,
+	/* io */			elops_io_ev,
+	/* run_pt */			elops_run_pt_ev,
+	/* destroy_pt */		elops_destroy_pt_ev,
+	/* destroy wsi */		elops_destroy_wsi_ev,
+	/* foreign_thread */		NULL,
+	/* fake_POLLIN */		NULL,
+
+	/* flags */			0,
+
+	/* evlib_size_ctx */	0,
+	/* evlib_size_pt */	sizeof(struct lws_pt_eventlibs_libev),
+	/* evlib_size_vh */	sizeof(struct lws_vh_eventlibs_libev),
+	/* evlib_size_wsi */	sizeof(struct lws_wsi_eventlibs_libev),
+};
+
+#if defined(LWS_WITH_EVLIB_PLUGINS)
+LWS_VISIBLE
+#endif
+const lws_plugin_evlib_t evlib_ev = {
+	.hdr = {
+		"libev event loop",
+		"lws_evlib_plugin",
+		LWS_BUILD_HASH,
+		LWS_PLUGIN_API_MAGIC
+	},
+
+	.ops	= &event_loop_ops_ev
+};

Kinc/Sources/kinc/libs/event-libs/libev/private-lib-event-libs-libev.h

@@ -0,0 +1,62 @@
+/*
+ * libwebsockets - small server side websockets and web server implementation
+ *
+ * Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <ev.h>
+
+#define LWS_EV_REFCOUNT_STATIC_HANDLE_NEW(_x, _ctx) \
+		{ (_x)->data = _ctx; \
+		_ctx->count_event_loop_static_asset_handles++; }
+#define LWS_EV_REFCOUNT_STATIC_HANDLE_TO_CONTEXT(_x) \
+			((struct lws_context *)(_x)->data)))
+#define LWS_EV_REFCOUNT_STATIC_HANDLE_DESTROYED(_x) \
+		(--(LWS_UV_REFCOUNT_STATIC_HANDLE_TO_CONTEXT(_x)-> \
+				count_event_loop_static_asset_handles))
+
+struct lws_signal_watcher_libev {
+	ev_signal watcher;
+	struct lws_context *context;
+};
+
+struct lws_pt_eventlibs_libev {
+	struct ev_loop *io_loop;
+	struct ev_timer hrtimer;
+	struct ev_idle idle;
+	struct lws_signal_watcher_libev w_sigint;
+	struct lws_context_per_thread *pt;
+};
+
+struct lws_io_watcher_libev {
+	ev_io watcher;
+	struct lws_context *context;
+};
+
+struct lws_vh_eventlibs_libev {
+	struct lws_io_watcher_libev w_accept;
+};
+
+struct lws_wsi_eventlibs_libev {
+	struct lws_io_watcher_libev w_read;
+	struct lws_io_watcher_libev w_write;
+};
+