Bump version for v1.6.0 release

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

.gitignore

@@ -4,6 +4,9 @@
 *.so
 *.so.*
 *.a
+*.la
+*.lo
+*.html
 .deps
 .libs
 compile
@@ -21,5 +24,7 @@ aclocal.m4
 ar-lib
 autom4te.cache
 bench
-test
-libuev*
+libuev*.tar.*
+libuev.pc
+!libuev.pc.in
+test-driver

.travis.yml

@@ -2,7 +2,7 @@
 # Defaults to GNU GCC and autotools: ./configure && make && make test
 language: c
 
-# We don't need to install packages, use dockerized build, quicker
+# Use docker for quicker builds, it now allows https://docs.travis-ci.com/user/apt/
 sudo: false
 
 env:
@@ -17,14 +17,13 @@ addons:
       name: "troglobit/libuev"
       description: "libuEv | Simple event loop for Linux"
     notification_email: troglobit@gmail.com
-    build_command_prepend: "./autogen && ./configure --enable-examples"
+    build_command_prepend: "./autogen && ./configure"
     build_command: "make clean all"
     branch_pattern: dev
 
-# We don't use configure, so we must define our own build script.
 script:
   - ./autogen.sh
-  - ./configure --disable-silent-rules --enable-examples
+  - ./configure --disable-silent-rules
   - make clean
   - make -j5
-  - make test
+  - make check

API.md

@@ -0,0 +1,283 @@
+API Documentation
+=================
+
+* [Introduction](#introduction)
+* [Overview](#overview)
+  * [Create an Event Context](#create-an-event-context)
+  * [Register an Event Watcher](#register-an-event-watcher)
+  * [Start Event Loop](#start-event-loop)
+  * [Summary](#summary)
+* [Using -luev](#using--luev)
+* [Joystick Example](#joystick-example)
+
+
+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
+signals.  The [Summary](#summary) details a slight caveat on signals.
+
+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
+the wall clock changes, either via NTP or user input.
+
+**NOTE:** On some systems, embedded in particular, `time_t` is a 32-bit
+  integer that wraps around in the year 2038.  A [GLIBC workaround][]
+  (`-D_TIME_BITS=64`) protects those systems, but users of other C
+  libraries have no known workarounds.  It is strongly recommended to
+  use relative timers as often as possible.
+
+
+Overview
+--------
+
+```C
+/*
+ * Callback example, arg comes from the watcher's *_init() function,
+ * 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.
+ */
+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_exit        (uev_ctx_t *ctx);
+int uev_run         (uev_ctx_t *ctx, int flags);         /* UEV_NONE, UEV_ONCE, and/or UEV_NONBLOCK */
+
+/* I/O watcher:     fd      *MUST* be non-blocking!
+ *                  events  combination of the main flags:  UEV_READ, UEV_WRITE,
+ *                                                          UEV_EDGE, UEV_ONESHOT
+ */
+int uev_io_init     (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events);
+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 */
+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 */
+int uev_timer_stop  (uev_t *w);                          /* Stop a timer */
+
+/* Cron watcher:    schedule an absolute timer, when and period in time_t seconds */
+int uev_cron_init   (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, time_t when, time_t period);
+int uev_cron_set    (uev_t *w, int when, time_t period); /* Change when or period */
+int uev_cron_start  (uev_t *w);                          /* Restart a stopped cron */
+int uev_cron_stop   (uev_t *w);                          /* Stop a cron */
+
+/* Signal watcher:  signo is the signal to wait for, e.g., SIGTERM */
+int uev_signal_init (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo);
+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 */
+```
+
+
+### Create an Event Context
+
+To monitor events the developer first creates an *event context*, this
+is achieved by calling `uev_init()` with a pointer to a (thread) local
+`uev_ctx_t` variable.
+
+```C
+uev_ctx_t ctx;
+
+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.
+
+Here is a signal example:
+
+```C
+void cleanup_exit(uev_t *w, void *arg, int events)
+{
+    /* Graceful exit, with optional cleanup ... */
+    uev_exit(w->ctx);
+}
+
+int main(void)
+{
+    uev_t sigterm_watcher;
+
+    .
+    .
+    uev_signal_init(&ctx, &sigterm_watcher, cleanup_exit, NULL, SIGTERM);
+    .
+    .
+}
+```
+
+
+### Start Event Loop
+
+When all watchers are registered, call the *event loop* with `uev_run()`
+and the argument to the event context.  The `flags` parameter can be
+used to integrate [libuEv][] into another event loop.
+
+In this example we set `flags` to none:
+
+```C
+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.
+
+**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.
+
+### Summary
+
+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
+
+**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
+  opened in blocking mode.  Be careful out there!
+
+**Note 2:** When closing a descriptor or socket, make sure to first stop
+  your watcher, if possible.  This will help prevent any nasty side
+  effects on your program.
+
+**Note 3:** a certain amount of care is needed when dealing with APIs
+  that employ signalfd.  If your application use `system()` you replace
+  that with `fork()`, and then in the child, unblock all signals blocked
+  by your parent process, before you run `exec()`.  This because Linux
+  does not unblock signals for your children, and neither does most
+  (all?)  C-libraries.  See the [finit][6] project's implementation of
+  `run()` for an example of this.  For more details on this issue, see
+  [this article][4] at [lwn.net](http://lwn.net).
+
+
+Using -luev
+-----------
+
+LibuEv is by default installed as a library with a few header files, you
+should only ever need to include one:
+
+```C
+#include <uev/uev.h>
+```
+
+The output from the `pkg-config` tool holds no surprises:
+
+```sh
+$ pkg-config --libs --static --cflags libuev
+-I/usr/local/include -L/usr/local/lib -luev
+```
+
+The prefix path `/usr/local/` shown here is only the default.  Use the
+`configure` script to select a different prefix when installing libuEv.
+
+For GNU autotools based projects, use the following in `configure.ac`:
+
+```sh
+# Check for required libraries
+PKG_CHECK_MODULES([uev], [libuev >= 1.4.0])
+```
+
+and in your `Makefile.am`:
+
+```sh
+proggy_CFLAGS = $(uev_CFLAGS)
+proggy_LDADD  = $(uev_LIBS)
+```
+
+
+Joystick Example
+----------------
+
+Here follows a very brief example to illustrate how one can use libuEv
+to act upon joystick input.
+
+```C
+#include <err.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <uev/uev.h>
+
+struct js_event {
+    uint32_t time;      /* event timestamp in milliseconds */
+    int16_t  value;     /* value */
+    uint8_t  type;      /* event type */
+    uint8_t  number;    /* axis/button number */
+} e;
+
+static void joystick_cb(uev_t *w, void *arg, int events)
+{
+    read(w->fd, &e, sizeof(e));
+
+    switch (e.type) {
+    case 1:
+        printf("Button %d %s\n", e.number, e.value ? "pressed" : "released");
+        break;
+
+    case 2:
+        printf("Joystick axis %d moved, value %d!\n", e.number, e.value);
+        break;
+    }
+}
+
+int main(void)
+{
+    int fd;
+    uev_t watcher;
+    uev_ctx_t ctx;
+
+    fd = open("/dev/input/js1", 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);
+
+    puts("Starting, press Ctrl-C to exit.");
+
+    return uev_run(&ctx, 0);
+}
+```
+
+To build the example, follow installation instructions below, then save
+the code as `joystick.c` and call GCC
+
+```sh
+$ gcc `pkg-config --libs --static --cflags libuev` -o joystick joystick.c
+```
+
+Alternatively, call the `Makefile` with <kbd>make joystick</kbd> from
+the unpacked [libuEv][] distribution.
+
+More complete and relevant example uses of [libuEv][] is the FTP/TFTP
+server [uftpd][5], and the Linux `/sbin/init` replacement [finit][6].
+Both successfully employ [libuEv][].
+
+Also see the `bench.c` program (<kbd>make bench</kbd> from within the
+library) for [reference benchmarks][7] against [libevent][1] and
+[libev][2].
+
+[1]:      http://libevent.org
+[2]:      http://software.schmorp.de/pkg/libev.html
+[4]:      http://lwn.net/Articles/415684/
+[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
+[GLIBC workaround]: https://sourceware.org/glibc/wiki/Y2038ProofnessDesign

ChangeLog

@@ -1 +0,0 @@
-ChangeLog.md

ChangeLog.md

@@ -4,14 +4,99 @@ Change Log
 All notable changes to the project are documented in this file.
 
 
+[v1.6.0][] - 2017-09-18
+-----------------------
+
+### Changes
+- Support for edge triggered and oneshot event types
+- Add `make package` build target to trigger a `.deb` package build
+- Support 64 bit `time_t` on 32 bit GLIBC systems
+
+### Fixes
+- `bench.c`: Use `signal.h`, not non-standard `sys/signal.h`
+
+
+[v1.5.2][] - 2016-11-27
+-----------------------
+
+### Fixes
+- Fix build regression in v1.5.1
+
+
+[v1.5.1][] - 2016-11-27
+-----------------------
+
+### Changes
+- Add support for checking if a watcher is active.
+- Refactor unit testing framework
+
+
+[v1.5.0][] - 2016-10-30
+-----------------------
+
+### Changes
+- Add support for absolute timers with the `uev_cron_*()` API.
+- Update build & install instructions in README
+
+### Fixes
+- Fix `uev_timer_set()` so that it returns error in case the underlying
+  Linux timerfd API fails.
+
+
+[v1.4.2][] - 2016-06-25
+-----------------------
+
+### Changes
+- Add range checks for `period` and `timeout` to `uev_timer_init()` and
+  `uev_timer_set()`.  If either on is `< 0` libuEv now return `ERANGE`.
+
+
+[v1.4.1][] - 2016-04-22
+-----------------------
+
+### Changes
+- Add some `pkg-config` integration tips for developers using libuEv
+  with GNU autotools in their projects.
+
+### Fixes
+- Add missing `SFD_CLOEXEC` and `TFD_CLOEXEC` to signal and timer file
+  descriptors.  This prevents these file descriptors from "leaking" into
+  sub-processes of the parent thread.  The kernel will atomically close
+  these descriptors for forked-off children calling the exec*() family
+  of syscalls.
+- Minor coding style fixes and simplification of build scripts.
+
+
+[v1.4.0][] - 2016-03-22
+-----------------------
+
+This release changes the header file namespace, which was silently
+introduced in [v1.2.1][].  Apologies for any problems this may cause!
+
+### Changes
+- Change namespace for header files: `libuev/` to `uev/`, e.g. using
+  `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
+
+
+[v1.3.1][] - 2016-02-02
+-----------------------
+
+### Fixes
+- Remove symlinks to Markdown files from GIT
+- Distribute and install Markdown files: README.md, etc.
+
+
 [v1.3.0][] - 2016-01-22
 -----------------------
 
 ### Changes
 - Change to GNU configure and build system
-- Default optimization is now -O2, not -Os, which can be a bit
-  unpredictable with some cross compiler toolchains.  -O2 is
-  the tried and tested path, and default in autotools
+- Default optimization is now `-O2`, not `-Os`, which can be a bit
+  unpredictable with some cross compiler toolchains.  `-O2` is the
+  tried and tested path, and default in autotools
 - Added `-Wextra` to the previous `-W -Wall`, drop `-Werror`
   which is supposed to be used by maintainer(s) only.
 
@@ -65,7 +150,7 @@ Minor bugfix release.
   called `private.h`.  This will hopefully make it easier to understand
   what a user of libuEv is allowed to play around with.  Thanks to @vonj
   for the discussions around this!
-- All builds of libuEv now default to use -fPIC, this bloats the code
+- All builds of libuEv now default to use `-fPIC`, this bloats the code
   slightly, but ensures that linking works for all use cases, withouth
   introducing unnecessary complexity.
 
@@ -195,7 +280,12 @@ v0.0.1 - 2012-03-17
 Lua users mailing list.
 
 
-[UNRELEASED]: https://github.com/troglobit/libuev/compare/v1.2.3...HEAD
+[UNRELEASED]: https://github.com/troglobit/libuev/compare/v1.4.2...HEAD
+[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
+[v1.3.1]: https://github.com/troglobit/libuev/compare/v1.3.0...v1.3.1
+[v1.3.0]: https://github.com/troglobit/libuev/compare/v1.2.3...v1.3.0
 [v1.2.3]: https://github.com/troglobit/libuev/compare/v1.2.2...v1.2.3
 [v1.2.2]: https://github.com/troglobit/libuev/compare/v1.2.1...v1.2.2
 [v1.2.1]: https://github.com/troglobit/libuev/compare/v1.2.0...v1.2.1

LICENSE

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

Makefile.am

@@ -1,36 +1,12 @@
 ACLOCAL_AMFLAGS     = -I m4
+SUBDIRS             = src tests
+DIST_SUBDIRS        = src examples tests
+doc_DATA            = API.md README.md LICENSE
+EXTRA_DIST          = API.md README.md LICENSE AUTHORS ChangeLog.md
 
-lib_LTLIBRARIES     = libuev.la
-pkginclude_HEADERS  = uev.h private.h queue.h
-libuev_la_SOURCES   = uev.c io.c timer.c signal.c
-
-check_PROGRAMS      = bench
-bench_CPPFLAGS      = -D_GNU_SOURCE
-bench_LDADD         = $(top_srcdir)/libuev.la
-
-libuev_la_CPPFLAGS  = -D_GNU_SOURCE
-libuev_la_CFLAGS    = -W -Wall -Wextra
-libuev_la_LDFLAGS   = $(AM_LDFLAGS) -version-info 1:0:0
-
-doc_DATA            = README LICENSE
-#EXTRA_DIST          = README.md AUTHORS LICENSE ChangeLog.md
-
-DIST_SUBDIRS        = examples
-SUBDIRS             = .
-if ENABLE_EXAMPLES
-  SUBDIRS          += examples
-endif
-
-test joystick: all-recursive
-	./examples/$@
-
-check-local:
-	@echo "  BENCH    $(PACKAGE)"
-	@./bench
-if ENABLE_EXAMPLES
-	@echo "  TEST     $(PACKAGE)"
-	@./examples/test
-endif
+## Generate .deb package
+package:
+	@dpkg-buildpackage -uc -us -B
 
 ## Generate MD5 checksum file
 MD5 = md5sum

README

@@ -1 +0,0 @@
-README.md

README.md

@@ -3,308 +3,95 @@ libuEv | Simple event loop for Linux
 [![Travis Status][]][Travis] [![Coverity Status][]][Coverity Scan]
 
 
-Table of Contents
------------------
-
 * [Introduction](#introduction)
-* [API](#api)
-  * [Create an Event Context](#create-an-event-context)
-  * [Register an Event Watcher](#register-an-event-watcher)
-  * [Start Event Loop](#start-event-loop)
-  * [Summary](#summary)
-* [Joystick Example](#joystick-example)
+* [API](API.md#overview)
+  * [Create an Event Context](API.md#create-an-event-context)
+  * [Register an Event Watcher](API.md#register-an-event-watcher)
+  * [Start Event Loop](API.md#start-event-loop)
+  * [Summary](API.md#summary)
+* [Using -luev](API.md#using--luev)
+* [Joystick Example](API.md#joystick-example)
 * [Build & Install](#build--install)
 * [Origin & References](#origin--references)
 
 
+> “Event driven software improves concurrency” -- [Dave Zarzycki, Apple][]
+
 Introduction
 ------------
 
-> “Why an event loop, why not use threads?”
-
-With the advent of light-weight processes (threads) programmers these
-days have a [golden hammer](http://c2.com/cgi/wiki?GoldenHammer) they
-often swing without consideration.  Event loops and non-blocking I/O is
-often a far easier approach, as well as less error prone.
-
-The purpose of many applications is, with a little logic sprinkled on
-top, to act on network packets entering an interface, timeouts expiring,
-mouse clicks, or other types of events.  Such applications are often
-very well suited to use an event loop.
-
-Applications that need to churn massively parallel algorithms are more
-suitable for running multiple (independent) threads on several CPU
-cores.  However, threaded applications must deal with the side effects
-of concurrency, like race conditions, deadlocks, live locks, etc.
-Writing error free threaded applications is hard, debugging them can be
-even harder.
-
-Sometimes the combination of multiple threads *and* an event loop per
-thread can be the best approach, but each application of course needs to
-be broken down individually to find the most optimal approach.  Do keep
-in mind, however, that not all systems your application will run on have
-multiple CPU cores -- some small embedded systems still use a single CPU
-core, even though they run Linux, with multiple threads a program may
-actually run slower!  Always profile your program, and if possible, test
-it on different architectures.
-
 [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.  The primary target of
-[libuEv][] is a modern Linux system.
+small size overhead impact of the library.
 
 Experienced developers may appreciate that [libuEv][] is built on top of
-modern Linux APIs: epoll, timerfd and signalfd.  Note, a certain amount
-of care is needed when dealing with APIs that employ signalfd.  For
-details, see [this article][4] at [lwn.net](http://lwn.net).
-
-> “Event driven software improves concurrency” -- [Dave Zarzycki, Apple]
+modern Linux APIs: epoll, timerfd and signalfd.
 
 
-API
----
+Example
+-------
 
-The C interface to [libuEv][] is very simple.  It handles three different
-types of events: I/O (files, sockets, message queues, etc.), timers, and
-signals.  With a slight caveat on signals
+The library documentation is available as a [separate document](API.md).
 
 ```C
+#include <stdio.h>
+#include <uev/uev.h>
 
-    /* Callback example, arg is passed from watcher's *_init()
-     * w->fd holds the file descriptor, events is set by libuEv
-     * to indicate if any of UEV_READ and/or UEV_WRITE is ready.
-     */
-    void callback       (uev_t *w, void *arg, int events);
+static void cb(uev_t *w, void *arg, int events)
+{
+	puts("Every other second");
+}
 
-    /* Event loop:      Notice the use of flags! */
-    int uev_init        (uev_ctx_t *ctx);
-    int uev_exit        (uev_ctx_t *ctx);
-    int uev_run         (uev_ctx_t *ctx, int flags);         /* UEV_NONE, UEV_ONCE, and/or UEV_NONBLOCK */
-    
-    /* I/O watcher:     fd is non-blocking, events is UEV_READ and/or UEV_WRITE */
-    int uev_io_init     (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events);
-    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:   timeout 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 */
-    int uev_timer_stop  (uev_t *w);                          /* Stop a timer */
-    
-    /* Signal watcher:  signo is the signal to wait for, e.g., SIGTERM */
-    int uev_signal_init (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo);
-    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 */
+int main(void)
+{
+	uev_t timer;
+	uev_ctx_t ctx;
 
+	uev_init(&ctx);
+	uev_timer_init(&ctx, &timer, cb, NULL, 2 * 1000, 0);
+
+	return uev_run(&ctx, 0);
+}
 ```
 
-### Create an Event Context
-
-To monitor events the developer first creates an *event context*, this
-is achieved by calling `uev_init()` with a pointer to a (thread) local
-`uev_ctx_t` variable.
-
-```C
-
-    uev_ctx_t ctx;
-    
-    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.
-
-Here is a signal example:
-
-```C
-
-    void cleanup_exit(uev_t *w, void *arg, int events)
-    {
-        /* Graceful exit, with optional cleanup ... */
-        uev_exit(w->ctx);
-    }
-    
-    int main(void)
-	{
-	    uev_t sigterm_watcher;
-        .
-		.
-		.
-        uev_signal_init(&ctx, &sigterm_watcher, cleanup_exit, NULL, SIGTERM);
-		.
-		.
-		.
-	}
-
-```
-
-
-### Start Event Loop
-
-When all watchers are registered, call the *event loop* with `uev_run()`
-and the argument to the event context.  The `flags` parameter can be
-used to integrate [libuEv][] into another event loop.
-
-In this example we set `flags` to none:
-
-```C
-
-    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.
-
-**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.
-
-### Summary
-
-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
-
-**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
-opened in blocking mode.  Be careful out there!
-
-**Note 2:** When closing a descriptor or socket, make sure to first stop
-  your watcher, if possible.  This will help prevent any nasty side
-  effects on your program.
-
-**Note 3:** As mentioned above, a certain amount of care is needed when
-dealing with signalfd.  This means that if your application, for
-instance, uses `system()` you must redesign that to use `fork()`, and
-then in the child, unblock all signals blocked by your parent process,
-before you run `exec()`.  This because Linux does not unblock signals
-for your children, and neither does most (all?) C-libraries.  An example
-of this, from [finit][6], implementing `run()` as a better replacement
-to `system()`, which sucks anyawy :)
-
-
-Joystick Example
-----------------
-
-Here follows a very brief example to illustrate how one can use
-[libuEv][] to act upon joystick input.
-
-```C
-
-    #include <err.h>
-    #include <errno.h>
-    #include <stdio.h>
-    #include <stdint.h>
-    #include <fcntl.h>
-    #include <unistd.h>
-    
-    #include "uev.h"
-    
-    struct js_event {
-    	uint32_t time;		/* event timestamp in milliseconds */
-    	int16_t  value;		/* value */
-    	uint8_t  type;		/* event type */
-    	uint8_t  number;	/* axis/button number */
-    } e;
-    
-    static void joystick_cb(uev_t *w, void *arg, int events)
-    {
-    	read (w->fd, &e, sizeof(e));
-    
-    	switch (e.type) {
-    	case 1:
-    		if (e.value) printf("Button %d pressed\n", e.number);
-    		else 	     printf("Button %d released\n", e.number);
-    		break;
-    
-    	case 2:
-    		printf("Joystick axis %d moved, value %d!\n", e.number, e.value);
-    		break;
-    	}
-    }
-    
-    int main(void)
-    {
-    	int       fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
-    	uev_t     js1_watcher;
-    	uev_ctx_t ctx;
-    
-    	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);
-    
-    	puts("Starting, press Ctrl-C to exit.");
-    
-    	return uev_run(&ctx, 0);
-    }
-
-```
-
-To compile the program, save the code as `joystick.c` and call GCC with
-`gcc -o joystick joystick.c io.c timer.c signal.c main.c` from this
-directory, skips using a Makefile altogether.  Alternatively, call the
-`Makefile` with <kbd>make joystick</kbd> from this directory.
-
-More complete and relevant example uses of [libuEv][] is the FTP/TFTP
-server [uftpd][5], and the Linux `/sbin/init` replacement [finit][6].
-Both successfully employ [libuEv][].
-
-Also see the `bench.c` program (<kbd>make bench</kbd> from within the
-library) for [reference benchmarks][7] against [libevent][1] and
-[libev][2].
-
 
 Build & Install
 ---------------
 
-The library is built for and developed on GNU/Linux systems, patches to
-support *BSD and its kqueue interface are most welcome.
-
 libuEv use the GNU configure and build system.  To try out the bundled
 examples, use the `--enable-examples` switch to the `configure` script.
+There is also a limited unit test suite that can be useful to learn how
+the library works.
 
-    ./configure
-    make all
-    make test
-    make install
+```sh
+./configure
+make -j5
+make test
+sudo make install-strip
+sudo ldconfig
+```
 
-The resulting .so file is ~14 kiB when stripped (`make install-strip`).
+The resulting .so file is ~14 kiB.
 
 
 Origin & References
 -------------------
 
 [libuEv][] was originally based on [LibUEvent][8] by [Flemming Madsen][]
-but has been completely rewritten with a much clearer API.  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][].
+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][].  It is
+built for and developed on GNU/Linux systems, patches to support *BSD
+and its [kqueue][] interface are most welcome.
 
-[libuEv][] is developed and maintained by [Joachim Nilsson][].
 
 [1]: http://libevent.org
 [2]: http://software.schmorp.de/pkg/libev.html
 [3]: http://unix.com/man-page/All/3x/XtDispatchEvent
-[4]: http://lwn.net/Articles/415684/
-[5]: https://github.com/troglobit/uftpd
-[6]: https://github.com/troglobit/finit
-[7]: http://libev.schmorp.de/bench.html
 [8]: http://code.google.com/p/libuevent/
 [9]: https://github.com/kazuho/picoev
 [Travis]:          https://travis-ci.org/troglobit/libuev
@@ -312,14 +99,9 @@ event library used for inspiration is the very small [Picoev][9] by
 [Coverity Scan]:   https://scan.coverity.com/projects/3846
 [Coverity Status]: https://scan.coverity.com/projects/3846/badge.svg
 [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
-
-<!--
-  -- Local Variables:
-  --  mode: markdown
-  -- End:
-  -->

TODO

@@ -1 +0,0 @@
-TODO.md

TODO.md

@@ -1,5 +1,9 @@
 LibuEv TODO
 ===========
 
-* Make port to *BSD kqueue API, http://en.wikipedia.org/wiki/Kqueue
+* Add standard UNIX backend with select() and timer_create()
+  See SMCRoute and toolbox for examples.
+* Port to *BSD kqueue API, http://en.wikipedia.org/wiki/Kqueue
+  Also in UNIX Network Progamming, by W. Richard Stevens 3rd ed.
+* Restore Lua bindings now that libuEv itself has stabilized
 

configure.ac

@@ -1,24 +1,14 @@
-# Use v2.61 for backwards compat with Ubuntu 12.04 LTS
-AC_PREREQ([2.61])
-AC_INIT(libuEv, 1.3.0, https://github.com/troglobit/libuev/issues, libuev)
+AC_INIT(libuev, 1.6.0, https://github.com/troglobit/libuev/issues)
 AM_INIT_AUTOMAKE([1.11 foreign no-dist-gzip dist-xz])
 AM_SILENT_RULES([yes])
 
-AC_CONFIG_SRCDIR(uev.c)
+AC_CONFIG_SRCDIR(src/uev.c)
 AM_CONFIG_HEADER(config.h)
-AC_CONFIG_FILES([Makefile examples/Makefile])
+AC_CONFIG_FILES([Makefile src/libuev.pc src/Makefile examples/Makefile tests/Makefile])
 AC_CONFIG_MACRO_DIR([m4])
 
 AC_PROG_CC
 AM_PROG_AR
 LT_INIT
 
-AC_ARG_ENABLE([examples],
-	[AS_HELP_STRING([--enable-examples], [build examples])],
-	[enable_examples=yes], [])
-AM_CONDITIONAL([ENABLE_EXAMPLES], [test "$enable_examples" = yes])
-
-AC_HEADER_STDC
-AC_C_CONST
-
 AC_OUTPUT

debian/.gitignore

@@ -0,0 +1,8 @@
+tmp/*
+libuev/*
+libuev*
+autoreconf*
+debhelper*
+files
+!*.dirs
+!*.install

debian/README.debian

@@ -0,0 +1,14 @@
+libuEv for Debian
+-----------------
+
+This is the upstream pre-packaged version of libuEv.  It consists of two
+.deb packages: one with only the .so library and one -dev package with
+headers and the .a library for static linking.  It builds on any Debian
+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
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Thu, 21 Sep 18:10, 2017

debian/changelog

@@ -0,0 +1,18 @@
+libuev (1.6.0-1) unstable; urgency=medium
+
+  * Support for edge triggered and oneshot event types
+  * Support for 64 bit time_t on 32 bit GLIBC systems
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Mon, 18 Sep 2017 07:49:23 +0200
+
+libuev (1.5.2-2) unstable; urgency=low
+
+  * Minor packaging fixes.
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Sun, 12 Mar 2017 17:48:00 +0100
+
+libuev (1.5.2-1) unstable; urgency=low
+
+  * Initial release.
+
+ -- Joachim Nilsson <troglobit@gmail.com>  Mon, 28 Nov 2016 22:53:35 +0100

debian/clean

@@ -0,0 +1 @@
+config.log

debian/compat

@@ -0,0 +1 @@
+9

debian/control

@@ -0,0 +1,39 @@
+Source: libuev
+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
+Homepage: https://github.com/troglobit/libuev/
+Vcs-Git: https://github.com/troglobit/libuev.git
+Vcs-Browser: https://github.com/troglobit/libuev/
+
+Package: libuev-dev
+Priority: extra
+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.
+ .
+ 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.
+ .
+ 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.
+
+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.
+ .
+ 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.

debian/copyright

@@ -0,0 +1,26 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Source: https.//github.com/troglobit/libuev/
+
+Files: *
+Copyright: 2013-2017 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:
+
+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/docs

@@ -0,0 +1,2 @@
+API.md
+README.md

debian/libuev-dev.dirs

@@ -0,0 +1,2 @@
+usr/lib
+usr/include

debian/libuev-dev.install

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

debian/libuev.dirs

@@ -0,0 +1 @@
+usr/lib

debian/libuev.install

@@ -0,0 +1 @@
+usr/lib/*/lib*.so.*

debian/rules

@@ -0,0 +1,10 @@
+#!/usr/bin/make -f           
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+%:
+	dh $@ --with autoreconf
+
+override_dh_compress:
+	dh_compress -A -X.md

debian/source/format

@@ -0,0 +1 @@
+3.0 (native)

examples/.gitignore

@@ -0,0 +1,4 @@
+joystick
+signal
+cronrun
+test

examples/Makefile.am

@@ -1,4 +1,4 @@
-noinst_PROGRAMS = signal test joystick
+noinst_PROGRAMS = joystick
 AM_CPPFLAGS     = -I$(top_srcdir)
 AM_LDFLAGS      = -L$(top_srcdir)
 LIBS            = $(LTLIBINTL)

examples/joystick.c

@@ -1,6 +1,6 @@
 /* Simple example of how to use libuEv with Linux joystick API
  *
- * Copyright (c) 2014-2015  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2014-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
@@ -30,8 +30,6 @@
 
 #include "uev.h"
 
-#define UNUSED(arg) arg __attribute__ ((unused))
-
 struct js_event {
 	uint32_t time;		/* event timestamp in milliseconds */
 	int16_t  value;		/* value */
@@ -39,15 +37,14 @@ struct js_event {
 	uint8_t  number;	/* axis/button number */
 } e;
 
-static void joystick_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void joystick_cb(uev_t *w, void *arg, int events)
 {
-	if (read (w->fd, &e, sizeof(e)) < 0)
+	if (read(w->fd, &e, sizeof(e)) < 0)
 		errx(errno, "Failed reading joystick event");
 
 	switch (e.type) {
 	case 1:
-		if (e.value) printf("Button %d pressed\n", e.number);
-		else 	     printf("Button %d released\n", e.number);
+		printf("Button %d %s\n", e.number, e.value ? "pressed" : "released");
 		break;
 
 	case 2:
@@ -58,10 +55,11 @@ static void joystick_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
 
 int main(void)
 {
-	int       fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
-	uev_t     js1_watcher;
+	int fd;
+	uev_t js1_watcher;
 	uev_ctx_t ctx;
 
+	fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
 	if (fd < 0)
 		errx(errno, "Cannot find a joystick attached.");
 
@@ -75,8 +73,7 @@ int main(void)
 
 /**
  * Local Variables:
- *  compile-command: "gcc -o joystick joystick.c io.o timer.o signal.o main.o"
- *  version-control: t
+ *  compile-command: "make joystick"
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/Makefile.am

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

src/README.md

@@ -0,0 +1 @@
+../API.md

src/bench.c

@@ -44,11 +44,11 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/resource.h>
-#include <sys/signal.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ -140,7 +140,8 @@ static struct timeval *run_once(uev_ctx_t *ctx)
 
 		gettimeofday(&te, NULL);
 
-//		if (xcount != count) fprintf(stderr, "Xcount: %d, Rcount: %d\n", xcount, count);
+		if (xcount != count)
+			fprintf(stderr, "Xcount: %d, Rcount: %d\n", xcount, count);
 	}
 
 	timersub(&te, &ta, &ta);
@@ -229,7 +230,6 @@ int main(int argc, char **argv)
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/cron.c

@@ -0,0 +1,165 @@
+/* libuEv - Micro event loop library
+ *
+ * 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:
+ *
+ * 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 <string.h>		/* memset() */
+#include <sys/timerfd.h>
+#include <unistd.h>		/* close(), read() */
+
+#include "uev.h"
+
+/* Missing defines in GLIBC <= 2.24 */
+#ifndef TFD_TIMER_CANCEL_ON_SET
+#define TFD_TIMER_CANCEL_ON_SET (1 << 1)
+#endif
+#ifndef TFD_SETTIME_FLAGS
+#define TFD_SETTIME_FLAGS (TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET)
+#endif
+
+
+/**
+ * Create and start an at/cron job watcher
+ * @param ctx      A valid libuEv context
+ * @param w        Pointer to an uev_t watcher
+ * @param cb       Callback function for cron job
+ * @param arg      Optional callback argument
+ * @param when     First point in time to call @param cb
+ * @param interval For an at job this is zero, for cron the offset interval
+ *
+ * For at jobs set @param interval to zero and only use @param when.  For
+ * cron jobs, set @param interval to the offset.  E.g., if the job should
+ * run every five minutes set the @param tm_min of struct tm to five.
+ *
+ * Use mktime() to create the time_t arguments.  The special value zero
+ * may be used for @param when to denote 'now', where 'now' is when the
+ * event loop is started.  You can also treat time_t simply as a signed
+ * integer.  E.g., set @param interval to 3600 to create a cron job that
+ * runs every hour.
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_cron_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, time_t when, time_t interval)
+{
+	int fd;
+
+	if (when < 0 || interval < 0) {
+		errno = ERANGE;
+		return -1;
+	}
+
+	fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
+	if (fd < 0)
+		return -1;
+
+	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);
+	exit:
+		close(fd);
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * Reset an at/cron job watcher
+ * @param w        Watcher to reset
+ * @param when     First point in time to call @param cb
+ * @param interval For an at job this is zero, for cron the offset interval
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_cron_set(uev_t *w, time_t when, time_t interval)
+{
+	/* Every watcher must be registered to a context */
+	if (!w || !w->ctx) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (when < 0 || interval < 0) {
+		errno = ERANGE;
+		return -1;
+	}
+
+	/* Handle stopped timers */
+	if (w->fd < 0) {
+		/* Timer already stopped */
+		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;
+	}
+
+	w->u.c.when     = when;
+	w->u.c.interval = interval;
+
+	if (w->ctx->running) {
+		struct itimerspec time;
+
+		memset(&time, 0, sizeof(time));
+		time.it_value.tv_sec    = when;
+		time.it_interval.tv_sec = interval;
+		if (timerfd_settime(w->fd, TFD_SETTIME_FLAGS, &time, NULL) < 0)
+			return 1;
+	}
+
+	return uev_watcher_start(w);
+}
+
+/**
+ * Start a stopped at/cron job watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_cron_start(uev_t *w)
+{
+	return uev_timer_start(w);
+}
+
+/**
+ * Stop and unregister an at/cron job watcher
+ * @param w  Watcher to stop
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_cron_stop(uev_t *w)
+{
+	return uev_timer_stop(w);
+}
+
+/**
+ * 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-2015  Joachim Nilsson <troglobit()gmail!com>
+ * 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
@@ -23,7 +23,6 @@
  */
 
 #include <errno.h>
-
 #include "uev.h"
 
 
@@ -34,7 +33,7 @@
  * @param cb      I/O callback
  * @param arg     Optional callback argument
  * @param fd      File descriptor to watch, or -1 to register an empty watcher
- * @param events  Requested events to watch for, a mask of %UEV_READ and %UEV_WRITE
+ * @param events  Events to watch for: %UEV_READ, %UEV_WRITE, %UEV_EDGE, %UEV_ONESHOW
  *
  * @return POSIX OK(0) or non-zero with @param errno set on error.
  */
@@ -61,6 +60,10 @@ 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);
+
 	/* Ignore any errors, only to clean up anything lingering ... */
 	uev_io_stop(w);
 
@@ -91,7 +94,6 @@ int uev_io_stop(uev_t *w)
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/libuev.pc.in

@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PACKAGE@
+Description: Simple event loop for Linux
+Version: @VERSION@
+Requires:
+Libs: -L${libdir} -luev
+Cflags: -I${includedir}
+

src/private.h

@@ -31,13 +31,14 @@
 
 /* I/O, timer, or signal watcher */
 typedef enum {
-	UEV_IO_TYPE = 1,
-	UEV_TIMER_TYPE,
+	UEV_CRON_TYPE = 1,
+	UEV_IO_TYPE,
 	UEV_SIGNAL_TYPE,
+	UEV_TIMER_TYPE,
 } uev_type_t;
 
 /* Event mask, used internally only. */
-#define UEV_EVENT_MASK  (UEV_READ | UEV_WRITE)
+#define UEV_EVENT_MASK  (UEV_READ | UEV_WRITE | UEV_PRI | UEV_HUP | UEV_RDHUP | UEV_EDGE | UEV_ONESHOT)
 
 /* Main libuEv context type */
 typedef struct {
@@ -61,28 +62,37 @@ struct uev;
 	void          (*cb)(struct uev *, void *, int);         \
 	void           *arg;                                    \
 								\
-	/* Timer watchers, time in milliseconds */		\
-	int             timeout;                                \
-	int             period;                                 \
+	/* Arguments for different watchers */			\
+	union {							\
+		/* Cron watchers */				\
+		struct {					\
+			time_t when;				\
+			time_t interval;			\
+		} c;						\
 								\
-	/* Signal watchers */                                   \
-	int             signo;                                  \
+		/* Timer watchers, time in milliseconds */	\
+		struct {					\
+			int timeout;				\
+			int period;				\
+		} t;						\
+	} u;							\
 								\
 	/* Watcher type */					\
 	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_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_ */
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/signal.c

@@ -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-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
@@ -52,7 +52,7 @@ int uev_signal_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo
 	w->fd = -1;
 
 	sigemptyset(&mask);
-	fd = signalfd(-1, &mask, SFD_NONBLOCK);
+	fd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
 	if (fd < 0)
 		return -1;
 
@@ -151,7 +151,6 @@ int uev_signal_stop(uev_t *w)
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/timer.c

@@ -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-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
@@ -67,7 +67,12 @@ int uev_timer_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeou
 {
 	int fd;
 
-	fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+	if (timeout < 0 || period < 0) {
+		errno = ERANGE;
+		return -1;
+	}
+
+	fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
 	if (fd < 0)
 		return -1;
 
@@ -100,6 +105,11 @@ int uev_timer_set(uev_t *w, int timeout, int period)
 		return -1;
 	}
 
+	if (timeout < 0 || period < 0) {
+		errno = ERANGE;
+		return -1;
+	}
+
 	/* Handle stopped timers */
 	if (w->fd < 0) {
 		/* Timer already stopped */
@@ -113,15 +123,16 @@ int uev_timer_set(uev_t *w, int timeout, int period)
 			return -1;
 	}
 
-	w->timeout = timeout;
-	w->period  = period;
+	w->u.t.timeout = timeout;
+	w->u.t.period  = period;
 
 	if (w->ctx->running) {
 		struct itimerspec time;
 
 		msec2tspec(timeout, &time.it_value);
 		msec2tspec(period, &time.it_interval);
-		timerfd_settime(w->fd, 0, &time, NULL);
+		if (timerfd_settime(w->fd, 0, &time, NULL) < 0)
+			return 1;
 	}
 
 	return uev_watcher_start(w);
@@ -143,7 +154,7 @@ int uev_timer_start(uev_t *w)
 	if (-1 != w->fd)
 		uev_watcher_stop(w);
 
-	return uev_timer_set(w, w->timeout, w->period);
+	return uev_timer_set(w, w->u.t.timeout, w->u.t.period);
 }
 
 /**
@@ -169,7 +180,6 @@ int uev_timer_stop(uev_t *w)
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/uev.c

@@ -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-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
@@ -36,8 +36,9 @@
 
 static int _init(uev_ctx_t *ctx, int close_old)
 {
-	int fd = epoll_create1(EPOLL_CLOEXEC);
+	int fd;
 
+	fd = epoll_create1(EPOLL_CLOEXEC);
 	if (fd < 0)
 		return -1;
 
@@ -67,7 +68,7 @@ int uev_watcher_init(uev_ctx_t *ctx, uev_t *w, uev_type_t type, uev_cb_t *cb, vo
 	w->type   = type;
 	w->active = 0;
 	w->fd     = fd;
-	w->cb     = (void *)cb;
+	w->cb     = cb;
 	w->arg    = arg;
 	w->events = events;
 
@@ -123,6 +124,33 @@ int uev_watcher_stop(uev_t *w)
 	return 0;
 }
 
+/* Private to libuEv, do not use directly! */
+int uev_watcher_active(uev_t *w)
+{
+	if (!w)
+		return 0;
+
+	return w->active;
+}
+
+/* Private to libuEv, do not use directly! */
+int uev_watcher_rearm(uev_t *w)
+{
+	struct epoll_event ev;
+
+	if (!w || w->fd < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	ev.events   = w->events | EPOLLRDHUP;
+	ev.data.ptr = w;
+	if (epoll_ctl(w->ctx->fd, EPOLL_CTL_MOD, w->fd, &ev) < 0)
+		return -1;
+
+	return 0;
+}
+
 /**
  * Create an event loop context
  * @param ctx  Pointer to an uev_ctx_t context to be initialized
@@ -165,6 +193,7 @@ int uev_exit(uev_ctx_t *ctx)
 			continue;
 
 		switch (w->type) {
+		case UEV_CRON_TYPE:
 		case UEV_TIMER_TYPE:
 			uev_timer_stop(w);
 			break;
@@ -218,8 +247,10 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 	/* Start all dormant timers */
 	LIST_FOREACH(w, &ctx->watchers, link) {
+		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->timeout, w->period);
+			uev_timer_set(w, w->u.t.timeout, w->u.t.period);
 	}
 
 	while (ctx->running) {
@@ -273,6 +304,24 @@ int uev_run(uev_ctx_t *ctx, int flags)
 				}
 			}
 
+			if (UEV_CRON_TYPE == w->type) {
+				uint64_t exp;
+
+				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
+					if (errno != ECANCELED) {
+						uev_exit(ctx);
+						return -3;
+					}
+
+					events[i].events = UEV_HUP;
+				}
+
+				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;
 
@@ -281,8 +330,8 @@ int uev_run(uev_ctx_t *ctx, int flags)
 					return -3;
 				}
 
-				if (!w->period)
-					w->timeout = 0;
+				if (!w->u.t.period)
+					w->u.t.timeout = 0;
 			}
 
 			if (UEV_SIGNAL_TYPE == w->type) {
@@ -298,8 +347,12 @@ int uev_run(uev_ctx_t *ctx, int flags)
 			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);
+			}
 			if (UEV_TIMER_TYPE == w->type) {
-				if (!w->timeout)
+				if (!w->u.t.timeout)
 					uev_timer_stop(w);
 			}
 		}
@@ -311,10 +364,8 @@ int uev_run(uev_ctx_t *ctx, int flags)
 	return result;
 }
 
-
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

src/uev.h

@@ -30,26 +30,42 @@
 /* Max. number of simulateneous events */
 #define UEV_MAX_EVENTS  10
 
-/* I/O events, for signals and timers revents will always be UEV_READ */
+/* I/O events, signal and timer revents are always UEV_READ */
 #define UEV_NONE        0
 #define UEV_READ        EPOLLIN
 #define UEV_WRITE       EPOLLOUT
+#define UEV_PRI         EPOLLPRI
+#define UEV_HUP         EPOLLHUP
+#define UEV_RDHUP       EPOLLRDHUP
+#define UEV_EDGE        EPOLLET
+#define UEV_ONESHOT     EPOLLONESHOT
 
 /* Run flags */
 #define UEV_ONCE        1
 #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)
+
 /* Event watcher */
 typedef struct uev {
 	/* Private data for libuEv internal engine */
 	uev_private_t   type;
 
 	/* Public data for users to reference  */
+	int             signo;
 	int             fd;
 	uev_ctx_t      *ctx;
 } uev_t;
 
-/* Generic callback for watchers */
+/*
+ * 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.
+ */
 typedef void (uev_cb_t)(uev_t *w, void *arg, int events);
 
 /* Public interface */
@@ -67,6 +83,11 @@ int uev_timer_set      (uev_t *w, int timeout, int period);
 int uev_timer_start    (uev_t *w);
 int uev_timer_stop     (uev_t *w);
 
+int uev_cron_init      (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, time_t when, time_t interval);
+int uev_cron_set       (uev_t *w, time_t when, time_t interval);
+int uev_cron_start     (uev_t *w);
+int uev_cron_stop      (uev_t *w);
+
 int uev_signal_init    (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo);
 int uev_signal_set     (uev_t *w, int signo);
 int uev_signal_start   (uev_t *w);
@@ -76,7 +97,6 @@ int uev_signal_stop    (uev_t *w);
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

tests/.gitignore

@@ -0,0 +1,7 @@
+*.trs
+*.log
+active
+complete
+cronrun
+signal
+timer

tests/Makefile.am

@@ -0,0 +1,16 @@
+EXTRA_DIST      = check.h
+CLEANFILES      = *~ *.trs *.log
+
+TESTS           =
+TESTS          += active
+TESTS          += complete
+TESTS          += cronrun
+TESTS          += signal
+TESTS          += timer
+
+check_PROGRAMS  = $(TESTS)
+
+# Ignore warnings about unused result, in e.g. write()
+CFLAGS          = -W -Wall -Wextra -Wno-unused-result
+CPPFLAGS        = -D_GNU_SOURCE
+LDADD           = -L../src ../src/libuev.la

tests/active.c

@@ -0,0 +1,51 @@
+#include "check.h"
+#include <time.h>
+#include <sys/time.h>
+
+#define TIMEOUT1 2		/* 2 sec */
+#define TIMEOUT2 4		/* 4 sec */
+#define DAYLY    (24 * 60 * 60)	/* Seconds in one day */
+
+uev_t timer1;
+uev_t timer2;
+uev_t timer3;
+uev_t cron1;
+uev_t cron2;
+
+static void cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+{
+	fail_unless(w == &timer1);
+
+	fail_unless(uev_timer_active(&timer2));
+	fail_unless(!uev_timer_active(&timer3));
+	fail_unless(uev_cron_active(&cron1));
+	fail_unless(uev_cron_active(&cron2));
+
+	uev_timer_stop(&timer2);
+	uev_timer_stop(&cron2);
+
+	fail_unless(!uev_timer_active(&timer2));
+	fail_unless(!uev_cron_active(&cron2));
+
+	uev_exit(w->ctx);
+}
+
+int main(void)
+{
+	uev_ctx_t ctx;
+	struct timeval tomorrow;
+
+	gettimeofday(&tomorrow, NULL);
+	tomorrow.tv_sec += 24 * 60 * 60;
+
+	uev_init(&ctx);
+	uev_timer_init(&ctx, &timer1, cb, NULL, TIMEOUT1 * 1000, 0);
+	uev_timer_init(&ctx, &timer2, cb, NULL, TIMEOUT2 * 1000, 0);
+	uev_timer_init(&ctx, &timer3, cb, NULL, TIMEOUT2 * 1000, 0);
+	uev_timer_stop(&timer3);
+
+	uev_cron_init(&ctx, &cron1, cb, NULL, tomorrow.tv_sec, 24 * 60 * 60);
+	uev_cron_init(&ctx, &cron2, cb, NULL, tomorrow.tv_sec, 24 * 60 * 60);
+
+	return uev_run(&ctx, 0);
+}

tests/check.h

@@ -0,0 +1,81 @@
+#ifndef UEV_TESTS_CHECK_H_
+#define UEV_TESTS_CHECK_H_
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "../src/uev.h"
+
+#define UNUSED(arg) arg __attribute__ ((unused))
+
+#define fail_unless(test)						\
+  do {									\
+    if (!(test)) {							\
+      fprintf(stderr,							\
+	      "----------------------------------------------\n"	\
+	      "%s:%d: test FAILED:\nFailed test: %s\n"			\
+	      "----------------------------------------------\n",	\
+	      __FILE__, __LINE__, #test);				\
+      exit(1);								\
+    }									\
+  } while (0)
+
+static inline int test(int result, const char *fmt, ...)
+{
+	char buf[80];
+	size_t len;
+	va_list ap;
+	const char success[] = " \033[1m[ OK ]\033[0m\n";
+	const char failure[] = " \033[7m[FAIL]\033[0m\n";
+	const char dots[] = " .....................................................................";
+
+	va_start(ap, fmt);
+	len = vsnprintf(buf, sizeof(buf), fmt, ap);
+	va_end(ap);
+
+	write(STDERR_FILENO, buf, len);
+	write(STDERR_FILENO, dots, 60 - len); /* pad with dots. */
+
+	if (!result)
+		write(STDERR_FILENO, success, strlen(success));
+	else
+		write(STDERR_FILENO, failure, strlen(failure));
+
+	return result;
+}
+
+static inline int timespec_newer(const struct timespec *a, const struct timespec *b)
+{
+	if (a->tv_sec != b->tv_sec)
+		return a->tv_sec > b->tv_sec;
+
+	return a->tv_nsec > b->tv_nsec;
+}
+
+static inline char *timespec2str(struct timespec *ts, char *buf, size_t len)
+{
+	size_t ret, pos;
+	struct tm t;
+
+	memset(buf, 0, len);
+
+	tzset();
+	if (localtime_r(&(ts->tv_sec), &t) == NULL)
+		return buf;
+
+	ret = strftime(buf, len, "%F %T", &t);
+	if (ret == 0)
+		return buf;
+	len -= ret - 1;
+
+	pos  = strlen(buf);
+	len -= pos;
+	snprintf(&buf[pos], len, ".%09ld", ts->tv_nsec);
+
+	return buf;
+}
+
+#endif /* UEV_TESTS_CHECK_H_ */

tests/complete.c

@@ -22,14 +22,8 @@
  * THE SOFTWARE.
  */
 
+#include "check.h"
 #include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>		/* intptr_t */
-
-#include "uev.h"
-
-#define UNUSED(arg) arg __attribute__ ((unused))
 
 typedef struct {
 	int counter;
@@ -138,15 +132,13 @@ int main(void)
 	uev_run(&ctx, 0);
 
 	fprintf(stderr, "Period is %d must be 10: %s\n", period, 10 == period ? "OK" : "ERROR!");
-	if (10 != period)
-		return 1;
+	fail_unless(10 == period);
 
 	return 0;
 }
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

tests/cronrun.c

@@ -0,0 +1,73 @@
+/* Test cron API in libuEv event library
+ *
+ * Copyright (c) 2016  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 <time.h>
+#include <sys/time.h>
+
+#define TIMEOUT  2
+#define INTERVAL 2
+
+struct timeval tv;
+
+static void cron_job(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+{
+	static int laps = 3;
+	struct timeval now;
+
+	/* Update timer every lap */
+	tv.tv_sec += TIMEOUT;
+
+	gettimeofday(&now, NULL);
+	printf("Cron job HELO %s", ctime(&now.tv_sec));
+	fail_unless(now.tv_sec == tv.tv_sec);
+
+	if (!laps--)
+		uev_exit(w->ctx);
+}
+
+int main(void)
+{
+	uev_t cron_watcher;
+	uev_ctx_t ctx;
+	time_t when, interval;
+
+	uev_init(&ctx);
+
+	gettimeofday(&tv, NULL);
+	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);
+}
+
+/**
+ * Local Variables:
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

tests/signal.c

@@ -21,7 +21,7 @@
  * THE SOFTWARE.
  */
 
-#define _GNU_SOURCE
+#include "check.h"
 #include <err.h>
 #include <sched.h>
 #include <signal.h>
@@ -33,8 +33,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-#include "uev.h"
-
 #define UNUSED(arg) arg __attribute__ ((unused))
 #define DO_SEGFAULT 1
 
@@ -134,7 +132,6 @@ int main(void)
 
 /**
  * Local Variables:
- *  version-control: t
  *  indent-tabs-mode: t
  *  c-file-style: "linux"
  * End:

tests/timer.c

@@ -0,0 +1,28 @@
+#include "check.h"
+#include <time.h>
+#include <sys/time.h>
+
+#define TIMEOUT 2		/* 2 sec */
+struct timeval start;
+
+static void cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+{
+	struct timeval now;
+
+	gettimeofday(&now, NULL);
+	fail_unless(now.tv_sec == start.tv_sec + TIMEOUT);
+
+	uev_exit(w->ctx);
+}
+
+int main(void)
+{
+	uev_t w;
+	uev_ctx_t ctx;
+
+	uev_init(&ctx);
+	uev_timer_init(&ctx, &w, cb, NULL, TIMEOUT * 1000, 0);
+	gettimeofday(&start, NULL);
+
+	return uev_run(&ctx, 0);
+}