Update ChangeLog and bump version for v2.3.0 release

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

.gitignore

@@ -7,8 +7,14 @@
 *.la
 *.lo
 *.html
+.config
 .deps
 .libs
+.unpacked
+ID
+GTAGS
+GRTAGS
+GPATH
 compile
 config.*
 configure
@@ -27,4 +33,4 @@ bench
 libuev*.tar.*
 libuev.pc
 !libuev.pc.in
-test-driver
+test-driver

.travis.yml

@@ -5,6 +5,11 @@ language: c
 # Use docker for quicker builds, it now allows https://docs.travis-ci.com/user/apt/
 sudo: false
 
+# Test build with both GCC and Clang (LLVM)
+compiler:
+  - gcc
+  - clang
+
 env:
   global:
    # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
@@ -17,13 +22,13 @@ addons:
       name: "troglobit/libuev"
       description: "libuEv | Simple event loop for Linux"
     notification_email: troglobit@gmail.com
-    build_command_prepend: "./autogen && ./configure"
+    build_command_prepend: "./autogen.sh && ./configure --enable-examples"
     build_command: "make clean all"
     branch_pattern: dev
 
 script:
   - ./autogen.sh
-  - ./configure --disable-silent-rules
+  - ./configure --disable-silent-rules --enable-examples
   - make clean
   - make -j5
   - make check

API.md

@@ -11,13 +11,21 @@ API Documentation
 * [Joystick Example](#joystick-example)
 
 
+> “Event driven software improves concurrency” -- [Dave Zarzycki, Apple][]
+
 Introduction
 ------------
 
 The C API to [libuEv][], listed in `uev/uev.h`, handles three different
-types of events: I/O (files, sockets, message queues, etc.), timers, and
+types of events: I/O (pipes, sockets, message queues, etc.), timers, and
 signals.  The [Summary](#summary) details a slight caveat on signals.
 
+Notice the *lack of support for regular files* and directories.  This is
+a limitation of the underlying Linux `epoll` interface which will return
+`EPERM` for regular files.  Except for the special case when `stdin` is
+redirected from the command line.  See `examples/redirect.c` for more on
+this particular case.
+
 Timers can be either relative, timeout in milliseconds, or absolute with
 a time given in `time_t`, see `mktime()` et al.  Absolute timers are
 called cron timers and their callbacks get an `UEV_HUP` error event if
@@ -39,11 +47,17 @@ Overview
  * w->fd holds the file descriptor or socket, and events is set by
  * libuEv to indicate status: UEV_READ and/or UEV_WRITE with any of
  * the optional UEV_HUP, UEV_RDHUP, or UEV_PRI for urgent read data.
+ *
+ * Note: UEV_ERROR may be returned for any watcher and must be checked
+ *       by all callbacks.  I/O watchers may also need to check UEV_HUP.
+ *       Appropriate action, e.g. restart the watcher, is up to the
+ *       application and is thus delegated to the callback.
  */
 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 */
 
@@ -56,7 +70,7 @@ int uev_io_set      (uev_t *w, int fd, int events);
 int uev_io_start    (uev_t *w);
 int uev_io_stop     (uev_t *w);
 
-/* Timer watcher:   schedule a relative timer, timeout and period in milliseconds */
+/* Timer watcher:   schedule a relative timer, timeout (must be non-zero) and period in milliseconds */
 int uev_timer_init  (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeout, int period);
 int uev_timer_set   (uev_t *w, int timeout, int period); /* Change timeout or period */
 int uev_timer_start (uev_t *w);                          /* Restart a stopped timer */
@@ -73,6 +87,11 @@ int uev_signal_init (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int sign
 int uev_signal_set  (uev_t *w, int signo);               /* Change signal to wait for */
 int uev_signal_start(uev_t *w);                          /* Restart a stopped signal watcher */
 int uev_signal_stop (uev_t *w);                          /* Stop signal watcher */
+
+/* Generic event watcher, post events for later processing, or from forked child */
+int uev_event_init  (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg);
+int uev_event_post  (uev_t *w);
+int uev_event_stop  (uev_t *w);
 ```
 
 
@@ -91,16 +110,20 @@ uev_init(&ctx);
 
 ### Register an Event Watcher
 
-For each event to monitor, be it a signal, timer or file descriptor, a
-*watcher* must be registered with the event context.  The watcher, an
-`uev_t`, is registered by calling the event type's `_init()` function
-with the `uev_ctx_t` context, the callback, and an optional argument.
+For each event to monitor, be it a signal, cron/timer or a file/network
+descriptor, a *watcher* must be registered with the event context.  The
+watcher, an `uev_t`, is registered by calling the event type's `_init()`
+function with the `uev_ctx_t` context, the callback, and an optional
+argument.
 
 Here is a signal example:
 
 ```C
 void cleanup_exit(uev_t *w, void *arg, int events)
 {
+    if (UEV_ERROR == events)
+	    puts("Ignoring signal watcher error ...");
+
     /* Graceful exit, with optional cleanup ... */
     uev_exit(w->ctx);
 }
@@ -117,6 +140,17 @@ int main(void)
 }
 ```
 
+Notice that the callback must be prepared to handle `UEV_ERROR`.  I/O
+watchers in particular, but also timer watchers, must be restarted if
+required by the application.  libuEv automatically tries to restart a
+signal watcher, but should that fail the callback will return error as
+well.
+
+I/O watchers should also check for `UEV_HUP`, preferably when handling
+any short `read()` or `write()` system calls.  A short read on a socket
+may be due to the remote end having performed a `shutdown()`.  This is
+signaled to the callback using `UEV_HUP` in the `events` mask.
+
 
 ### Start Event Loop
 
@@ -127,13 +161,24 @@ used to integrate [libuEv][] into another event loop.
 In this example we set `flags` to none:
 
 ```C
-uev_run(&ctx, UEV_NONE);
+result = uev_run(&ctx, UEV_NONE);
 ```
 
 With `flags` set to `UEV_ONCE` the event loop returns as soon as it has
 served the first event.  If `flags` is set to `UEV_ONCE | UEV_NONBLOCK`
 the event loop returns immediately if no event is available.
 
+```
+if (result < 0)
+    errx(result, "Unrecoverable event loop error, error %d", result);
+```
+
+If the call to `uev_run()` fails you should notify the user somehow.
+libuEv fails if there is an invalid pointer, if `uev_init()` was not
+called, or recurring `epoll()` errors thare are impossible to recover
+from should occur.  This is true for individual watchers as well, in
+particular signal and timer watchers which can fail in miserable ways.
+
 **Note:** libuEv handles many types of errors, stream close, or peer
 shutdowns internally, but also lets the callback run.  This is useful
 for stateful connections to be able to detect EOF.
@@ -143,8 +188,16 @@ for stateful connections to be able to detect EOF.
 1. Set up an event context with `uev_init()`
 2. Register event callbacks with the event context using
    `uev_io_init()`, `uev_signal_init()` or `uev_timer_init()`
-3. Start the event loop with `uev_run()`
-4. Exit the event loop with `uev_exit()`, possibly from a callback
+3. Make sure callbacks checks their `events` mask and handles:
+
+   - `UEV_ERROR`, e.g. I/O watchers must be restarted
+   - `UEV_HUP`, reading any remaining data on the descriptor
+
+   In both of these cases the watcher is stopped by libuEv.  On HUP the
+   descriptor/connection must be reopened and the watcher reinitialized
+   with `uev_io_set()`, if required by the application.
+4. Start the event loop with `uev_run()`
+5. Exit the event loop with `uev_exit()`, possibly from a callback
 
 **Note 1:** Make sure to use non-blocking stream I/O!  Most hard to find
   bugs in event driven applications are due to sockets and files being
@@ -167,7 +220,7 @@ for stateful connections to be able to detect EOF.
 Using -luev
 -----------
 
-LibuEv is by default installed as a library with a few header files, you
+libuEv is by default installed as a library with a few header files, you
 should only ever need to include one:
 
 ```C
@@ -221,9 +274,32 @@ struct js_event {
     uint8_t  number;    /* axis/button number */
 } e;
 
+/*
+ * Called on any joystick event
+ *
+ * Note: We handle errors here by exiting, for a background daemon with
+ *       multiple watchers you may want another approach.
+ */
 static void joystick_cb(uev_t *w, void *arg, int events)
 {
-    read(w->fd, &e, sizeof(e));
+    ssize_t cnt;
+
+    if (UEV_ERROR == events) {
+        /* Possibly joystick was unplugged */
+        warnx("Spurious problem with the joystick watcher, restarting.");
+        uev_io_start(w);
+    }
+
+    cnt = read(w->fd, &e, sizeof(e));
+    if (cnt < 0) {
+        warn("Failed reading joystick event");
+        return;
+    }
+
+    if (cnt == 0 || UEV_HUP == events) {
+        warn("Joystick disconnected");
+        return;
+    }
 
     switch (e.type) {
     case 1:
@@ -238,16 +314,16 @@ static void joystick_cb(uev_t *w, void *arg, int events)
 
 int main(void)
 {
-    int fd;
-    uev_t watcher;
     uev_ctx_t ctx;
+    uev_t js;
+    int fd;
 
-    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.");
 
     uev_init(&ctx);
-    uev_io_init(&ctx, &watcher, joystick_cb, NULL, fd, UEV_READ);
+    uev_io_init(&ctx, &js, joystick_cb, NULL, fd, UEV_READ);
 
     puts("Starting, press Ctrl-C to exit.");
 
@@ -279,5 +355,6 @@ library) for [reference benchmarks][7] against [libevent][1] and
 [5]:      https://github.com/troglobit/uftpd
 [6]:      https://github.com/troglobit/finit
 [7]:      http://libev.schmorp.de/bench.html
-[LibuEv]: https://github.com/troglobit/libuev
+[libuEv]: https://github.com/troglobit/libuev
 [GLIBC workaround]: https://sourceware.org/glibc/wiki/Y2038ProofnessDesign
+[Dave Zarzycki, Apple]: http://www.youtube.com/watch?v=cD_s6Fjdri8

ChangeLog.md

@@ -4,6 +4,118 @@ Change Log
 All notable changes to the project are documented in this file.
 
 
+[v2.3.0][] - 2019-04-06
+-----------------------
+
+### Changes
+
+- Support for Linux eventfd, `uev_event_*()` see [API.md][] for details
+
+
+[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
+-----------------------
+
+### Fixes
+- Fix use after free in main event loop if watcher deletes itself in
+  the callback.  I.e., the callback must be the last action for the
+  watcher in the event loop.
+- Doc timer example fix by @tisyang
+- Doc timer updates, non-zero timeout required
+
+
+[v2.1.0][] - 2017-11-14
+-----------------------
+
+### Changes
+- Remove event loop error tracking used to trigger a `epoll_create1()`
+  at a certain error threshold.  This tracking was first introduced in
+  [v1.1.0][], triggered by spurious `EPOLLERR` on I/O watchers
+- Unconditionally stop I/O watchers that return `EPOLLERR` or `EPOLLHUP`
+  it is up to the watcher callback to clear the error and/or `read()`
+  the last few bytes from the descriptor.  HUP usally means EOF, or that
+  the remote end of a stream or pipe closed, this may also be signaled
+  by `read()` returning zero
+- Add missing `--enable-examples` to `configure` script
+- Update documentation, both [README.md][] and [API.md][]
+
+### Fixes
+- Properly stop and de-register signal and cron/timer watchers from the
+  epoll socket in case of errors, problem introduced in [v2.0.0][]
+- Mark watcher file descriptor as unintialized on internal error
+- Fix double-close of cron/timer watchers.  Problem triggered when the
+  timer expires and calls `uev_exit()`, which stops all watchers.  When
+  the timer callback returns another call to stop the watcher triggered
+  the double `close()`
+- Fix unit test's error handling in watcher callbacks, for reference
+- Fix use-before-set in cronrun unit test
+- Make sure to restart unit test's I/O watchers on `UEV_ERROR`
+- Make sure to restart example I/O watchers on `UEV_ERROR`
+- Properly check for `UEV_HUP` in unit tests and examples
+
+
+[v2.0.0][] - 2017-11-11
+-----------------------
+
+Beware, this is a major release, introducing incompatible changes to the
+failure modes of `uev_run()` and watcher callbacks.  Most users will most
+likely not notice any difference, but please read on.
+
+### Changes
+- `uev_run()` no longer exits the main event loop if an unrecoverable
+  error with a watcher occurs.  Instead, the watcher is disabled and the
+  callback is run one last time with `events` set to `UEV_ERROR`
+- Watcher callbacks must handle `UEV_ERROR` conditions.  This pertains
+  in particular to signal and timer watchers
+- Examples and API docs updated with the new failure modes
+
+
 [v1.6.0][] - 2017-09-18
 -----------------------
 
@@ -36,7 +148,7 @@ All notable changes to the project are documented in this file.
 
 ### Changes
 - Add support for absolute timers with the `uev_cron_*()` API.
-- Update build & install instructions in README
+- Update build & install instructions in [README.md][]
 
 ### Fixes
 - Fix `uev_timer_set()` so that it returns error in case the underlying
@@ -78,7 +190,7 @@ introduced in [v1.2.1][].  Apologies for any problems this may cause!
   `pkg-config` your C program must now `#include <uev/uev.h>`
 - Support for `EPOLLPRI` events for I/O watchers, thanks to Markus Svilans
 - Simplified joystick example
-- Updated `README` slightly
+- Updated [README.md][] slightly
 
 
 [v1.3.1][] - 2016-02-02
@@ -86,7 +198,7 @@ introduced in [v1.2.1][].  Apologies for any problems this may cause!
 
 ### Fixes
 - Remove symlinks to Markdown files from GIT
-- Distribute and install Markdown files: README.md, etc.
+- Distribute and install Markdown files: [README.md][], etc.
 
 
 [v1.3.0][] - 2016-01-22
@@ -122,7 +234,7 @@ Very minor release.
 - Dropped [TODO.md][] from distribution archives, only for devs
 
 ### Fixes
-- Lots of Markdown syntax fixes in both README and ChangeLog
+- Lots of Markdown syntax fixes in both [README.md][] and ChangeLog
 - Silence annoying warning from newer GNU ar in Ubuntu 15.10
 
 
@@ -280,7 +392,18 @@ v0.0.1 - 2012-03-17
 Lua users mailing list.
 
 
-[UNRELEASED]: https://github.com/troglobit/libuev/compare/v1.4.2...HEAD
+[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.3.0...HEAD
+[v2.3.0]: https://github.com/troglobit/libuev/compare/v2.2.0...v2.3.0
+[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
+[v1.6.0]: https://github.com/troglobit/libuev/compare/v1.5.2...v1.6.0
+[v1.5.2]: https://github.com/troglobit/libuev/compare/v1.5.1...v1.5.2
+[v1.5.1]: https://github.com/troglobit/libuev/compare/v1.5.0...v1.5.1
+[v1.5.0]: https://github.com/troglobit/libuev/compare/v1.4.2...v1.5.0
 [v1.4.2]: https://github.com/troglobit/libuev/compare/v1.4.1...v1.4.2
 [v1.4.1]: https://github.com/troglobit/libuev/compare/v1.4.0...v1.4.1
 [v1.4.0]: https://github.com/troglobit/libuev/compare/v1.3.1...v1.4.0
@@ -298,6 +421,7 @@ Lua users mailing list.
 [v1.0.1]: https://github.com/troglobit/libuev/compare/v1.0.0...v1.0.1
 [v1.0.0]: https://github.com/troglobit/libuev/compare/v0.0.1...v1.0.0
 [TODO.md]: https://github.com/troglobit/libuev/blob/master/TODO.md
+[API.md]: https://github.com/troglobit/libuev/blob/master/API.md
 [README.md]: https://github.com/troglobit/libuev/blob/master/README.md
 [ChangeLog.md]: https://github.com/troglobit/libuev/blob/master/ChangeLog.md
 [joystick.c]: https://github.com/troglobit/libuev/blob/master/joystick.c
@@ -307,9 +431,3 @@ Lua users mailing list.
 [libuevent]: https://code.google.com/p/libuevent/
 [Flemming Madsen]: http://www.madsensoft.dk
 [Initial announcement]: http://lua-users.org/lists/lua-l/2012-03/msg00510.html
-
-<!--
-  -- Local Variables:
-  --  mode: markdown
-  -- End:
-  -->

HACKING.md

@@ -0,0 +1,106 @@
+Maintenance and Release Checklist
+=================================
+
+Maintenance
+-----------
+
+* Encourage contributors to write tests, in particular for new features
+* Run tests regularly, use Travis-CI to do this automatically
+* Leverage GitHub issues for milestone planning
+* Reference issues from GitHub pull requests to alert issue subscribers
+* Bump library ABI version just before release!
+
+
+Release Checklist
+-----------------
+
+* Update ChangeLog, follow http://keepachangelog.com/ loosely
+  - Inform users in a plain language of changes and bug fixes
+  - Do *not* copy-paste GIT commit logs!
+  - Order entries according to importance, most relevant first
+* Run unit tests: `make check`
+* Make at least one `-rcN` release and test it in an actual real project
+* **REMEMBER:** bump ABI version according to below rules
+* Tag
+* Push last commit(s) *and* tags to GitHub
+* Make release
+
+        make distclean
+        ./autogen.sh
+        ./configure
+        make release
+
+* Create new release in GitHub releases page
+* Copy and paste ChangeLog entry, check any stale links!
+* Upload release tarball and MD5 files
+
+
+Library Versioning
+------------------
+
+libuEv relies on GNU Libtool for building the library.  For users of the
+library it is important to maintain a clear ABI versioning scheme.  This
+is not the same as the libuEv version, but rather its "compatibility
+level".
+
+The libuEv ABI version is specified in `src/Makefile.am`:
+
+    libuev_la_LDFLAGS = -version-info 0:0:0
+                                       \ \ `-- age
+                                        \ `--- revision
+                                         `---- current
+
+It must be updated according to the [GNU Libtool recommendations][1]:
+
+1. Start with version information of `0:0:0` for each libtool library.
+2. Update the version information only immediately before a public
+   release of your software.  More frequent updates are unnecessary, and
+   only guarantee that the current interface number gets larger faster.
+3. If the library *source code has changed at all* since the last update,
+   then increment revision (`c:r:a` becomes `c:r+1:a`).
+4. If any *interfaces have been added, removed, or changed* since the
+   last update, increment current, and set revision to 0.
+5. If any *interfaces have been added* since the last public release,
+   then increment age.
+6. If any *interfaces have been removed or changed* since the last
+   public release, then set age to 0.
+
+The libtool ABI versioning logic is very confusing but works if you just
+disable your brain and follow the rules, one by one.
+
+**Example #1:** a new function has been added, none of the existing ones
+have changed.  The initial version is 1:0:0, we follow the rules above to
+the letter: increase revision, increase current and set revision to zero,
+and finally increase age.  This, rather confusingly, gives us 2:0:1 which
+libtool then translates to `libuev.so.1.1.0`.
+
+**Example #2:** some existing functions are changed, they now return an
+`int` instead of `void`.  The initial version is 0:0:0, and we follow the
+rules again: increment revision, increment current and set revision to
+zero, set age to zero.  This gives us 1:0:0, which is then translated to
+ `libuev.so.1.0.0`.
+
+
+### Note
+
+Usually, non-developers have no interest in running development versions
+(releases are frequent enough), and developers are expected to know how
+to juggle versions.  In such an ideal world, it is good enough to bump
+the library version just prior to a release, point 2.
+
+However, if releases are few and far between, distributors may start to
+use snapshots.  When a distributor uses a snapshot, the distributor has
+to handle the library version manually.  Things can get ugly when the
+distributor has released an intermediate version with a bumped library
+version, and when the official release is bumped to that version, the
+distributor will then have to bump the library version for the official
+release, and it can be confusing if someone reports bugs on versions
+that you didn't even know existed.
+
+The problem with bumping the version with every change is that if your
+interface is not finished, the version number might run away, and it
+looks pretty bad if a library is at version 262.  It kind of tells the
+user that the library interface is volatile, which is not good for
+business.
+
+[1]: https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html

LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
-Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!com>
+Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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

Makefile.am

@@ -4,6 +4,10 @@ DIST_SUBDIRS        = src examples tests
 doc_DATA            = API.md README.md LICENSE
 EXTRA_DIST          = API.md README.md LICENSE AUTHORS ChangeLog.md
 
+if ENABLE_EXAMPLES
+SUBDIRS            += examples
+endif
+
 ## Generate .deb package
 package:
 	@dpkg-buildpackage -uc -us -B
@@ -34,7 +38,7 @@ release-hook:
 	fi
 
 ## Target to run when building a release
-release: dist release-hook md5-dist
+release: distcheck release-hook md5-dist
 	@for file in $(DIST_ARCHIVES); do						\
 		printf "$$file    \tDistribution tarball\n";				\
 		printf "$$file.md5\t"; cat $$file.md5 | cut -f1 -d' ';			\

README.md

@@ -1,5 +1,5 @@
-libuEv | Simple event loop for Linux
-====================================
+µEv | Simple event loop for Linux
+==================================
 [![Travis Status][]][Travis] [![Coverity Status][]][Coverity Scan]
 
 
@@ -15,43 +15,54 @@ libuEv | Simple event loop for Linux
 * [Origin & References](#origin--references)
 
 
-> “Event driven software improves concurrency” -- [Dave Zarzycki, Apple][]
+> **NOTE:** Incompatible failure mode changes in v2.0 compared to v1.x!
 
 Introduction
 ------------
 
-[libuEv][] is a simple event loop in the style of the more established
-[libevent][1], [libev][2] and the venerable [Xt(3)][3] event loop.  The
-*u* (micro) in the name refers to both the small feature set and the
-small size overhead impact of the library.
+[libuEv][] is a small event loop that wraps the Linux `epoll()` family
+of APIs.  It is similar to the more established [libevent][], [libev][]
+and the venerable [Xt(3)][] event loop.  The *µ* in the name refers to
+both its limited feature set and the size impact of the library.
 
-Experienced developers may appreciate that [libuEv][] is built on top of
-modern Linux APIs: epoll, timerfd and signalfd.
+Failure mode changes introduced in v2.0 may affect users of v1.x, See
+the [ChangeLog][] for the full details.
+
+The [API documentation](API.md) is available as a separate document.
 
 
 Example
 -------
 
-The library documentation is available as a [separate document](API.md).
+Notice how watcher conditions like `UEV_ERROR` must be handled by each
+callback.  I/O watchers must also check for `UEV_HUP`.  Both errors are
+usually fatal, libuEv makes sure to stop each watcher before a callback
+runs, leaving it up to the callback to take appropriate action.
 
 ```C
+/* Set up a timer watcher to call cb() every other second */
 #include <stdio.h>
 #include <uev/uev.h>
 
 static void cb(uev_t *w, void *arg, int events)
 {
-	puts("Every other second");
+        if (UEV_ERROR == events) {
+            puts("Problem with timer, attempting to restart.");
+            uev_timer_start(w);
+        }
+
+        puts("Every other second");
 }
 
 int main(void)
 {
-	uev_t timer;
-	uev_ctx_t ctx;
+        uev_ctx_t ctx;
+        uev_t timer;
 
-	uev_init(&ctx);
-	uev_timer_init(&ctx, &timer, cb, NULL, 2 * 1000, 0);
+        uev_init(&ctx);
+        uev_timer_init(&ctx, &timer, cb, NULL, 2 * 1000, 2 * 1000);
 
-	return uev_run(&ctx, 0);
+        return uev_run(&ctx, 0);
 }
 ```
 
@@ -72,36 +83,40 @@ sudo make install-strip
 sudo ldconfig
 ```
 
-The resulting .so file is ~14 kiB.
+The resulting .so library is ~23 kiB.
+
+To build from GIT sources; clone the repository and run the `autogen.sh`
+script.  This requires GNU `automake`, `autoconf` amd `libtool` to be
+installed on your system.  (If you build from a released tarball you do
+not need them.)
 
 
 Origin & References
 -------------------
 
-[libuEv][] was originally based on [LibUEvent][8] by [Flemming Madsen][]
-but has been completely rewritten to provide a cleaner API.  It is now
-more similar to the famous [libev][2] by [Mark Lehmann][].  Another
-small event library used for inspiration is the very small [picoev][9]
-by [Oku Kazuho][].
+[libuEv][] is developed and maintained by [Joachim Nilsson][] on GitHub.
+It is primarily built for and developed on GNU/Linux systems, patches to
+support the BSD [kqueue][] interface are most welcome.
 
-[libuEv][] is developed and maintained by [Joachim Nilsson][].  It is
-built for and developed on GNU/Linux systems, patches to support *BSD
-and its [kqueue][] interface are most welcome.
+Originally based on [LibUEvent][] by [Flemming Madsen][], uEv has since
+evolved to support all of the Linux `epoll()` family APIs.  It is now
+more similar to the excellent [libev][] by [Mark Lehmann][], with some
+inspiration also from [picoev][] by [Oku Kazuho][].
 
 
-[1]: http://libevent.org
-[2]: http://software.schmorp.de/pkg/libev.html
-[3]: http://unix.com/man-page/All/3x/XtDispatchEvent
-[8]: http://code.google.com/p/libuevent/
-[9]: https://github.com/kazuho/picoev
+[ChangeLog]:       https://github.com/troglobit/libuev/blob/master/ChangeLog.md
 [Travis]:          https://travis-ci.org/troglobit/libuev
 [Travis Status]:   https://travis-ci.org/troglobit/libuev.png?branch=master
 [Coverity Scan]:   https://scan.coverity.com/projects/3846
 [Coverity Status]: https://scan.coverity.com/projects/3846/badge.svg
+[libevent]:        https://libevent.org
+[Xt(3)]:           https://unix.com/man-page/All/3x/XtDispatchEvent
+[LibUEvent]:       https://code.google.com/p/libuevent/
+[picoev]:          https://github.com/kazuho/picoev
+[libev]:           http://software.schmorp.de/pkg/libev.html
 [LibuEv]:          https://github.com/troglobit/libuev
 [kqueue]:          https://github.com/mheily/libkqueue
 [Oku Kazuho]:      https://github.com/kazuho
 [Mark Lehmann]:    http://software.schmorp.de
 [Joachim Nilsson]: http://troglobit.com
 [Flemming Madsen]: http://www.madsensoft.dk
-[Dave Zarzycki, Apple]: http://www.youtube.com/watch?v=cD_s6Fjdri8

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(libuev, 1.6.0, https://github.com/troglobit/libuev/issues)
+AC_INIT(libuev, 2.3.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,13 @@ 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
+AC_ARG_ENABLE([examples],
+	[AC_HELP_STRING([--enable-examples], [Build libuEv examples/ directory])],
+	[], [enable_examples=no])
+AM_CONDITIONAL([ENABLE_EXAMPLES], [test "$enable_examples" = yes])
+
 AC_OUTPUT

debian/README.debian

@@ -8,7 +8,7 @@ based operating system, e.g.  Debian, Ubuntu, Linux Mint, etc.
 
 Recommended reading is the upstream README and API docs.
 
-     less /usr/share/doc/libuev-dev/README.md
-    zless /usr/share/doc/libuev-dev/API.md.gz
+    less /usr/share/doc/libuev-dev/README.md
+    less /usr/share/doc/libuev-dev/API.md
 
- -- Joachim Nilsson <troglobit@gmail.com>  Thu, 21 Sep 18:10, 2017
+ -- Joachim Nilsson <troglobit@gmail.com>  Sat, 6 Apr 13:18, 2019

debian/changelog

@@ -1,3 +1,71 @@
+libuev (2.3.0) unstable; urgency=medium
+
+  * Support for Linux eventfd, uev_event_*(), see API.md for details.
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Thu, 06 Apr 2019 13:09:31 +0200
+
+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
+  * Use native version numbering for package
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Sun, 28 Jan 2018 13:38:00 +0100
+
+libuev (2.1.0-1) unstable; urgency=medium
+
+  * New upstream release.  Further improvements to failure modes, some
+    fixes to regressions introduced in v2.0.
+
+    - Unconditionally stop I/O watchers on UEV_HUP and UEV_ERR conditions.
+    - Attempt to restart failing  signal watchers before dropping to error.
+    - Properly de-register signal and cron/timer watchers on error.
+    - Fix possible double close() on cron/timer watchers.
+    - Documentation updates, improved examples, and unit tests.
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Tue, 14 Nov 2017 17:40:43 +0100
+
+libuev (2.0.0-1) unstable; urgency=medium
+
+  * Major new upstream version, possibly incompatible changes to both
+    uev_run() and how watchers are called in various failure modes.
+
+    - uev_run() no longer exits the main event loop if an unrecoverable
+      error with a watcher occurs.  Instead, the watcher is disabled and
+      the callback is run one last time with events set to UEV_ERROR.
+    - Watcher callbacks must handle UEV_ERROR conditions.  This pertains
+      in particular to signal and timer watchers.
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Sat, 11 Nov 2017 16:31:46 +0100
+
 libuev (1.6.0-1) unstable; urgency=medium
 
   * Support for edge triggered and oneshot event types

debian/compat

@@ -1 +1 @@
-9
+10

debian/control

@@ -1,12 +1,12 @@
 Source: libuev
+Section: libs
 Priority: optional
 Maintainer: Joachim Nilsson <troglobit@gmail.com>
 Build-Depends: dpkg-dev (>= 1.14.9), debhelper (>= 9), dh-autoreconf
-Standards-Version: 3.9.6
-Section: libs
+Standards-Version: 4.3.0
 Homepage: https://github.com/troglobit/libuev/
-Vcs-Git: https://github.com/troglobit/libuev.git
 Vcs-Browser: https://github.com/troglobit/libuev/
+Vcs-Git: https://github.com/troglobit/libuev.git
 
 Package: libuev-dev
 Priority: extra
@@ -14,26 +14,24 @@ Section: libdevel
 Architecture: any
 Depends: ${misc:Depends}, libuev (= ${binary:Version})
 Description: static library, header files, and docs for libuev
- Static library, header files, and documentation for libuev.
+ Static library, header files, and documentation for libuEv
  .
- libuEv is a simple event loop in the style of the more established
- libevent, libev and the venerable Xt(3) event loop. The u (micro) in the
- name refers to both the small feature set and the small size overhead
- impact of the library.
+ libuEv is a small event loop that wraps the Linux epoll() family of APIs.
+ It is similar to the more established libevent, libev and the venerable
+ Xt(3) event loop. The u (micro) in the name refers to both its limited
+ feature set and the small size impact of the library.
  .
- Experienced developers may appreciate that libuEv is built on top of
- modern Linux APIs: epoll, timerfd and signalfd. Note however, a certain
- amount of care is needed when dealing with APIs that employ signalfd.
+ Experienced developers may appreciate libuEv is built on top of modern
+ Linux APIs like epoll, eventfd, timerf, and signalfd.
 
 Package: libuev
 Architecture: any
 Depends: ${misc:Depends}, ${shlibs:Depends}
-Description: Lightweight event loop library
- libuEv is a simple event loop in the style of the more established
- libevent, libev and the venerable Xt(3) event loop. The u (micro) in the
- name refers to both the small feature set and the small size overhead
- impact of the library.
+Description: Lightweight event loop library for Linux
+ libuEv is a small event loop that wraps the Linux epoll() family of APIs.
+ It is similar to the more established libevent, libev and the venerable
+ Xt(3) event loop. The u (micro) in the name refers to both its limited
+ feature set and the small size impact of the library.
  .
- Experienced developers may appreciate that libuEv is built on top of
- modern Linux APIs: epoll, timerfd and signalfd. Note however, a certain
- amount of care is needed when dealing with APIs that employ signalfd.
+ Experienced developers may appreciate libuEv is built on top of modern
+ Linux APIs like epoll, eventfd, timerfd, and signalfd.

debian/copyright

@@ -1,26 +1,35 @@
 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: libuEv
+Upstream-Contact: troglobit@gmail.com
 Source: https.//github.com/troglobit/libuev/
+Comment: Debianized by upstream on Mon, Nov 28 2016 23:23:17 +0100
 
 Files: *
-Copyright: 2013-2017 Joachim Nilsson <troglobit@gmail.com>
+Copyright: 2012 Flemming Madsen <flemming.madsen@madsensoft.dk>
+           2013-2019 Joachim Nilsson <troglobit@gmail.com>
 License: MIT
-Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
-Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!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:
+Files: debian/*
+Copyright: 2016-2019 Joachim Nilsson <troglobit@gmail.com>
 
-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.
+License: MIT
+ Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
+ Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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.

debian/libuev-dev.install

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

debian/libuev.dirs

@@ -1 +1,2 @@
 usr/lib
+usr/share

debian/rules

@@ -1,10 +1,17 @@
 #!/usr/bin/make -f           
-
 # Uncomment this to turn on verbose mode.
 #export DH_VERBOSE=1
+export DEB_BUILD_MAINT_OPTIONS = hardening=+all
 
 %:
 	dh $@ --with autoreconf
 
 override_dh_compress:
 	dh_compress -A -X.md
+
+override_dh_installchangelogs:
+	dh_installchangelogs ChangeLog.md
+
+override_dh_auto_install:
+	dh_auto_install
+	find debian -name LICENSE -delete

examples/.gitignore

@@ -2,3 +2,5 @@ joystick
 signal
 cronrun
 test
+redirect
+hej.txt

examples/Makefile.am

@@ -1,5 +1,3 @@
-noinst_PROGRAMS = joystick
-AM_CPPFLAGS     = -I$(top_srcdir)
-AM_LDFLAGS      = -L$(top_srcdir)
-LIBS            = $(LTLIBINTL)
-LDADD           = $(top_srcdir)/libuev.la
+noinst_PROGRAMS = joystick redirect
+AM_CPPFLAGS     = -I$(top_srcdir)/src
+LDADD           = $(top_srcdir)/src/libuev.la

examples/joystick.c

@@ -1,6 +1,6 @@
 /* Simple example of how to use libuEv with Linux joystick API
  *
- * Copyright (c) 2014-2017  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2014-2019  Joachim Nilsson <troglobit()gmail!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
@@ -37,10 +37,29 @@ struct js_event {
 	uint8_t  number;	/* axis/button number */
 } e;
 
+/*
+ * Always check for UEV_ERROR in watcher callback!
+ * Possibly joystick was unplugged
+ */
 static void joystick_cb(uev_t *w, void *arg, int events)
 {
-	if (read(w->fd, &e, sizeof(e)) < 0)
-		errx(errno, "Failed reading joystick event");
+	ssize_t len;
+
+	if (UEV_ERROR == events) {
+		warnx("Spurious problem with the joystick watcher, restarting.");
+		uev_io_start(w);
+	}
+
+	len = read(w->fd, &e, sizeof(e));
+	if (len < 0) {
+		warn("Failed reading joystick event");
+		return;
+	}
+
+	if (len == 0 || UEV_HUP == events) {
+		warn("Joystick disconnected");
+		return;
+	}
 
 	switch (e.type) {
 	case 1:
@@ -55,16 +74,16 @@ static void joystick_cb(uev_t *w, void *arg, int events)
 
 int main(void)
 {
-	int fd;
-	uev_t js1_watcher;
 	uev_ctx_t ctx;
+	uev_t js1;
+	int fd;
 
-	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.");
 
 	uev_init(&ctx);
-	uev_io_init(&ctx, &js1_watcher, joystick_cb, NULL, fd, UEV_READ);
+	uev_io_init(&ctx, &js1, joystick_cb, NULL, fd, UEV_READ);
 
 	puts("Starting, press Ctrl-C to exit.");
 

examples/redirect.c

@@ -0,0 +1,69 @@
+/* Example of how to handle stdin redirect
+ *
+ * The problem is non-trivial since Linux epoll, which libuEv uses, does
+ * not support I/O watchers for regular files or directories.
+ *
+ * This works:
+ *                  echo foo | redirect
+ * This doesn't:
+ *                  redirect < foo.txt
+ *
+ * However, with a little bit of hacking libuEv can be made to handle
+ * reading from stdin as a special case.
+ */
+
+#include <err.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include "src/uev.h"
+
+void process_stdin(uev_t *w, void *arg, int events)
+{
+	char buf[256];
+	int len;
+
+	if (UEV_ERROR == events) {
+		warnx("Spurious problem with the stdin watcher, restarting.");
+		uev_io_start(w);
+	}
+
+	len = read(w->fd, buf, sizeof(buf));
+	if (len == -1) {
+		warn("Error reading from stdin");
+		return;
+	}
+
+	if (len == 0 || UEV_HUP == events) {
+		warnx("Connection closed.");
+		return;
+	}
+
+	printf("Read %d bytes\n", len);
+	if (write(STDOUT_FILENO, buf, len) != len)
+		warn("Failed writing to stdout");
+}
+
+int main(int argc, char **argv)
+{
+	uev_ctx_t ctx;
+	uev_t watcher;
+	int ret;
+
+	uev_init(&ctx);
+
+	ret = uev_io_init(&ctx, &watcher, process_stdin, NULL, STDIN_FILENO, UEV_READ);
+	if (ret)
+		err(errno, "Failed setting up STDIN watcher");
+
+	return uev_run(&ctx, 0);
+}
+
+/**
+ * Local Variables:
+ *  compile-command: "make redirect; echo hej > hej.txt; ./redirect < hej.txt"
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

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 event.c
 libuev_la_CPPFLAGS  = -D_GNU_SOURCE -D_TIME_BITS=64
-libuev_la_CFLAGS    = -W -Wall -Wextra
-libuev_la_LDFLAGS   = $(AM_LDFLAGS) -version-info 1:2:0
+libuev_la_CFLAGS    = -W -Wall -Wextra -std=gnu11
+libuev_la_LDFLAGS   = $(AM_LDFLAGS) -version-info 4:0:2
 
 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

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -72,11 +72,11 @@ int uev_cron_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, time_t when
 	if (fd < 0)
 		return -1;
 
-	if (uev_watcher_init(ctx, w, UEV_CRON_TYPE, cb, arg, fd, UEV_READ))
+	if (_uev_watcher_init(ctx, w, UEV_CRON_TYPE, cb, arg, fd, UEV_READ))
 		goto exit;
 
 	if (uev_cron_set(w, when, interval)) {
-		uev_watcher_stop(w);
+		_uev_watcher_stop(w);
 	exit:
 		close(fd);
 		return -1;
@@ -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;
 	}
@@ -132,7 +129,7 @@ int uev_cron_set(uev_t *w, time_t when, time_t interval)
 			return 1;
 	}
 
-	return uev_watcher_start(w);
+	return _uev_watcher_start(w);
 }
 
 /**

src/event.c

@@ -0,0 +1,106 @@
+/* libuEv - Micro event loop library
+ *
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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 <errno.h>
+#include <sys/eventfd.h>
+#include <unistd.h>		/* close(), read() */
+
+#include "uev.h"
+
+
+/**
+ * Create a generic event watcher
+ * @param ctx    A valid libuEv context
+ * @param w      Pointer to an uev_t watcher
+ * @param cb     Callback when an event is posted
+ * @param arg    Optional callback argument
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_event_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg)
+{
+	int fd;
+
+	if (!w || !ctx) {
+		errno = EINVAL;
+		return -1;
+	}
+	w->fd = -1;
+
+	fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+	if (fd < 0)
+		return -1;
+
+	return _uev_watcher_init(ctx, w, UEV_EVENT_TYPE, cb, arg, fd, UEV_READ)
+		|| _uev_watcher_start(w);
+}
+
+/**
+ * Post a generic event
+ * @param w  Watcher to post to
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_event_post(uev_t *w)
+{
+	uint64_t val = 1;
+
+	if (!w || -1 == w->fd) {
+		errno = EINVAL;
+		return -1;
+	}
+
+
+	if (write(w->fd, &val, sizeof(val)) != sizeof(val))
+		return -1;
+
+	return 0;
+}
+
+/**
+ * Stop a generic event watcher
+ * @param w  Watcher to stop
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_event_stop(uev_t *w)
+{
+	if (!_uev_watcher_active(w))
+		return 0;
+
+	if (_uev_watcher_stop(w))
+		return -1;
+
+	close(w->fd);
+	w->fd = -1;
+
+	return 0;
+}
+
+/**
+ * Local Variables:
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

src/io.c

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -44,10 +44,10 @@ int uev_io_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int e
 		return -1;
 	}
 
-	if (uev_watcher_init(ctx, w, UEV_IO_TYPE, cb, arg, fd, events))
+	if (_uev_watcher_init(ctx, w, UEV_IO_TYPE, cb, arg, fd, events))
 		return -1;
 
-	return uev_watcher_start(w);
+	return _uev_watcher_start(w);
 }
 
 /**
@@ -60,9 +60,8 @@ int uev_io_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int e
  */
 int uev_io_set(uev_t *w, int fd, int events)
 {
-
-	if ((events & UEV_ONESHOT) && w->active)
-		return uev_watcher_rearm(w);
+	if ((events & UEV_ONESHOT) && _uev_watcher_active(w))
+		return _uev_watcher_rearm(w);
 
 	/* Ignore any errors, only to clean up anything lingering ... */
 	uev_io_stop(w);
@@ -89,7 +88,7 @@ int uev_io_start(uev_t *w)
  */
 int uev_io_stop(uev_t *w)
 {
-	return uev_watcher_stop(w);
+	return _uev_watcher_stop(w);
 }
 
 /**

src/private.h

@@ -1,7 +1,7 @@
 /* libuEv - Private methods and data types, do not use directly!
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -27,25 +27,59 @@
 
 #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 {
-	UEV_CRON_TYPE = 1,
-	UEV_IO_TYPE,
+	UEV_IO_TYPE = 1,
 	UEV_SIGNAL_TYPE,
 	UEV_TIMER_TYPE,
+	UEV_CRON_TYPE,
+	UEV_EVENT_TYPE,
 } uev_type_t;
 
 /* Event mask, used internally only. */
-#define UEV_EVENT_MASK  (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() */
-	uint32_t        errors;
-	LIST_HEAD(,uev) watchers;
+	int             fd;	    /* For epoll() */
+	int             maxevents;  /* For epoll() */
+	struct uev     *watchers;
+	uint32_t        workaround; /* For workarounds, e.g. redirected stdin */
 } uev_ctx_t;
 
 /* Forward declare due to dependencys, don't try this at home kids. */
@@ -53,7 +87,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;                                 \
@@ -81,13 +115,13 @@ struct uev;
 	uev_type_t
 
 /* Internal API for dealing with generic watchers */
-int uev_watcher_init  (uev_ctx_t *ctx, struct uev *w, uev_type_t type,
-		       void (*cb)(struct uev *, void *, int), void *arg,
-		       int fd, int events);
-int uev_watcher_start (struct uev *w);
-int uev_watcher_stop  (struct uev *w);
-int uev_watcher_active(struct uev *w);
-int uev_watcher_rearm (struct uev *w);
+int _uev_watcher_init  (uev_ctx_t *ctx, struct uev *w, uev_type_t type,
+			void (*cb)(struct uev *, void *, int), void *arg,
+			int fd, int events);
+int _uev_watcher_start (struct uev *w);
+int _uev_watcher_stop  (struct uev *w);
+int _uev_watcher_active(struct uev *w);
+int _uev_watcher_rearm (struct uev *w);
 
 #endif /* LIBUEV_PRIVATE_H_ */
 

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

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -34,7 +34,7 @@
  * Create a signal watcher
  * @param ctx    A valid libuEv context
  * @param w      Pointer to an uev_t watcher
- * @param cb     Timer callback
+ * @param cb     Signal callback
  * @param arg    Optional callback argument
  * @param signo  Signal to watch for
  *
@@ -42,8 +42,8 @@
  */
 int uev_signal_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo)
 {
-	int fd;
 	sigset_t mask;
+	int fd;
 
 	if (!w || !ctx) {
 		errno = EINVAL;
@@ -56,11 +56,11 @@ int uev_signal_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo
 	if (fd < 0)
 		return -1;
 
-	if (uev_watcher_init(ctx, w, UEV_SIGNAL_TYPE, cb, arg, fd, UEV_READ))
+	if (_uev_watcher_init(ctx, w, UEV_SIGNAL_TYPE, cb, arg, fd, UEV_READ))
 		goto exit;
 
 	if (uev_signal_set(w, signo)) {
-		uev_watcher_stop(w);
+		_uev_watcher_stop(w);
 	exit:
 		close(fd);
 		return -1;
@@ -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;
 	}
@@ -109,7 +106,7 @@ int uev_signal_set(uev_t *w, int signo)
 	if (signalfd(w->fd, &mask, SFD_NONBLOCK) < 0)
 		return -1;
 
-	return uev_watcher_start(w);
+	return _uev_watcher_start(w);
 }
 
 
@@ -140,7 +137,10 @@ int uev_signal_start(uev_t *w)
  */
 int uev_signal_stop(uev_t *w)
 {
-	if (uev_watcher_stop(w))
+	if (!_uev_watcher_active(w))
+		return 0;
+
+	if (_uev_watcher_stop(w))
 		return -1;
 
 	close(w->fd);

src/timer.c

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -76,13 +76,14 @@ int uev_timer_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeou
 	if (fd < 0)
 		return -1;
 
-	if (uev_watcher_init(ctx, w, UEV_TIMER_TYPE, cb, arg, fd, UEV_READ))
+	if (_uev_watcher_init(ctx, w, UEV_TIMER_TYPE, cb, arg, fd, UEV_READ))
 		goto exit;
 
 	if (uev_timer_set(w, timeout, period)) {
-		uev_watcher_stop(w);
+		_uev_watcher_stop(w);
 	exit:
 		close(fd);
+		w->fd = -1;
 		return -1;
 	}
 
@@ -92,9 +93,13 @@ int uev_timer_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeou
 /**
  * Reset a timer
  * @param w        Watcher to reset
- * @param timeout  Timeout in milliseconds before @param cb is called
+ * @param timeout  Timeout in milliseconds before @param cb is called, zero disarms timer
  * @param period   For periodic timers this is the period time that @param timeout is reset to
  *
+ * Note, the @param timeout value must be non-zero.  Setting it to zero
+ * will disarm the timer.  This is the underlying Linux function @func
+ * timerfd_settimer() which has this behavior.
+ *
  * @return POSIX OK(0) or non-zero with @param errno set on error.
  */
 int uev_timer_set(uev_t *w, int timeout, int period)
@@ -116,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;
 	}
@@ -135,7 +137,7 @@ int uev_timer_set(uev_t *w, int timeout, int period)
 			return 1;
 	}
 
-	return uev_watcher_start(w);
+	return _uev_watcher_start(w);
 }
 
 /**
@@ -152,7 +154,7 @@ int uev_timer_start(uev_t *w)
 	}
 
 	if (-1 != w->fd)
-		uev_watcher_stop(w);
+		_uev_watcher_stop(w);
 
 	return uev_timer_set(w, w->u.t.timeout, w->u.t.period);
 }
@@ -165,13 +167,12 @@ int uev_timer_start(uev_t *w)
  */
 int uev_timer_stop(uev_t *w)
 {
-	/* Stop kernel timer */
-	uev_timer_set(w, 0, 0);
+	if (!_uev_watcher_active(w))
+		return 0;
 
-	if (uev_watcher_stop(w))
+	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

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2017  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -26,13 +26,13 @@
 #include <fcntl.h>		/* O_CLOEXEC */
 #include <string.h>		/* memset() */
 #include <sys/epoll.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>		/* for select() workaround */
 #include <sys/signalfd.h>	/* struct signalfd_siginfo */
 #include <unistd.h>		/* close(), read() */
 
 #include "uev.h"
 
-#define UNUSED(arg) arg __attribute__ ((unused))
-
 
 static int _init(uev_ctx_t *ctx, int close_old)
 {
@@ -50,14 +50,24 @@ static int _init(uev_ctx_t *ctx, int close_old)
 	return 0;
 }
 
-/* Simple check if a descriptor is still valid in the kernel */
-static int is_valid_fd(int fd)
+/* Used by file i/o workaround when epoll => EPERM */
+static int has_data(int fd)
 {
-    return fcntl(fd, F_GETFL) != -1 || errno != EBADF;
+	struct timeval timeout = { 0, 0 };
+	fd_set fds;
+	int n = 0;
+
+	FD_ZERO(&fds);
+	FD_SET(fd, &fds);
+
+	if (select(1, &fds, NULL, NULL, &timeout) > 0)
+		return ioctl(0, FIONREAD, &n) == 0 && n > 0;
+
+	return 0;
 }
 
 /* Private to libuEv, do not use directly! */
-int uev_watcher_init(uev_ctx_t *ctx, uev_t *w, uev_type_t type, uev_cb_t *cb, void *arg, int fd, int events)
+int _uev_watcher_init(uev_ctx_t *ctx, uev_t *w, uev_type_t type, uev_cb_t *cb, void *arg, int fd, int events)
 {
 	if (!ctx || !w) {
 		errno = EINVAL;
@@ -76,46 +86,59 @@ int uev_watcher_init(uev_ctx_t *ctx, uev_t *w, uev_type_t type, uev_cb_t *cb, vo
 }
 
 /* Private to libuEv, do not use directly! */
-int uev_watcher_start(uev_t *w)
+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;
 	}
 
-	if (w->active)
+	if (_uev_watcher_active(w))
 		return 0;
 
 	ev.events   = w->events | EPOLLRDHUP;
 	ev.data.ptr = w;
-	if (epoll_ctl(w->ctx->fd, EPOLL_CTL_ADD, w->fd, &ev) < 0)
-		return -1;
+	if (epoll_ctl(w->ctx->fd, EPOLL_CTL_ADD, w->fd, &ev) < 0) {
+		if (errno != EPERM)
+			return -1;
 
-	w->active = 1;
+		/* Handle special case: `application < file.txt` */
+		if (w->type != UEV_IO_TYPE || w->events != UEV_READ)
+			return -1;
+
+		/* Only allow this special handling for stdin */
+		if (w->fd != STDIN_FILENO)
+			return -1;
+
+		w->ctx->workaround = 1;
+		w->active = -1;
+	} else {
+		w->active = 1;
+	}
 
 	/* Add to internal list for bookkeeping */
-	LIST_INSERT_HEAD(&w->ctx->watchers, w, link);
+	_UEV_INSERT(w, w->ctx->watchers);
 
 	return 0;
 }
 
 /* Private to libuEv, do not use directly! */
-int uev_watcher_stop(uev_t *w)
+int _uev_watcher_stop(uev_t *w)
 {
 	if (!w) {
 		errno = EINVAL;
 		return -1;
 	}
 
-	if (!w->active)
+	if (!_uev_watcher_active(w))
 		return 0;
 
 	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)
@@ -125,16 +148,16 @@ int uev_watcher_stop(uev_t *w)
 }
 
 /* Private to libuEv, do not use directly! */
-int uev_watcher_active(uev_t *w)
+int _uev_watcher_active(uev_t *w)
 {
 	if (!w)
 		return 0;
 
-	return w->active;
+	return w->active > 0;
 }
 
 /* Private to libuEv, do not use directly! */
-int uev_watcher_rearm(uev_t *w)
+int _uev_watcher_rearm(uev_t *w)
 {
 	struct epoll_event ev;
 
@@ -155,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);
 }
@@ -178,38 +230,44 @@ 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_t *w = LIST_FIRST(&ctx->watchers);
-
+	_UEV_FOREACH(w, ctx->watchers) {
 		/* Remove from internal list */
-		LIST_REMOVE(w, link);
+		_UEV_REMOVE(w, ctx->watchers);
 
-		if (!w->active)
+		if (!_uev_watcher_active(w))
 			continue;
 
 		switch (w->type) {
-		case UEV_CRON_TYPE:
-		case UEV_TIMER_TYPE:
-			uev_timer_stop(w);
+		case UEV_IO_TYPE:
+			uev_io_stop(w);
 			break;
 
 		case UEV_SIGNAL_TYPE:
 			uev_signal_stop(w);
 			break;
 
-		case UEV_IO_TYPE:
-			uev_io_stop(w);
+		case UEV_TIMER_TYPE:
+		case UEV_CRON_TYPE:
+			uev_timer_stop(w);
+			break;
+
+		case UEV_EVENT_TYPE:
+			uev_event_stop(w);
 			break;
 		}
 	}
 
+	ctx->watchers = NULL;
 	ctx->running = 0;
-	close(ctx->fd);
+	if (ctx->fd > -1)
+		close(ctx->fd);
 	ctx->fd = -1;
 
 	return 0;
@@ -231,8 +289,8 @@ int uev_exit(uev_ctx_t *ctx)
  */
 int uev_run(uev_ctx_t *ctx, int flags)
 {
-	int result = 0, timeout = -1;
 	uev_t *w;
+	int timeout = -1;
 
         if (!ctx || ctx->fd < 0) {
 		errno = EINVAL;
@@ -246,18 +304,38 @@ 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) {
-		int i, nfds;
-		struct epoll_event events[UEV_MAX_EVENTS];
+	while (ctx->running && ctx->watchers) {
+		struct epoll_event ee[UEV_MAX_EVENTS];
+		int i, nfds, rerun = 0;
 
-		while ((nfds = epoll_wait(ctx->fd, events, UEV_MAX_EVENTS, timeout)) < 0) {
+		/* Handle special case: `application < file.txt` */
+		if (ctx->workaround) {
+			_UEV_FOREACH(w, ctx->watchers) {
+				if (w->active != -1 || !w->cb)
+					continue;
+
+				if (!has_data(w->fd)) {
+					w->active = 0;
+					_UEV_REMOVE(w, ctx->watchers);
+				}
+
+				rerun++;
+				w->cb(w, w->arg, UEV_READ);
+			}
+		}
+
+		if (rerun)
+			continue;
+		ctx->workaround = 0;
+
+		while ((nfds = epoll_wait(ctx->fd, ee, ctx->maxevents, timeout)) < 0) {
 			if (!ctx->running)
 				break;
 
@@ -266,102 +344,82 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 			/* Unrecoverable error, cleanup and exit with error. */
 			uev_exit(ctx);
-			return -1;
+
+			return -2;
 		}
 
 		for (i = 0; ctx->running && i < nfds; i++) {
-			w = (uev_t *)events[i].data.ptr;
+			struct signalfd_siginfo fdsi;
+			uint32_t events;
+			uint64_t exp;
+			ssize_t sz = sizeof(fdsi);
 
-			if (events[i].events & (EPOLLHUP | EPOLLERR)) {
-				ctx->errors++;
+			w = (uev_t *)ee[i].data.ptr;
+			events = ee[i].events;
 
-				if (ctx->errors >= 42) {
-					uev_t *tmp, *retry = w;;
+			switch (w->type) {
+			case UEV_IO_TYPE:
+				if (events & (EPOLLHUP | EPOLLERR))
+					uev_io_stop(w);
+				break;
 
-					/* If not valid anymore, try to remove, ignore any errors. */
-					if (!is_valid_fd(w->fd))
-						uev_watcher_stop(w);
-
-					/* Must recreate epoll fd now ... */
-					if (_init(ctx, 1)) {
-						uev_exit(ctx);
-						return -2;
+			case UEV_SIGNAL_TYPE:
+				if (read(w->fd, &fdsi, sz) != sz) {
+					if (uev_signal_start(w)) {
+						uev_signal_stop(w);
+						events = UEV_ERROR;
 					}
-
-					/* Restart watchers in new efd */
-					LIST_FOREACH_SAFE(w, &ctx->watchers, link, tmp) {
-						if (w->active) {
-							w->active = 0;
-							LIST_REMOVE(w, link);
-							uev_watcher_start(w);
-						}
-					}
-					uev_watcher_start(retry);
-
-					/* New efd, restart everything! */
-					ctx->errors = 0;
-					continue;
 				}
-			}
-
-			if (UEV_CRON_TYPE == w->type) {
-				uint64_t exp;
+				break;
 
+			case UEV_TIMER_TYPE:
 				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
-					if (errno != ECANCELED) {
-						uev_exit(ctx);
-						return -3;
-					}
+					uev_timer_stop(w);
+					events = UEV_ERROR;
+				}
 
-					events[i].events = UEV_HUP;
+				if (!w->u.t.period)
+					w->u.t.timeout = 0;
+				if (!w->u.t.timeout)
+					uev_timer_stop(w);
+				break;
+
+			case UEV_CRON_TYPE:
+				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
+					events = UEV_HUP;
+					if (errno != ECANCELED) {
+						uev_cron_stop(w);
+						events = UEV_ERROR;
+					}
 				}
 
 				if (!w->u.c.interval)
 					w->u.c.when = 0;
 				else
 					w->u.c.when += w->u.c.interval;
-			}
-
-			if (UEV_TIMER_TYPE == w->type) {
-				uint64_t exp;
-
-				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
-					uev_exit(ctx);
-					return -3;
-				}
-
-				if (!w->u.t.period)
-					w->u.t.timeout = 0;
-			}
-
-			if (UEV_SIGNAL_TYPE == w->type) {
-				struct signalfd_siginfo fdsi;
-				ssize_t sz = sizeof(fdsi);
-
-				if (read(w->fd, &fdsi, sz) != sz) {
-					uev_exit(ctx);
-					return -4;
-				}
-			}
-
-			if (w->cb)
-				w->cb(w, w->arg, events[i].events & UEV_EVENT_MASK);
-
-			if (UEV_CRON_TYPE == w->type) {
 				if (!w->u.c.when)
 					uev_timer_stop(w);
+				break;
+
+			case UEV_EVENT_TYPE:
+				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp))
+					events = UEV_HUP;
+				break;
 			}
-			if (UEV_TIMER_TYPE == w->type) {
-				if (!w->u.t.timeout)
-					uev_timer_stop(w);
-			}
+
+			/*
+			 * NOTE: Must be last action for watcher, the
+			 *       callback may delete itself.
+			 */
+			if (w->cb)
+				w->cb(w, w->arg, events & UEV_EVENT_MASK);
 		}
 
-		if ((flags & UEV_ONCE) || LIST_EMPTY(&ctx->watchers))
+		if (flags & UEV_ONCE)
 			break;
 	}
 
-	return result;
+	return 0;
 }
 
 /**

src/uev.h

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -32,6 +32,7 @@
 
 /* I/O events, signal and timer revents are always UEV_READ */
 #define UEV_NONE        0
+#define UEV_ERROR       EPOLLERR
 #define UEV_READ        EPOLLIN
 #define UEV_WRITE       EPOLLOUT
 #define UEV_PRI         EPOLLPRI
@@ -45,10 +46,11 @@
 #define UEV_NONBLOCK    2
 
 /* Macros */
-#define uev_io_active(w)     uev_watcher_active(w)
-#define uev_timer_active(w)  uev_watcher_active(w)
-#define uev_cron_active(w)   uev_watcher_active(w)
-#define uev_signal_active(w) uev_watcher_active(w)
+#define uev_io_active(w)     _uev_watcher_active(w)
+#define uev_signal_active(w) _uev_watcher_active(w)
+#define uev_timer_active(w)  _uev_watcher_active(w)
+#define uev_cron_active(w)   _uev_watcher_active(w)
+#define uev_event_active(w)  _uev_watcher_active(w)
 
 /* Event watcher */
 typedef struct uev {
@@ -65,11 +67,17 @@ typedef struct uev {
  * Generic callback for watchers, @events holds %UEV_READ and/or %UEV_WRITE
  * with optional %UEV_PRI (priority data available to read) and any of the
  * %UEV_HUP and/or %UEV_RDHUP, which may be used to signal hang-up events.
+ *
+ * Note: UEV_ERROR conditions must be handled by all callbacks!
+ *       I/O watchers may also need to check UEV_HUP.  Appropriate action,
+ *       e.g. restart the watcher, is up to the application and is thus
+ *       delegated to the callback.
  */
 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);
 
@@ -93,6 +101,10 @@ int uev_signal_set     (uev_t *w, int signo);
 int uev_signal_start   (uev_t *w);
 int uev_signal_stop    (uev_t *w);
 
+int uev_event_init     (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg);
+int uev_event_post     (uev_t *w);
+int uev_event_stop     (uev_t *w);
+
 #endif /* LIBUEV_UEV_H_ */
 
 /**

tests/.gitignore

@@ -1,7 +1,9 @@
 *.trs
 *.log
 active
+api
 complete
 cronrun
 signal
 timer
+event

tests/Makefile.am

@@ -3,14 +3,16 @@ CLEANFILES      = *~ *.trs *.log
 
 TESTS           =
 TESTS          += active
+TESTS          += api
 TESTS          += complete
 TESTS          += cronrun
 TESTS          += signal
 TESTS          += timer
+TESTS          += event
 
 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,8 +12,11 @@ uev_t timer3;
 uev_t cron1;
 uev_t cron2;
 
-static void cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void cb(uev_t *w, void *arg, int events)
 {
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	fail_unless(w == &timer1);
 
 	fail_unless(uev_timer_active(&timer2));
@@ -27,13 +30,16 @@ static void cb(uev_t *w, void *UNUSED(arg), int UNUSED(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);
 }
 
 int main(void)
 {
-	uev_ctx_t ctx;
 	struct timeval tomorrow;
+	uev_ctx_t ctx;
 
 	gettimeofday(&tomorrow, NULL);
 	tomorrow.tv_sec += 24 * 60 * 60;
@@ -49,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

@@ -1,7 +1,7 @@
 /* Test libuEv event library
  *
  * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2019  Joachim Nilsson <troglobit()gmail!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
@@ -33,15 +33,21 @@ static int in, out;
 static int period = 0;
 static uev_t *watchdog;
 
-static void lifetime_cb(uev_t *w, void *arg, int UNUSED(events))
+static void lifetime_cb(uev_t *w, void *arg, int events)
 {
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	fprintf(stderr, "\nLifetime exceeded, program completed successfully! (arg:%p)\n", arg);
 	uev_exit(w->ctx);
 }
 
 /* The pipe watchdog, if it triggers we haven't received data in time. */
-static void timeout_cb(uev_t *w, void *arg, int UNUSED(events))
+static void timeout_cb(uev_t *w, void *arg, int events)
 {
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	watchdog = NULL;
 	fprintf(stderr, "\nTimeout exceeded %p\n", arg);
 
@@ -49,39 +55,66 @@ static void timeout_cb(uev_t *w, void *arg, int UNUSED(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 UNUSED(events))
+static void signal_cb(uev_t *w, void *arg, int events)
 {
+	if (UEV_ERROR == events) {
+		fprintf(stderr, "Signal watcher failed, unrecoverable error.\n");
+		return;
+	}
+
 	fprintf(stderr, w->signo == SIGINT ? "^Cv" : "^\v");
 }
 
-static void pipe_read_cb(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void pipe_read_cb(uev_t *w, void *arg, int events)
 {
-	int cnt;
+	int len;
 	char msg[50];
 
-        /* Kick watchdog */
+	if (UEV_ERROR == events) {
+	error:
+		fprintf(stderr, "pipe watcher failed, restarting ...\n");
+		uev_io_start(w);
+		return;
+	}
+
+	/* Kick watchdog */
 	if (watchdog)
 		uev_timer_set(watchdog, 1000, 0);
 
-	cnt = read(in, msg, sizeof(msg));
-//	fprintf(stderr, "READ %.*s %d\n", cnt, msg, cnt);
-	fprintf(stderr, "%.*s.%d ", cnt, msg, cnt);
+	/* Here we can read() from in or w->fd, either works. */
+	len = read(w->fd, msg, sizeof(msg));
+	if (len < 0) {
+		perror(__func__);
+		goto error;
+	}
+
+	if (len == 0 || UEV_HUP == events) {
+		fprintf(stderr, "Other end of pipe closed, no more data\n");
+		return;
+	}
+
+//	fprintf(stderr, "READ %.*s %d\n", len, msg, len);
+	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";
 
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
+	/* 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");
-                return;
-        }
+		perror("\nFailed writing to pipe");
+		return;
+	}
 
 //	fprintf(stderr, "WRITE %.*s %d\n", my->counter, msg, my->counter);
 	fprintf(stderr, "%d ", my->counter);
@@ -120,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

@@ -1,6 +1,6 @@
 /* Test cron API in libuEv event library
  *
- * Copyright (c) 2016  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2016-2019  Joachim Nilsson <troglobit()gmail!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
@@ -28,12 +28,16 @@
 #define TIMEOUT  2
 #define INTERVAL 2
 
+int result = -1;
 struct timeval tv;
 
-static void cron_job(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void cron_job(uev_t *w, void *arg, int events)
 {
-	static int laps = 3;
 	struct timeval now;
+	static int laps = 3;
+
+	if (UEV_ERROR == events)
+		fprintf(stderr, "cron watcher failed, ignoring ...\n");
 
 	/* Update timer every lap */
 	tv.tv_sec += TIMEOUT;
@@ -42,27 +46,34 @@ static void cron_job(uev_t *w, void *UNUSED(arg), int UNUSED(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)
 {
-	uev_t cron_watcher;
 	uev_ctx_t ctx;
 	time_t when, interval;
+	uev_t cron;
+	int rc;
 
 	uev_init(&ctx);
 
 	gettimeofday(&tv, NULL);
+	when = tv.tv_sec + TIMEOUT;
+
 	printf("Start of test %s", ctime(&tv.tv_sec));
 	printf("Expected cron %s", ctime(&when));
-	
-	when     = tv.tv_sec + TIMEOUT;
-	interval = INTERVAL;
-	uev_cron_init(&ctx, &cron_watcher, cron_job, NULL, when, interval);
 
-	return uev_run(&ctx, 0);
+	interval = INTERVAL;
+	uev_cron_init(&ctx, &cron, cron_job, NULL, when, interval);
+
+	rc = uev_run(&ctx, 0);
+	fail_unless(result == 0);
+
+	return rc;
 }
 
 /**

tests/event.c

@@ -0,0 +1,78 @@
+/* Verifies eventfd support
+ *
+ * Copyright (c) 2018-2019  Joachim Nilsson <troglobit@gmail.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 "check.h"
+#include <err.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#define LAPS 10
+pid_t pid;
+
+static void cb(uev_t *w, void *arg, int events)
+{
+	static int num = LAPS;
+
+	num--;
+//	printf("Got event %d ...\n", LAPS - num);
+	if (num == 0) {
+		waitpid(pid, NULL, 0);
+		uev_exit(w->ctx);
+	}
+}
+
+int main(void)
+{
+	uev_ctx_t ctx;
+	uev_t ev;
+	int i;
+
+	/* Initialize libuEv */
+	uev_init(&ctx);
+
+	/* Setup callbacks */
+	uev_event_init(&ctx, &ev, cb, NULL);
+
+	pid = fork();
+	if (-1 == pid)
+		err(1, "fork");
+
+	/* Start event loop */
+	if (pid > 0)
+		return uev_run(&ctx, 0);
+
+	for (i = 0; i < LAPS; i++) {
+		uev_event_post(&ev);
+		usleep(10000);
+	}
+
+	return 0;
+}
+
+/**
+ * Local Variables:
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

tests/signal.c

@@ -1,6 +1,6 @@
 /* Multiple signals, segfault and fork() to test sub-processes.
  *
- * Copyright (c) 2015  Joachim Nilsson <troglobit@gmail.com>
+ * Copyright (c) 2015-2019  Joachim Nilsson <troglobit@gmail.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
@@ -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)
-                warnx("PID %d exited, bye.", pid);
+	if (-1 != 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;
+	int status = 0;
 
-        pid = fork();
-        if (-1 == pid)
-                err(1, "fork");
+	pid = fork();
+	if (-1 == pid)
+		err(1, "fork");
 	if (!pid) {
 		status = callback(arg, 6137, NULL);
-                exit(status);
-        }
+		exit(status);
+	}
 
-        if (waitpid(pid, &status, 0) == -1)
-                err(1, "waitpid");
+	if (waitpid(pid, &status, 0) == -1)
+		err(1, "waitpid");
 
 	if (WIFEXITED(status))
 		printf("Child exited normally => %d\n", WEXITSTATUS(status));
@@ -106,16 +105,16 @@ 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);
 }
 
 int main(void)
 {
-	uev_t sigsegv_watcher, sigchld_watcher, timeout_watcher, deadline_watcher;
 	uev_ctx_t ctx;
+	uev_t sigsegv_watcher, sigchld_watcher, timeout_watcher, deadline_watcher;
 
 	/* Initialize libuEv */
 	uev_init(&ctx);

tests/timer.c

@@ -3,26 +3,43 @@
 #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 UNUSED(events))
+static void cb(uev_t *w, void *arg, int events)
 {
 	struct timeval now;
 
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	gettimeofday(&now, NULL);
 	fail_unless(now.tv_sec == start.tv_sec + TIMEOUT);
 
+	result = 0;
 	uev_exit(w->ctx);
 }
 
 int main(void)
 {
-	uev_t w;
 	uev_ctx_t ctx;
+	uev_t w;
+	int rc;
 
 	uev_init(&ctx);
 	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:
+ */