Update ChangeLog and bump version for v2.2.0 release

Signed-off-by: Joachim Nilsson <troglobit@gmail.com>

API.md

@@ -57,6 +57,7 @@ void callback       (uev_t *w, void *arg, int events);
 
 /* Event loop:      Notice the use of flags! */
 int uev_init        (uev_ctx_t *ctx);
+int uev_init1       (uev_ctx_t *ctx, int maxevents);
 int uev_exit        (uev_ctx_t *ctx);
 int uev_run         (uev_ctx_t *ctx, int flags);         /* UEV_NONE, UEV_ONCE, and/or UEV_NONBLOCK */
 
@@ -312,7 +313,7 @@ int main(void)
     uev_t watcher;
     uev_ctx_t ctx;
 
-    fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
+    fd = open("/dev/input/js0", O_RDONLY, O_NONBLOCK);
     if (fd < 0)
         errx(errno, "Cannot find a joystick attached.");
 

ChangeLog.md

@@ -3,6 +3,54 @@ Change Log
 
 All notable changes to the project are documented in this file.
 
+
+[v2.2.0][] - 2018-10-04
+-----------------------
+
+**NOTE:** You now have to explicitly include `sys/queue.h`, or provide a
+          local version of `queue.h`, if your application depends on it.
+
+### Changes
+- Replaced BSD `queue.h` doubly-linked lst API with own implementation.
+  Making libuEv stand-alone, no longer imposing any particular version
+  of `queue.h` on the user
+- Enforce `-std=gnu11` to unlock `typeof()` in older GCC versions
+- Code cleanup
+
+### Fixes
+- Fix missing header deps. in `Makefile.am`, library did not rebuild
+  properly if any of the local header files were changed
+
+
+[v2.1.3][] - 2018-09-06
+-----------------------
+
+### Changes
+- Update joystick example, use first device, `/dev/input/js0`
+- Minor refactor of `uev_exit()`, use `_SAFE` macros to traverse
+  list of watchers instead of `while()`
+- New API test to verify that `uev_exit()` terminates properly
+- Make `uev_signal_stop()` idempotent
+
+### Fixes
+- Let `uev_timer_stop()` call `close()` on the timerfd directly, do not
+  call `uev_timer_set()` since that may cause lockups or hangs
+
+
+[v2.1.2][] - 2018-02-27
+-----------------------
+
+### Changes
+- Minor refactor of event loop after fixing the nasty use-after-free bug
+  in v2.1.1.  Code can now be collapsed and noticeably simplified
+
+### Fixes
+- Issue #17: Check if `AM_PROG_AR` macro exists before calling it, fixes
+  problem building libuEv on systems with older autoconf + automake.
+  Patch by Markus Svilans
+- Fix minor issue with unit tests, return result of test not event loop
+
+
 [v2.1.1][] - 2018-01-28
 -----------------------
 
@@ -336,7 +384,10 @@ v0.0.1 - 2012-03-17
 Lua users mailing list.
 
 
-[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.1.1...HEAD
+[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.2.0...HEAD
+[v2.2.0]: https://github.com/troglobit/libuev/compare/v2.1.3...v2.2.0
+[v2.1.3]: https://github.com/troglobit/libuev/compare/v2.1.2...v2.1.3
+[v2.1.2]: https://github.com/troglobit/libuev/compare/v2.1.1...v2.1.2
 [v2.1.1]: https://github.com/troglobit/libuev/compare/v2.1.0...v2.1.1
 [v2.1.0]: https://github.com/troglobit/libuev/compare/v2.0.0...v2.1.0
 [v2.0.0]: https://github.com/troglobit/libuev/compare/v1.6.0...v2.0.0

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(libuev, 2.1.1, https://github.com/troglobit/libuev/issues)
+AC_INIT(libuev, 2.2.0, https://github.com/troglobit/libuev/issues)
 AM_INIT_AUTOMAKE([1.11 foreign no-dist-gzip dist-xz])
 AM_SILENT_RULES([yes])
 
@@ -8,7 +8,7 @@ AC_CONFIG_FILES([Makefile src/libuev.pc src/Makefile examples/Makefile tests/Mak
 AC_CONFIG_MACRO_DIR([m4])
 
 AC_PROG_CC
-AM_PROG_AR
+m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
 LT_INIT
 
 # Optional features

debian/changelog

@@ -1,3 +1,32 @@
+libuev (2.2.0) unstable; urgency=medium
+
+  * Replaced BSD queue.h with own linked list implementation.  This means
+    applications relying on any of the queue.h APIs now need to provide
+    their own version, or use the system sys/queue.h
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Thu, 04 Oct 2018 21:03:48 +0200
+
+libuev (2.1.3) unstable; urgency=medium
+
+  * Minor bugfix release
+    - Updated joystick example, use first joystick, /dev/input/js0
+    - Use LIST_FOREACH_SAFE() instead of while() in uev_exit()
+    - New API test for uev_exit()
+    - Don't call uev_timer_set() when stopping a timer, may cause lockups
+    - Return OK immediately if a signal watcher is already stopped
+  * Packaging fixes: libuev.so symlink goes in -dev package
+ -- Joachim Nilsson <troglobit@gmail.com>  Thu, 06 Sep 2018 22:01:24 +0200
+
+libuev (2.1.2) unstable; urgency=medium
+
+  * Minor bugfix release
+    - Fix #17: build problem on systems with too old autoconf + automake
+    - Fix unit tests, return result of test not result of event loop
+    - Refactor/simplify/collapse main event loop code after fixes in v2.1.1
+  * Fix minor packaging issues
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Tue, 27 Feb 2018 00:05:32 +0100
+
 libuev (2.1.1) unstable; urgency=medium
 
   * Minor bugfix release

debian/libuev-dev.install

@@ -1,6 +1,4 @@
-usr/include/uev/uev.h
+usr/include/uev/*.h
-usr/include/uev/private.h
+usr/lib/*/libuev.a
-usr/include/uev/queue.h
+usr/lib/*/libuev.so
-usr/lib/*/lib*.a
-usr/lib/*/lib*.so
 usr/lib/*/pkgconfig/lib*.pc

examples/joystick.c

@@ -78,7 +78,7 @@ int main(void)
 	uev_t js1_watcher;
 	uev_ctx_t ctx;
 
-	fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
+	fd = open("/dev/input/js0", O_RDONLY, O_NONBLOCK);
 	if (fd < 0)
 		errx(errno, "Cannot find a joystick attached.");
 

src/Makefile.am

@@ -1,8 +1,8 @@
 lib_LTLIBRARIES     = libuev.la
-libuev_la_SOURCES   = uev.c io.c timer.c signal.c cron.c
+libuev_la_SOURCES   = uev.c uev.h private.h io.c timer.c signal.c cron.c
 libuev_la_CPPFLAGS  = -D_GNU_SOURCE -D_TIME_BITS=64
-libuev_la_CFLAGS    = -W -Wall -Wextra
+libuev_la_CFLAGS    = -W -Wall -Wextra -std=gnu11
-libuev_la_LDFLAGS   = $(AM_LDFLAGS) -version-info 2:1:0
+libuev_la_LDFLAGS   = $(AM_LDFLAGS) -version-info 3:0:1
 
 noinst_PROGRAMS     = bench
 bench_CPPFLAGS      = -D_GNU_SOURCE
@@ -11,4 +11,4 @@ bench_LDADD         = libuev.la
 pkgconfigdir        = $(libdir)/pkgconfig
 pkgincludedir       = $(includedir)/uev
 pkgconfig_DATA      = libuev.pc
-pkginclude_HEADERS  = uev.h private.h queue.h
+pkginclude_HEADERS  = uev.h private.h

src/bench.c

@@ -57,8 +57,6 @@
 
 #include "uev.h"
 
-#define UNUSED(arg) arg __attribute__ ((unused))
-
 typedef struct {
 	int index;
 } myarg_t;
@@ -70,7 +68,7 @@ static int *pipes;
 static uev_t *evio;
 static uev_t *evto;
 
-static void read_cb(uev_t *w, void *arg, int UNUSED(events))
+static void read_cb(uev_t *w, void *arg, int events)
 {
 	int idx, widx;
 	u_char ch;
@@ -96,7 +94,7 @@ static void read_cb(uev_t *w, void *arg, int UNUSED(events))
 	}
 }
 
-static void timer_cb(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void timer_cb(uev_t *w, void *arg, int events)
 {
 	/* nop */
 }

src/cron.c

@@ -112,9 +112,6 @@ int uev_cron_set(uev_t *w, time_t when, time_t interval)
 		if (!when && !interval)
 			return 0;
 
-		/* Remove from internal list */
-		LIST_REMOVE(w, link);
-
 		if (uev_cron_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, when, interval))
 			return -1;
 	}

src/private.h

@@ -27,7 +27,38 @@
 
 #include <stdio.h>
 #include <sys/epoll.h>
-#include "queue.h"	       /* OpenBSD queue.h > old GLIBC version */
+
+/*
+ * List functions.
+ */
+#define _UEV_FOREACH(node, list)		\
+	for (typeof (node) next, node = list;	\
+	     node && (next = node->next, 1);	\
+	     node = next)
+
+#define _UEV_INSERT(node, list) do {		\
+	typeof (node) next;			\
+	next       = list;			\
+	list       = node;			\
+	if (next)				\
+		next->prev = node;		\
+	node->next = next;			\
+	node->prev = NULL;			\
+} while (0)
+
+#define _UEV_REMOVE(node, list) do {		\
+	typeof (node) prev, next;		\
+	prev = node->prev;			\
+	next = node->next;			\
+	if (prev)				\
+		prev->next = next;		\
+	if (next)				\
+		next->prev = prev;		\
+	node->prev = NULL;			\
+	node->next = NULL;			\
+	if (list == node)			\
+		list = next;			\
+} while (0)
 
 /* I/O, timer, or signal watcher */
 typedef enum {
@@ -38,13 +69,15 @@ typedef enum {
 } uev_type_t;
 
 /* Event mask, used internally only. */
-#define UEV_EVENT_MASK  (UEV_ERROR | UEV_READ | UEV_WRITE | UEV_PRI | UEV_HUP | UEV_RDHUP | UEV_EDGE | UEV_ONESHOT)
+#define UEV_EVENT_MASK  (UEV_ERROR | UEV_READ | UEV_WRITE | UEV_PRI |	\
+			 UEV_RDHUP | UEV_HUP  | UEV_EDGE  | UEV_ONESHOT)
 
 /* Main libuEv context type */
 typedef struct {
 	int             running;
-	int             fd;     /* For epoll() */
+	int             fd;	    /* For epoll() */
-	LIST_HEAD(,uev) watchers;
+	int             maxevents;  /* For epoll() */
+	struct uev     *watchers;
 	uint32_t        workaround; /* For workarounds, e.g. redirected stdin */
 } uev_ctx_t;
 
@@ -53,7 +86,7 @@ struct uev;
 
 /* This is used to hide all private data members in uev_t */
 #define uev_private_t                                           \
-	LIST_ENTRY(uev) link;   /* For queue.h linked list */   \
+	struct uev     *next, *prev;				\
 								\
 	int             active;                                 \
 	int             events;                                 \

src/queue.h

@@ -1,648 +0,0 @@
-/*	$OpenBSD: queue.h,v 1.38 2013/07/03 15:05:21 fgsch Exp $	*/
-/*	$NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $	*/
-
-/*
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * 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.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS 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.
- *
- *	@(#)queue.h	8.5 (Berkeley) 8/20/94
- */
-
-#ifndef	_SYS_QUEUE_H_
-#define	_SYS_QUEUE_H_
-
-/*
- * This file defines five types of data structures: singly-linked lists, 
- * lists, simple queues, tail queues, and circular queues.
- *
- *
- * A singly-linked list is headed by a single forward pointer. The elements
- * are singly linked for minimum space and pointer manipulation overhead at
- * the expense of O(n) removal for arbitrary elements. New elements can be
- * added to the list after an existing element or at the head of the list.
- * Elements being removed from the head of the list should use the explicit
- * macro for this purpose for optimum efficiency. A singly-linked list may
- * only be traversed in the forward direction.  Singly-linked lists are ideal
- * for applications with large datasets and few or no removals or for
- * implementing a LIFO queue.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
- * so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before
- * or after an existing element or at the head of the list. A list
- * may only be traversed in the forward direction.
- *
- * A simple queue is headed by a pair of pointers, one the head of the
- * list and the other to the tail of the list. The elements are singly
- * linked to save space, so elements can only be removed from the
- * head of the list. New elements can be added to the list before or after
- * an existing element, at the head of the list, or at the end of the
- * list. A simple queue may only be traversed in the forward direction.
- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
- * A circle queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or after
- * an existing element, at the head of the list, or at the end of the list.
- * A circle queue may be traversed in either direction, but has a more
- * complex end of list detection.
- *
- * For details on the use of these macros, see the queue(3) manual page.
- */
-
-#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC))
-#define _Q_INVALIDATE(a) (a) = ((void *)-1)
-#else
-#define _Q_INVALIDATE(a)
-#endif
-
-/*
- * Singly-linked List definitions.
- */
-#define SLIST_HEAD(name, type)						\
-struct name {								\
-	struct type *slh_first;	/* first element */			\
-}
- 
-#define	SLIST_HEAD_INITIALIZER(head)					\
-	{ NULL }
- 
-#define SLIST_ENTRY(type)						\
-struct {								\
-	struct type *sle_next;	/* next element */			\
-}
- 
-/*
- * Singly-linked List access methods.
- */
-#define	SLIST_FIRST(head)	((head)->slh_first)
-#define	SLIST_END(head)		NULL
-#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))
-#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
-
-#define	SLIST_FOREACH(var, head, field)					\
-	for((var) = SLIST_FIRST(head);					\
-	    (var) != SLIST_END(head);					\
-	    (var) = SLIST_NEXT(var, field))
-
-#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = SLIST_FIRST(head);				\
-	    (var) && ((tvar) = SLIST_NEXT(var, field), 1);		\
-	    (var) = (tvar))
-
-/*
- * Singly-linked List functions.
- */
-#define	SLIST_INIT(head) {						\
-	SLIST_FIRST(head) = SLIST_END(head);				\
-}
-
-#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
-	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
-	(slistelm)->field.sle_next = (elm);				\
-} while (0)
-
-#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
-	(elm)->field.sle_next = (head)->slh_first;			\
-	(head)->slh_first = (elm);					\
-} while (0)
-
-#define	SLIST_REMOVE_AFTER(elm, field) do {				\
-	(elm)->field.sle_next = (elm)->field.sle_next->field.sle_next;	\
-} while (0)
-
-#define	SLIST_REMOVE_HEAD(head, field) do {				\
-	(head)->slh_first = (head)->slh_first->field.sle_next;		\
-} while (0)
-
-#define SLIST_REMOVE(head, elm, type, field) do {			\
-	if ((head)->slh_first == (elm)) {				\
-		SLIST_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->slh_first;		\
-									\
-		while (curelm->field.sle_next != (elm))			\
-			curelm = curelm->field.sle_next;		\
-		curelm->field.sle_next =				\
-		    curelm->field.sle_next->field.sle_next;		\
-		_Q_INVALIDATE((elm)->field.sle_next);			\
-	}								\
-} while (0)
-
-/*
- * List definitions.
- */
-#define LIST_HEAD(name, type)						\
-struct name {								\
-	struct type *lh_first;	/* first element */			\
-}
-
-#define LIST_HEAD_INITIALIZER(head)					\
-	{ NULL }
-
-#define LIST_ENTRY(type)						\
-struct {								\
-	struct type *le_next;	/* next element */			\
-	struct type **le_prev;	/* address of previous next element */	\
-}
-
-/*
- * List access methods
- */
-#define	LIST_FIRST(head)		((head)->lh_first)
-#define	LIST_END(head)			NULL
-#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))
-#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
-
-#define LIST_FOREACH(var, head, field)					\
-	for((var) = LIST_FIRST(head);					\
-	    (var)!= LIST_END(head);					\
-	    (var) = LIST_NEXT(var, field))
-
-#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = LIST_FIRST(head);				\
-	    (var) && ((tvar) = LIST_NEXT(var, field), 1);		\
-	    (var) = (tvar))
-
-/*
- * List functions.
- */
-#define	LIST_INIT(head) do {						\
-	LIST_FIRST(head) = LIST_END(head);				\
-} while (0)
-
-#define LIST_INSERT_AFTER(listelm, elm, field) do {			\
-	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\
-		(listelm)->field.le_next->field.le_prev =		\
-		    &(elm)->field.le_next;				\
-	(listelm)->field.le_next = (elm);				\
-	(elm)->field.le_prev = &(listelm)->field.le_next;		\
-} while (0)
-
-#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
-	(elm)->field.le_prev = (listelm)->field.le_prev;		\
-	(elm)->field.le_next = (listelm);				\
-	*(listelm)->field.le_prev = (elm);				\
-	(listelm)->field.le_prev = &(elm)->field.le_next;		\
-} while (0)
-
-#define LIST_INSERT_HEAD(head, elm, field) do {				\
-	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\
-		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
-	(head)->lh_first = (elm);					\
-	(elm)->field.le_prev = &(head)->lh_first;			\
-} while (0)
-
-#define LIST_REMOVE(elm, field) do {					\
-	if ((elm)->field.le_next != NULL)				\
-		(elm)->field.le_next->field.le_prev =			\
-		    (elm)->field.le_prev;				\
-	*(elm)->field.le_prev = (elm)->field.le_next;			\
-	_Q_INVALIDATE((elm)->field.le_prev);				\
-	_Q_INVALIDATE((elm)->field.le_next);				\
-} while (0)
-
-#define LIST_REPLACE(elm, elm2, field) do {				\
-	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
-		(elm2)->field.le_next->field.le_prev =			\
-		    &(elm2)->field.le_next;				\
-	(elm2)->field.le_prev = (elm)->field.le_prev;			\
-	*(elm2)->field.le_prev = (elm2);				\
-	_Q_INVALIDATE((elm)->field.le_prev);				\
-	_Q_INVALIDATE((elm)->field.le_next);				\
-} while (0)
-
-/*
- * Simple queue definitions.
- */
-#define SIMPLEQ_HEAD(name, type)					\
-struct name {								\
-	struct type *sqh_first;	/* first element */			\
-	struct type **sqh_last;	/* addr of last next element */		\
-}
-
-#define SIMPLEQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).sqh_first }
-
-#define SIMPLEQ_ENTRY(type)						\
-struct {								\
-	struct type *sqe_next;	/* next element */			\
-}
-
-/*
- * Simple queue access methods.
- */
-#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)
-#define	SIMPLEQ_END(head)	    NULL
-#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
-#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)
-
-#define SIMPLEQ_FOREACH(var, head, field)				\
-	for((var) = SIMPLEQ_FIRST(head);				\
-	    (var) != SIMPLEQ_END(head);					\
-	    (var) = SIMPLEQ_NEXT(var, field))
-
-#define	SIMPLEQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = SIMPLEQ_FIRST(head);				\
-	    (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1);		\
-	    (var) = (tvar))
-
-/*
- * Simple queue functions.
- */
-#define	SIMPLEQ_INIT(head) do {						\
-	(head)->sqh_first = NULL;					\
-	(head)->sqh_last = &(head)->sqh_first;				\
-} while (0)
-
-#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
-		(head)->sqh_last = &(elm)->field.sqe_next;		\
-	(head)->sqh_first = (elm);					\
-} while (0)
-
-#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.sqe_next = NULL;					\
-	*(head)->sqh_last = (elm);					\
-	(head)->sqh_last = &(elm)->field.sqe_next;			\
-} while (0)
-
-#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
-		(head)->sqh_last = &(elm)->field.sqe_next;		\
-	(listelm)->field.sqe_next = (elm);				\
-} while (0)
-
-#define SIMPLEQ_REMOVE_HEAD(head, field) do {			\
-	if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
-		(head)->sqh_last = &(head)->sqh_first;			\
-} while (0)
-
-#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
-	if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
-	    == NULL)							\
-		(head)->sqh_last = &(elm)->field.sqe_next;		\
-} while (0)
-
-/*
- * XOR Simple queue definitions.
- */
-#define XSIMPLEQ_HEAD(name, type)					\
-struct name {								\
-	struct type *sqx_first;	/* first element */			\
-	struct type **sqx_last;	/* addr of last next element */		\
-	unsigned long sqx_cookie;					\
-}
-
-#define XSIMPLEQ_ENTRY(type)						\
-struct {								\
-	struct type *sqx_next;	/* next element */			\
-}
-
-/*
- * XOR Simple queue access methods.
- */
-#define XSIMPLEQ_XOR(head, ptr)	    ((__typeof(ptr))((head)->sqx_cookie ^ \
-					(unsigned long)(ptr)))
-#define	XSIMPLEQ_FIRST(head)	    XSIMPLEQ_XOR(head, ((head)->sqx_first))
-#define	XSIMPLEQ_END(head)	    NULL
-#define	XSIMPLEQ_EMPTY(head)	    (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head))
-#define	XSIMPLEQ_NEXT(head, elm, field)    XSIMPLEQ_XOR(head, ((elm)->field.sqx_next))
-
-
-#define XSIMPLEQ_FOREACH(var, head, field)				\
-	for ((var) = XSIMPLEQ_FIRST(head);				\
-	    (var) != XSIMPLEQ_END(head);				\
-	    (var) = XSIMPLEQ_NEXT(head, var, field))
-
-#define	XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = XSIMPLEQ_FIRST(head);				\
-	    (var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1);	\
-	    (var) = (tvar))
-
-/*
- * XOR Simple queue functions.
- */
-#define	XSIMPLEQ_INIT(head) do {					\
-	arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \
-	(head)->sqx_first = XSIMPLEQ_XOR(head, NULL);			\
-	(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first);	\
-} while (0)
-
-#define XSIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.sqx_next = (head)->sqx_first) ==		\
-	    XSIMPLEQ_XOR(head, NULL))					\
-		(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
-	(head)->sqx_first = XSIMPLEQ_XOR(head, (elm));			\
-} while (0)
-
-#define XSIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.sqx_next = XSIMPLEQ_XOR(head, NULL);		\
-	*(XSIMPLEQ_XOR(head, (head)->sqx_last)) = XSIMPLEQ_XOR(head, (elm)); \
-	(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next);	\
-} while (0)
-
-#define XSIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.sqx_next = (listelm)->field.sqx_next) ==	\
-	    XSIMPLEQ_XOR(head, NULL))					\
-		(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
-	(listelm)->field.sqx_next = XSIMPLEQ_XOR(head, (elm));		\
-} while (0)
-
-#define XSIMPLEQ_REMOVE_HEAD(head, field) do {				\
-	if (((head)->sqx_first = XSIMPLEQ_XOR(head,			\
-	    (head)->sqx_first)->field.sqx_next) == XSIMPLEQ_XOR(head, NULL)) \
-		(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \
-} while (0)
-
-#define XSIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
-	if (((elm)->field.sqx_next = XSIMPLEQ_XOR(head,			\
-	    (elm)->field.sqx_next)->field.sqx_next)			\
-	    == XSIMPLEQ_XOR(head, NULL))				\
-		(head)->sqx_last = 					\
-		    XSIMPLEQ_XOR(head, &(elm)->field.sqx_next);		\
-} while (0)
-
-		    
-/*
- * Tail queue definitions.
- */
-#define TAILQ_HEAD(name, type)						\
-struct name {								\
-	struct type *tqh_first;	/* first element */			\
-	struct type **tqh_last;	/* addr of last next element */		\
-}
-
-#define TAILQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).tqh_first }
-
-#define TAILQ_ENTRY(type)						\
-struct {								\
-	struct type *tqe_next;	/* next element */			\
-	struct type **tqe_prev;	/* address of previous next element */	\
-}
-
-/* 
- * tail queue access methods 
- */
-#define	TAILQ_FIRST(head)		((head)->tqh_first)
-#define	TAILQ_END(head)			NULL
-#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
-#define TAILQ_LAST(head, headname)					\
-	(*(((struct headname *)((head)->tqh_last))->tqh_last))
-/* XXX */
-#define TAILQ_PREV(elm, headname, field)				\
-	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-#define	TAILQ_EMPTY(head)						\
-	(TAILQ_FIRST(head) == TAILQ_END(head))
-
-#define TAILQ_FOREACH(var, head, field)					\
-	for((var) = TAILQ_FIRST(head);					\
-	    (var) != TAILQ_END(head);					\
-	    (var) = TAILQ_NEXT(var, field))
-
-#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = TAILQ_FIRST(head);					\
-	    (var) != TAILQ_END(head) &&					\
-	    ((tvar) = TAILQ_NEXT(var, field), 1);			\
-	    (var) = (tvar))
-
-
-#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
-	for((var) = TAILQ_LAST(head, headname);				\
-	    (var) != TAILQ_END(head);					\
-	    (var) = TAILQ_PREV(var, headname, field))
-
-#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
-	for ((var) = TAILQ_LAST(head, headname);			\
-	    (var) != TAILQ_END(head) &&					\
-	    ((tvar) = TAILQ_PREV(var, headname, field), 1);		\
-	    (var) = (tvar))
-
-/*
- * Tail queue functions.
- */
-#define	TAILQ_INIT(head) do {						\
-	(head)->tqh_first = NULL;					\
-	(head)->tqh_last = &(head)->tqh_first;				\
-} while (0)
-
-#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
-		(head)->tqh_first->field.tqe_prev =			\
-		    &(elm)->field.tqe_next;				\
-	else								\
-		(head)->tqh_last = &(elm)->field.tqe_next;		\
-	(head)->tqh_first = (elm);					\
-	(elm)->field.tqe_prev = &(head)->tqh_first;			\
-} while (0)
-
-#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.tqe_next = NULL;					\
-	(elm)->field.tqe_prev = (head)->tqh_last;			\
-	*(head)->tqh_last = (elm);					\
-	(head)->tqh_last = &(elm)->field.tqe_next;			\
-} while (0)
-
-#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
-		(elm)->field.tqe_next->field.tqe_prev =			\
-		    &(elm)->field.tqe_next;				\
-	else								\
-		(head)->tqh_last = &(elm)->field.tqe_next;		\
-	(listelm)->field.tqe_next = (elm);				\
-	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
-} while (0)
-
-#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
-	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
-	(elm)->field.tqe_next = (listelm);				\
-	*(listelm)->field.tqe_prev = (elm);				\
-	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
-} while (0)
-
-#define TAILQ_REMOVE(head, elm, field) do {				\
-	if (((elm)->field.tqe_next) != NULL)				\
-		(elm)->field.tqe_next->field.tqe_prev =			\
-		    (elm)->field.tqe_prev;				\
-	else								\
-		(head)->tqh_last = (elm)->field.tqe_prev;		\
-	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
-	_Q_INVALIDATE((elm)->field.tqe_prev);				\
-	_Q_INVALIDATE((elm)->field.tqe_next);				\
-} while (0)
-
-#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
-	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
-		(elm2)->field.tqe_next->field.tqe_prev =		\
-		    &(elm2)->field.tqe_next;				\
-	else								\
-		(head)->tqh_last = &(elm2)->field.tqe_next;		\
-	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
-	*(elm2)->field.tqe_prev = (elm2);				\
-	_Q_INVALIDATE((elm)->field.tqe_prev);				\
-	_Q_INVALIDATE((elm)->field.tqe_next);				\
-} while (0)
-
-/*
- * Circular queue definitions.
- */
-#define CIRCLEQ_HEAD(name, type)					\
-struct name {								\
-	struct type *cqh_first;		/* first element */		\
-	struct type *cqh_last;		/* last element */		\
-}
-
-#define CIRCLEQ_HEAD_INITIALIZER(head)					\
-	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
-
-#define CIRCLEQ_ENTRY(type)						\
-struct {								\
-	struct type *cqe_next;		/* next element */		\
-	struct type *cqe_prev;		/* previous element */		\
-}
-
-/*
- * Circular queue access methods 
- */
-#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
-#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
-#define	CIRCLEQ_END(head)		((void *)(head))
-#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
-#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
-#define	CIRCLEQ_EMPTY(head)						\
-	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))
-
-#define CIRCLEQ_FOREACH(var, head, field)				\
-	for((var) = CIRCLEQ_FIRST(head);				\
-	    (var) != CIRCLEQ_END(head);					\
-	    (var) = CIRCLEQ_NEXT(var, field))
-
-#define	CIRCLEQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = CIRCLEQ_FIRST(head);				\
-	    (var) != CIRCLEQ_END(head) &&				\
-	    ((tvar) = CIRCLEQ_NEXT(var, field), 1);			\
-	    (var) = (tvar))
-
-#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
-	for((var) = CIRCLEQ_LAST(head);					\
-	    (var) != CIRCLEQ_END(head);					\
-	    (var) = CIRCLEQ_PREV(var, field))
-
-#define	CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
-	for ((var) = CIRCLEQ_LAST(head, headname);			\
-	    (var) != CIRCLEQ_END(head) && 				\
-	    ((tvar) = CIRCLEQ_PREV(var, headname, field), 1);		\
-	    (var) = (tvar))
-
-/*
- * Circular queue functions.
- */
-#define	CIRCLEQ_INIT(head) do {						\
-	(head)->cqh_first = CIRCLEQ_END(head);				\
-	(head)->cqh_last = CIRCLEQ_END(head);				\
-} while (0)
-
-#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
-	(elm)->field.cqe_prev = (listelm);				\
-	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\
-		(head)->cqh_last = (elm);				\
-	else								\
-		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
-	(listelm)->field.cqe_next = (elm);				\
-} while (0)
-
-#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
-	(elm)->field.cqe_next = (listelm);				\
-	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
-	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\
-		(head)->cqh_first = (elm);				\
-	else								\
-		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
-	(listelm)->field.cqe_prev = (elm);				\
-} while (0)
-
-#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
-	(elm)->field.cqe_next = (head)->cqh_first;			\
-	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
-	if ((head)->cqh_last == CIRCLEQ_END(head))			\
-		(head)->cqh_last = (elm);				\
-	else								\
-		(head)->cqh_first->field.cqe_prev = (elm);		\
-	(head)->cqh_first = (elm);					\
-} while (0)
-
-#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
-	(elm)->field.cqe_prev = (head)->cqh_last;			\
-	if ((head)->cqh_first == CIRCLEQ_END(head))			\
-		(head)->cqh_first = (elm);				\
-	else								\
-		(head)->cqh_last->field.cqe_next = (elm);		\
-	(head)->cqh_last = (elm);					\
-} while (0)
-
-#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
-	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\
-		(head)->cqh_last = (elm)->field.cqe_prev;		\
-	else								\
-		(elm)->field.cqe_next->field.cqe_prev =			\
-		    (elm)->field.cqe_prev;				\
-	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\
-		(head)->cqh_first = (elm)->field.cqe_next;		\
-	else								\
-		(elm)->field.cqe_prev->field.cqe_next =			\
-		    (elm)->field.cqe_next;				\
-	_Q_INVALIDATE((elm)->field.cqe_prev);				\
-	_Q_INVALIDATE((elm)->field.cqe_next);				\
-} while (0)
-
-#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\
-	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\
-	    CIRCLEQ_END(head))						\
-		(head)->cqh_last = (elm2);				\
-	else								\
-		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\
-	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\
-	    CIRCLEQ_END(head))						\
-		(head)->cqh_first = (elm2);				\
-	else								\
-		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\
-	_Q_INVALIDATE((elm)->field.cqe_prev);				\
-	_Q_INVALIDATE((elm)->field.cqe_next);				\
-} while (0)
-
-#endif	/* !_SYS_QUEUE_H_ */

src/signal.c

@@ -91,9 +91,6 @@ int uev_signal_set(uev_t *w, int signo)
 
 	/* Handle stopped signal watchers */
 	if (w->fd < 0) {
-		/* Remove from internal list */
-		LIST_REMOVE(w, link);
-
 		if (uev_signal_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, signo))
 			return -1;
 	}
@@ -140,6 +137,9 @@ int uev_signal_start(uev_t *w)
  */
 int uev_signal_stop(uev_t *w)
 {
+	if (!_uev_watcher_active(w))
+		return 0;
+
 	if (_uev_watcher_stop(w))
 		return -1;
 

src/timer.c

@@ -121,9 +121,6 @@ int uev_timer_set(uev_t *w, int timeout, int period)
 		if (!timeout && !period)
 			return 0;
 
-		/* Remove from internal list */
-		LIST_REMOVE(w, link);
-
 		if (uev_timer_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, timeout, period))
 			return -1;
 	}
@@ -170,17 +167,12 @@ int uev_timer_start(uev_t *w)
  */
 int uev_timer_stop(uev_t *w)
 {
-	/* Check if already stopped in uev_run() after cb() or _init() */
 	if (!_uev_watcher_active(w))
 		return 0;
 
-	/* Stop kernel timer */
-	uev_timer_set(w, 0, 0);
-
 	if (_uev_watcher_stop(w))
 		return -1;
 
-	/* Close timerfd, will have to be reopened again on reset */
 	close(w->fd);
 	w->fd = -1;
 

src/uev.c

@@ -33,8 +33,6 @@
 
 #include "uev.h"
 
-#define UNUSED(arg) arg __attribute__ ((unused))
-
 
 static int _init(uev_ctx_t *ctx, int close_old)
 {
@@ -92,7 +90,7 @@ int _uev_watcher_start(uev_t *w)
 {
 	struct epoll_event ev;
 
-	if (!w || w->fd < 0) {
+	if (!w || w->fd < 0 || !w->ctx) {
 		errno = EINVAL;
 		return -1;
 	}
@@ -121,7 +119,7 @@ int _uev_watcher_start(uev_t *w)
 	}
 
 	/* Add to internal list for bookkeeping */
-	LIST_INSERT_HEAD(&w->ctx->watchers, w, link);
+	_UEV_INSERT(w, w->ctx->watchers);
 
 	return 0;
 }
@@ -140,7 +138,7 @@ int _uev_watcher_stop(uev_t *w)
 	w->active = 0;
 
 	/* Remove from internal list */
-	LIST_REMOVE(w, link);
+	_UEV_REMOVE(w, w->ctx->watchers);
 
 	/* Remove from kernel */
 	if (epoll_ctl(w->ctx->fd, EPOLL_CTL_DEL, w->fd, NULL) < 0)
@@ -180,17 +178,46 @@ int _uev_watcher_rearm(uev_t *w)
  * Create an event loop context
  * @param ctx  Pointer to an uev_ctx_t context to be initialized
  *
+ * This function calls @func uev_init1() with @param maxevents set to
+ * @const UEV_MAX_EVENTS.
+ *
  * @return POSIX OK(0) on success, or non-zero on error.
  */
 int uev_init(uev_ctx_t *ctx)
 {
-	if (!ctx) {
+	return uev_init1(ctx, UEV_MAX_EVENTS);
+}
+
+/**
+ * Create an event loop context
+ * @param ctx  Pointer to an uev_ctx_t context to be initialized
+ * @param maxevents Maximum number of events in event cache
+ *
+ * This function is the same as @func uev_init() except for the
+ * @param maxevents argument, which controls the number of events
+ * in the event cache returned to the main loop.
+ *
+ * In cases where you have multiple events pending in the cache and some
+ * event may cause later ones, already sent by the kernel to userspace,
+ * to be deleted the pointer returned to the event loop for this later
+ * event may be deleted.
+ *
+ * There are two ways around this (accessing deleted memory); 1) use
+ * this function to initialize your event loop and set @param maxevents
+ * to 1, 2) use a free list in you application that you garbage collect
+ * at intervals relevant to your application.
+ *
+ * @return POSIX OK(0) on success, or non-zero on error.
+ */
+int uev_init1(uev_ctx_t *ctx, int maxevents)
+{
+	if (!ctx || maxevents < 1) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	memset(ctx, 0, sizeof(*ctx));
-	LIST_INIT(&ctx->watchers);
+	ctx->maxevents = maxevents;
 
 	return _init(ctx, 0);
 }
@@ -203,16 +230,16 @@ int uev_init(uev_ctx_t *ctx)
  */
 int uev_exit(uev_ctx_t *ctx)
 {
+	uev_t *w;
+
 	if (!ctx) {
 		errno = EINVAL;
 		return -1;
 	}
 
-	while (!LIST_EMPTY(&ctx->watchers)) {
+	_UEV_FOREACH(w, ctx->watchers) {
-		uev_t *w = LIST_FIRST(&ctx->watchers);
-
 		/* Remove from internal list */
-		LIST_REMOVE(w, link);
+		_UEV_REMOVE(w, ctx->watchers);
 
 		if (!_uev_watcher_active(w))
 			continue;
@@ -233,8 +260,10 @@ int uev_exit(uev_ctx_t *ctx)
 		}
 	}
 
+	ctx->watchers = NULL;
 	ctx->running = 0;
-	close(ctx->fd);
+	if (ctx->fd > -1)
+		close(ctx->fd);
 	ctx->fd = -1;
 
 	return 0;
@@ -271,26 +300,26 @@ int uev_run(uev_ctx_t *ctx, int flags)
 	ctx->running = 1;
 
 	/* Start all dormant timers */
-	LIST_FOREACH(w, &ctx->watchers, link) {
+	_UEV_FOREACH(w, ctx->watchers) {
 		if (UEV_CRON_TYPE == w->type)
 			uev_cron_set(w, w->u.c.when, w->u.c.interval);
 		if (UEV_TIMER_TYPE == w->type)
 			uev_timer_set(w, w->u.t.timeout, w->u.t.period);
 	}
 
-	while (ctx->running && !LIST_EMPTY(&ctx->watchers)) {
+	while (ctx->running && ctx->watchers) {
 		int i, nfds, rerun = 0;
 		struct epoll_event ee[UEV_MAX_EVENTS];
 
 		/* Handle special case: `application < file.txt` */
 		if (ctx->workaround) {
-			LIST_FOREACH(w, &ctx->watchers, link) {
+			_UEV_FOREACH(w, ctx->watchers) {
 				if (w->active != -1 || !w->cb)
 					continue;
 
 				if (!has_data(w->fd)) {
 					w->active = 0;
-					LIST_REMOVE(w, link);
+					_UEV_REMOVE(w, ctx->watchers);
 				}
 
 				rerun++;
@@ -302,7 +331,7 @@ int uev_run(uev_ctx_t *ctx, int flags)
 			continue;
 		ctx->workaround = 0;
 
-		while ((nfds = epoll_wait(ctx->fd, ee, UEV_MAX_EVENTS, timeout)) < 0) {
+		while ((nfds = epoll_wait(ctx->fd, ee, ctx->maxevents, timeout)) < 0) {
 			if (!ctx->running)
 				break;
 
@@ -347,6 +376,8 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 				if (!w->u.t.period)
 					w->u.t.timeout = 0;
+				if (!w->u.t.timeout)
+					uev_timer_stop(w);
 				break;
 
 			case UEV_CRON_TYPE:
@@ -362,16 +393,9 @@ int uev_run(uev_ctx_t *ctx, int flags)
 					w->u.c.when = 0;
 				else
 					w->u.c.when += w->u.c.interval;
-				break;
-			}
-
-			if (UEV_CRON_TYPE == w->type) {
 				if (!w->u.c.when)
 					uev_timer_stop(w);
-			}
+				break;
-			if (UEV_TIMER_TYPE == w->type) {
-				if (!w->u.t.timeout)
-					uev_timer_stop(w);
 			}
 
 			/*

src/uev.h

@@ -76,6 +76,7 @@ typedef void (uev_cb_t)(uev_t *w, void *arg, int events);
 
 /* Public interface */
 int uev_init           (uev_ctx_t *ctx);
+int uev_init1          (uev_ctx_t *ctx, int maxevents);
 int uev_exit           (uev_ctx_t *ctx);
 int uev_run            (uev_ctx_t *ctx, int flags);
 

tests/.gitignore

@@ -1,6 +1,7 @@
 *.trs
 *.log
 active
+api
 complete
 cronrun
 signal

tests/Makefile.am

@@ -3,6 +3,7 @@ CLEANFILES      = *~ *.trs *.log
 
 TESTS           =
 TESTS          += active
+TESTS          += api
 TESTS          += complete
 TESTS          += cronrun
 TESTS          += signal
@@ -11,6 +12,6 @@ TESTS          += timer
 check_PROGRAMS  = $(TESTS)
 
 # Ignore warnings about unused result, in e.g. write()
-CFLAGS          = -W -Wall -Wextra -Wno-unused-result
+CFLAGS          = -W -Wall -Wextra -Wno-unused-result -Wno-unused-parameter
 CPPFLAGS        = -D_GNU_SOURCE
 LDADD           = -L../src ../src/libuev.la

tests/active.c

@@ -12,7 +12,7 @@ uev_t timer3;
 uev_t cron1;
 uev_t cron2;
 
-static void cb(uev_t *w, void *UNUSED(arg), int events)
+static void cb(uev_t *w, void *arg, int events)
 {
 	if (UEV_ERROR == events)
 		fprintf(stderr, "timer watcher failed, ignoring ...\n");
@@ -30,6 +30,9 @@ static void cb(uev_t *w, void *UNUSED(arg), int events)
 	fail_unless(!uev_timer_active(&timer2));
 	fail_unless(!uev_cron_active(&cron2));
 
+	/* Restart timer and see if we fail in uev_exit() */
+	uev_timer_start(&timer2);
+
 	uev_exit(w->ctx);
 }
 
@@ -52,3 +55,10 @@ int main(void)
 
 	return uev_run(&ctx, 0);
 }
+
+/**
+ * Local Variables:
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

tests/api.c

@@ -0,0 +1,34 @@
+#include "check.h"
+
+uev_t timer, file;
+int   counter = 10;
+
+static void cb(uev_t *w, void *arg, int events)
+{
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
+	if (counter--)
+		return;
+
+	uev_exit(w->ctx);
+}
+
+int main(void)
+{
+	uev_ctx_t ctx;
+	FILE *fp;
+
+	uev_init(&ctx);
+	uev_timer_init(&ctx, &timer, cb, NULL, 100, 100);
+
+	fp = fopen("/dev/one", "r");
+	if (fp)
+		uev_io_init(&ctx, &file, cb, NULL, fileno(fp), UEV_READ);
+
+	uev_run(&ctx, 0);
+
+	uev_exit(&ctx);	/* Should not hang event loop, troglobit/uftpd#16 */
+
+	return 0;
+}

tests/check.h

@@ -9,8 +9,6 @@
 
 #include "../src/uev.h"
 
-#define UNUSED(arg) arg __attribute__ ((unused))
-
 #define fail_unless(test)						\
   do {									\
     if (!(test)) {							\

tests/complete.c

@@ -55,12 +55,12 @@ static void timeout_cb(uev_t *w, void *arg, int events)
 	uev_exit(w->ctx);
 }
 
-static void periodic_task(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void periodic_task(uev_t *w, void *arg, int events)
 {
 	fprintf(stderr, "|");
 }
 
-static void signal_cb(uev_t *w, void *UNUSED(arg), int events)
+static void signal_cb(uev_t *w, void *arg, int events)
 {
 	if (UEV_ERROR == events) {
 		fprintf(stderr, "Signal watcher failed, unrecoverable error.\n");
@@ -70,7 +70,7 @@ static void signal_cb(uev_t *w, void *UNUSED(arg), int events)
 	fprintf(stderr, w->signo == SIGINT ? "^Cv" : "^\v");
 }
 
-static void pipe_read_cb(uev_t *w, void UNUSED(*arg), int events)
+static void pipe_read_cb(uev_t *w, void *arg, int events)
 {
 	int len;
 	char msg[50];
@@ -82,7 +82,7 @@ static void pipe_read_cb(uev_t *w, void UNUSED(*arg), int events)
 		return;
 	}
 
-        /* Kick watchdog */
+	/* Kick watchdog */
 	if (watchdog)
 		uev_timer_set(watchdog, 1000, 0);
 
@@ -102,7 +102,7 @@ static void pipe_read_cb(uev_t *w, void UNUSED(*arg), int events)
 	fprintf(stderr, "%.*s.%d ", len, msg, len);
 }
 
-static void pipe_write_cb(uev_t *w, void *arg, int UNUSED(events))
+static void pipe_write_cb(uev_t *w, void *arg, int events)
 {
 	my_t *my  = arg;
 	char *msg = "TESTING";
@@ -112,9 +112,9 @@ static void pipe_write_cb(uev_t *w, void *arg, int UNUSED(events))
 
 	/* Here we *must* use out, not w->fd, since we're a timer callback */
 	if (write(out, msg, my->counter) < 0) {
-                perror("\nFailed writing to pipe");
+		perror("\nFailed writing to pipe");
-                return;
+		return;
-        }
+	}
 
 //	fprintf(stderr, "WRITE %.*s %d\n", my->counter, msg, my->counter);
 	fprintf(stderr, "%d ", my->counter);
@@ -153,8 +153,10 @@ int main(void)
 	uev_io_init(&ctx, &reader, pipe_read_cb, NULL, in, UEV_READ);
 	uev_timer_init(&ctx, &writer, pipe_write_cb, &my, 400, 0);
 
-	/* Watchdog for the above timer callback, if it doesn't wake up
+	/*
-	 * and write to the pipe within a given deadline it will bark. */
+	 * Watchdog for the above timer callback, if it doesn't wake up
+	 * and write to the pipe within a given deadline it will bark.
+	 */
 	uev_timer_init(&ctx, &wdt, timeout_cb, (void *)(intptr_t)1, 950, 0);
 	watchdog = &wdt;
 

tests/cronrun.c

@@ -28,9 +28,10 @@
 #define TIMEOUT  2
 #define INTERVAL 2
 
+int result = -1;
 struct timeval tv;
 
-static void cron_job(uev_t *w, void *UNUSED(arg), int events)
+static void cron_job(uev_t *w, void *arg, int events)
 {
 	static int laps = 3;
 	struct timeval now;
@@ -45,12 +46,15 @@ static void cron_job(uev_t *w, void *UNUSED(arg), int events)
 	printf("Cron job HELO %s", ctime(&now.tv_sec));
 	fail_unless(now.tv_sec == tv.tv_sec);
 
-	if (!laps--)
+	if (!laps--) {
+		result = 0;
 		uev_exit(w->ctx);
+	}
 }
 
 int main(void)
 {
+	int rc;
 	uev_t cron_watcher;
 	uev_ctx_t ctx;
 	time_t when, interval;
@@ -66,7 +70,10 @@ int main(void)
 	interval = INTERVAL;
 	uev_cron_init(&ctx, &cron_watcher, cron_job, NULL, when, interval);
 
-	return uev_run(&ctx, 0);
+	rc = uev_run(&ctx, 0);
+	fail_unless(result == 0);
+
+	return rc;
 }
 
 /**

tests/signal.c

@@ -33,7 +33,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-#define UNUSED(arg) arg __attribute__ ((unused))
 #define DO_SEGFAULT 1
 
 typedef struct {
@@ -63,38 +62,38 @@ static int callback(arg_t *arg, int event, void *foo)
 	printf("child: segfaulting failed!\n");
 #endif
 
-        return 42;
+	return 42;
 }
 
-static void sigsegv_cb(uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+static void sigsegv_cb(uev_t *w, void *arg, int events)
 {
 	warnx("PID %d caused segfault.", getpid());
 	exit(-1);
 }
 
-static void sigchld_cb(uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+static void sigchld_cb(uev_t *w, void *arg, int events)
 {
-        pid_t pid = waitpid(-1, NULL, WNOHANG);
+	pid_t pid = waitpid(-1, NULL, WNOHANG);
 
-        if (-1 != pid)
+	if (-1 != pid)
-                warnx("PID %d exited, bye.", pid);
+		warnx("PID %d exited, bye.", pid);
 }
 
-static void work_cb(uev_t *UNUSED(w), void *arg, int UNUSED(events))
+static void work_cb(uev_t *w, void *arg, int events)
 {
 	int    status = 0;
-        pid_t  pid;
+	pid_t  pid;
 
-        pid = fork();
+	pid = fork();
-        if (-1 == pid)
+	if (-1 == pid)
-                err(1, "fork");
+		err(1, "fork");
 	if (!pid) {
 		status = callback(arg, 6137, NULL);
-                exit(status);
+		exit(status);
-        }
+	}
 
-        if (waitpid(pid, &status, 0) == -1)
+	if (waitpid(pid, &status, 0) == -1)
-                err(1, "waitpid");
+		err(1, "waitpid");
 
 	if (WIFEXITED(status))
 		printf("Child exited normally => %d\n", WEXITSTATUS(status));
@@ -106,9 +105,9 @@ static void work_cb(uev_t *UNUSED(w), void *arg, int UNUSED(events))
 		printf("Child did not exit normally!\n");
 }
 
-static void exit_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void exit_cb(uev_t *w, void *arg, int events)
 {
-        printf("Process deadline reached, exiting!\n");
+	printf("Process deadline reached, exiting!\n");
 	uev_exit(w->ctx);
 }
 

tests/timer.c

@@ -3,9 +3,11 @@
 #include <sys/time.h>
 
 #define TIMEOUT 2		/* 2 sec */
+
+int result = -1;
 struct timeval start;
 
-static void cb(uev_t *w, void *UNUSED(arg), int events)
+static void cb(uev_t *w, void *arg, int events)
 {
 	struct timeval now;
 
@@ -15,11 +17,13 @@ static void cb(uev_t *w, void *UNUSED(arg), int events)
 	gettimeofday(&now, NULL);
 	fail_unless(now.tv_sec == start.tv_sec + TIMEOUT);
 
+	result = 0;
 	uev_exit(w->ctx);
 }
 
 int main(void)
 {
+	int rc;
 	uev_t w;
 	uev_ctx_t ctx;
 
@@ -27,5 +31,15 @@ int main(void)
 	uev_timer_init(&ctx, &w, cb, NULL, TIMEOUT * 1000, 0);
 	gettimeofday(&start, NULL);
 
-	return uev_run(&ctx, 0);
+	rc = uev_run(&ctx, 0);
+	fail_unless(result == 0);
+
+	return rc;
 }
+
+/**
+ * Local Variables:
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */