Update ChangeLog and bump version for v1.0.5 release.

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

.travis.yml

@@ -0,0 +1,22 @@
+# Travis CI integration -- https://travis-ci.org/troglobit/libuev
+language: c
+compiler:
+  - gcc
+  - clang
+
+env:
+  global:
+   # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
+   #   via the "travis encrypt" command using the project repo's public key
+   - secure: "ikQcWMCLFoxq0+wMiqrNT5HRn0d4e3AxuF8VzNUNFrk6jUvHIufC/OKvr8VWPTjCaAQXZjWfdQAAARUXzJV10WZ7xpiv5qt4bt26Qih2AwMPMJeUOYrqXgQqhTPBp05iLYpo4ybICteXRI3zKKUA1wkdDC0jyu3rl+Fbveekbe0="
+
+addons:
+  coverity_scan:
+    project:
+      name: "troglobit/libuev"
+      description: "libuEv | Simple event loop for Linux"
+    notification_email: troglobit@gmail.com
+    build_command: "make"
+    branch_pattern: dev
+
+script: make

CHANGELOG

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

CHANGELOG.md

@@ -0,0 +1,110 @@
+Change Log
+==========
+
+All notable changes to the project are documented in this file.
+
+[v1.0.5]
+--------
+
+### Changes
+- Add `uev_*_start()` functions.
+- Add slightly odd `examples/signal.c` example that utilises `fork()`
+  and causes segfault in child.
+- Renamed `main.c` to `uev.c`
+- Move examples to `examples/` subdirectory
+- Simplify automatic dependency calculation
+- Add [TODO.md] for wishlist items
+- Add [CHANGELOG.md], attempt to align with http://keepachangelog.com
+- Further updates to [README.md]
+
+
+[v1.0.4] - 2015-01-24
+---------------------
+
+Minor documentation and build fixes.
+
+Release mainly targeted for [Finit development](https://github.com/troglobit/finit/).
+
+### Changes
+* `test.c` has been simplified/clarified
+* Further updates to [README.md]
+* Minor update to Makefile, change how build progress is echoed
+
+
+[v1.0.3] - 2015-01-24
+---------------------
+
+This is a very minor release, with a strong focus on documentation. 
+
+### Changes
+- [README.md], massively updated
+- API documentation, updated
+- Travis CI integration added, https://travis-ci.org/troglobit/libuev
+- Coverity Scan integration, https://scan.coverity.com/projects/3846
+- Clang scan-build support added
+
+
+[v1.0.2] - 2015-01-07
+---------------------
+
+### Fixes
+- Fix broken `make dist` target in [v1.0.1].
+
+
+[v1.0.1] - 2015-01-07
+---------------------
+
+### Changes
+- Cleanup and rewrite of [README.md] after first audit by @vonj
+- Added API and example section to [README.md]
+- New [joystick.c] example added
+- `main.c:uev_run()`: Document mysterious flags parameter
+
+
+[v1.0.0] - 2013-08-06
+---------------------
+
+First release in the new guise and API.
+
+### Changes
+- Add support for timers, using `timerfd_*()` and `epoll()` API's
+- Add support for signals using `signalfd()` API
+- Convert to use BSD `sys/queue.h` API in GLIBC instead of homebrew
+  linked list implementation
+- Massive changes to code structure, API naming
+- Reindent to use Linux KNF
+- Change library name to libuev
+- Lua support removed
+- Make sure to state the [MIT license] correctly in all files
+- Import [Niels Provos]' `bench.c`, the [libev version]
+
+
+v0.0.1 - 2012-03-17
+-------------------
+
+[Initial announcement] of [libuevent] by [Flemming Madsen] to the Lua
+users mailing list.
+
+
+[v1.0.4]: https://github.com/troglobit/libuev/compare/v1.0.4...v1.0.5
+[v1.0.4]: https://github.com/troglobit/libuev/compare/v1.0.3...v1.0.4
+[v1.0.3]: https://github.com/troglobit/libuev/compare/v1.0.2...v1.0.3
+[v1.0.2]: https://github.com/troglobit/libuev/compare/v1.0.1...v1.0.2
+[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
+[README.md]: https://github.com/troglobit/libuev/blob/master/README.md
+[CHANGLOG.md]: https://github.com/troglobit/libuev/blob/master/CHANGELOG.md
+[joystick.c]: https://github.com/troglobit/libuev/blob/master/joystick.c
+[Niels Provos]: http://en.wikipedia.org/wiki/Niels_Provos
+[MIT license]: http://en.wikipedia.org/wiki/MIT_License
+[libev version]: http://libev.schmorp.de/bench.c
+[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:
+  -->

LICENSE

@@ -1,24 +1,20 @@
-Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
-Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
 
-Permission is hereby granted, free of charge, to any person obtaining
+Permission is hereby granted, free of charge, to any person obtaining a copy
-a copy of this software and associated documentation files (the
+of this software and associated documentation files (the "Software"), to deal
-"Software"), to deal in the Software without restriction, including
+in the Software without restriction, including without limitation the rights
-without limitation the rights to use, copy, modify, merge, publish,
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-distribute, sublicense, and/or sell copies of the Software, and to
+copies of the Software, and to permit persons to whom the Software is
-permit persons to whom the Software is furnished to do so, subject to
+furnished to do so, subject to the following conditions:
-the following conditions:
 
-The above copyright notice and this permission notice shall be
+The above copyright notice and this permission notice shall be included in
-included in all copies or substantial portions of the Software.
+all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE.
-
-For an explanation and background of the MIT license, see the Wikipedia
-article https://en.wikipedia.org/wiki/MIT_License

Makefile

@@ -1,7 +1,7 @@
-# -*-Makefile-*- for libuEv
+# libuEv main build file
 #
-# Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+# Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
-# Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+# Copyright (c) 2013-2015  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
@@ -22,10 +22,10 @@
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
-.PHONY: all test clean
+.PHONY: all test clean joystick test examples
 
 #VERSION    = $(shell git tag -l | tail -1)
-VERSION    ?= 1.0.2
+VERSION    ?= 1.0.5
 NAME        = libuev
 PKG         = $(NAME)-$(VERSION)
 ARCHIVE     = $(PKG).tar.xz
@@ -33,42 +33,36 @@ ARCHIVE     = $(PKG).tar.xz
 CC         ?= $(CROSS)gcc
 AR         ?= $(CROSS)ar
 STRIP      ?= $(CROSS)strip
-CHECK      ?= sparse
 CFLAGS     += -fPIC -Os
 CPPFLAGS   += -W -Wall -Werror
 ARFLAGS     = crus
-CHECK_FLAGS = -Wcast-to-as -Wdefault-bitfield-sign -Wdo-while -Wparen-string        \
+JUNK        = *~ *.bak *.map .*.d DEADJOE *.gdb *.elf core core.* *.html
-	      -Wptr-subtraction-blows -Wreturn-void -Wshadow -Wtypesign -Wbitwise   \
-	      -std=gnu99  -D__x86_64__ -D__LP64__ -I/usr/include/x86_64-linux-gnu
-JUNK        = *~ *.bak *.map .*.d DEADJOE *.gdb *.elf core core.*
 
+MAKEFLAGS   = --no-print-directory
+
+ROOTDIR    ?= $(shell pwd)
 LIBNAME     = $(NAME)
 prefix     ?= /usr/local
 libdir     ?= $(prefix)/lib
 datadir    ?= $(prefix)/share/doc/$(LIBNAME)
 incdir     ?= $(prefix)/include
-DISTFILES   = README LICENSE test.c
+DISTFILES   = README CHANGELOG TODO LICENSE test.c
 HEADER      = uev.h
 
-OBJS       := main.o io.o timer.o signal.o
+OBJS       := uev.o io.o timer.o signal.o
 SRCS       := $(OBJS:.o=.c)
-DEPS       := $(addprefix .,$(SRCS:.c=.d))
+DEPS       := $(SRCS:.c=.d)
 VER         = 1
 SOLIB       = $(LIBNAME).so.$(VER)
 SYMLIB      = $(LIBNAME).so
 STATICLIB   = $(LIBNAME).a
 TARGET      = $(STATICLIB) $(SOLIB)
 
-# Pattern rules
+export STATICLIB JUNK ROOTDIR CFLAGS CPPFLAGS
-.c.o:
-	@printf "  CC      $@\n"
-	@$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $@ $<
 
-# Smart autodependecy generation via GCC -M.
+# This magic trick looks like a comment, but works on BSD PMake
-.%.d: %.c
+#include <rules.mk>
-	@$(SHELL) -ec "$(CC) -MM $(CFLAGS) $(CPPFLAGS) $< 2>/dev/null \
+include rules.mk
-		| sed 's,.*: ,$*.o $@ : ,g' > $@; \
-                [ -s $@ ] || rm -f $@"
 
 # Build rules
 all: $(TARGET)
@@ -103,25 +97,26 @@ strip: $(TARGET)
 	@$(STRIP) --strip-unneeded $(TARGET)
 	@size $(TARGET)
 
-test: Makefile test.o $(STATICLIB)
-	@printf "  TEST    %s\n" $(STATICLIB)
-	@$(CC) $(CPPFLAGS) -g -o test test.c $(STATICLIB) && ./test
-
 bench: Makefile bench.o $(STATICLIB)
 	@printf "  BENCH   %s\n" $(STATICLIB)
 	@$(CC) $(CPPFLAGS) -g -o bench bench.c $(STATICLIB) && ./bench
 
-joystick: Makefile joystick.o $(STATICLIB)
+examples: all
-	@printf "  JOTST   %s\n" $(STATICLIB)
+	@$(MAKE) -C examples
-	@$(CC) $(CPPFLAGS) -g -o joystick joystick.c $(STATICLIB) && ./joystick
 
-check:
+test joystick:
-	@$(CHECK) $(CHECK_FLAGS) $(CPPFLAGS) $(SRCS) bench.c
+	@$(MAKE) -C examples $@
+
+# Runs Clang scan-build on the whole tree
+check: clean
+	@scan-build $(MAKE) all
 
 clean:
-	-@$(RM) $(TARGET) *.o test
+	-@$(MAKE) -C examples $@
+	-@$(RM) $(TARGET) *.o test joystick bench
 
 distclean: clean
+	-@$(MAKE) -C examples $@
 	-@$(RM) $(DEPS) $(JUNK)
 
 dist:
@@ -130,9 +125,4 @@ dist:
 	@(cd ..; md5sum $(ARCHIVE) | tee $(ARCHIVE).md5)
 
 # Include automatically generated rules
-ifneq ($(MAKECMDGOALS),clean)
-ifneq ($(MAKECMDGOALS),distclean)
 -include $(DEPS)
-endif
-endif
-

README.md

@@ -1,5 +1,20 @@
 libuEv | Simple event loop for Linux
 ====================================
+[![Travis Status]][Travis] [![Coverity Status]][Coverity Scan]
+
+
+Table of Contents
+-----------------
+
+* [Introduction](#introduction)
+* [API](#api)
+* [Example](#example)
+* [Build & Install](#build--install)
+* [Origin & References](#origin--references)
+
+
+Introduction
+------------
 
 > “Why an event loop, why not use threads?”
 
@@ -29,24 +44,25 @@ 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
+[libuEv] is a simple event loop in the style of the more established
-[libevent](http://libevent.org/),
+[libevent][1], [libev][2] and the venerable [Xt(3)][3] event loop.  The
-[libev](http://software.schmorp.de/pkg/libev.html) and the venerable
+*u* (micro) in the name refers to both the small feature set and the
-[Xt(3)](http://unix.com/man-page/All/3x/XtDispatchEvent) event loop.
+small size overhead impact of the library.  The primary target of
-The *u* (micro) in the name refers to both the small feature set and the
+[libuEv] is a modern Linux system.
-small size overhead impact of the library.  The primary target of libuEv
-is a modern Linux system.
 
-Experienced developers may appreciate that libuEv is built on top of
+Experienced developers may appreciate that [libuEv] is built on top of
-modern Linux APIs: epoll, timerfd and signalfd.
+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]
 
 
 API
 ---
 
-Here is the interface to libuEv.  It handles three different types of
+Here is the interface to [libuEv].  It handles three different types of
-events: I/O (files, sockets, message queues, etc.), timers, and
+events: I/O (files, sockets, message queues, etc.), timers, and signals.
-signals.
 
 ```C
 /* Callback example, arg is passed from watcher's *_init()
@@ -80,14 +96,14 @@ To be able to set up callbacks to events the developer first need to
 create an *event context*, achieved by calling `uev_init()` with a
 pointer to a local `uev_ctx_t` variable.
 
-Events are monitored by watchers in libuEV.  A watcher is nothing more
+Events are monitored by watchers in [libuEv].  A watcher is nothing more
 than a mechnism that polls a file descriptor.  Register a watcher with a
 callback to the event context by passing the `uev_ctx_t` variable, along
 with an `uev_t` variable to each event's `_init()` function.
 
 When all watchers are registered call the event loop with `uev_run()`
 and the argument to the event context.  The `flags` parameter is slightly
-mysterious, but can be used to integrate libuEv into another event loop.
+mysterious, but can be used to integrate [libuEv] into another event loop.
 With `flags` set to `UEV_ONCE` the event loop returns after having
 served the first event.  If `flags` is set to `UEV_ONCE | UEV_NONBLOCK`
 the event loop returns immediately if no event is available.
@@ -100,15 +116,24 @@ Summary:
 3. Enter the event loop with `uev_run()`
 4. Leave the event loop with `uev_exit()`, possibly from a callback
 
-**Note:** Make sure to use non-blocking stream I/O!  Most hard to find
+**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:** 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 :)
+
 
 Example
 -------
 
-Here follows a very brief example to illustrate how one can use libuEv
+Here follows a very brief example to illustrate how one can use [libuEv]
 to act upon joystick input.
 
 ```C
@@ -165,15 +190,14 @@ int main(void)
 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 `make joystick` from this directory.
+`Makefile` with <kbd>make joystick</kbd> from this directory.
 
-For a more complete, and perhaps more relevant example, see the code for
+More complete and relevant example uses of [libuEv] is the TFTP/FTP
-the TFTP/FTP server [uftpd](https://github.com/troglobit/uftpd).  It
+server [uftpd][5], and the Linux `/sbin/init` replacement [finit][6].
-uses libuEv as a GIT submodule.
+Both use [libuEv] as a GIT submodule.
 
-Also, see the `bench.c` program (`make bench` from within the library)
+Also, see the `bench.c` program (<kbd>make bench</kbd> from within the
-for [reference benchmarks](http://libev.schmorp.de/bench.html) against
+library) for [reference benchmarks][7] against libevent and libev.
-libevent and libev.
 
 
 Build & Install
@@ -184,11 +208,11 @@ use GCC and GNU Make specific extensions here and there.  This is not on
 purpose and patches to correct this are most welcome.  Particularly
 patches to support *BSD and its kqueue interface.
 
-* `make all`: The library
+* <kbd>make all</kbd>: The library
-* `make test`: Test and showcase
+* <kbd>make test</kbd>: Test and showcase
-* `make install`: Honors `$prefix` and `$DESTDIR` environment variables
+* <kbd>make install</kbd>: Honors `$prefix` and `$DESTDIR` environment variables
 
-Size of libuEv:
+Size of [libuEv]:
 
     $ make strip
     CC      main.o
@@ -210,22 +234,29 @@ Size of libuEv:
 Origin & References
 --------------------
 
-LibuEv (this library) was originally based on
+[libuEv] was originally based on [LibUEvent][8] by [Flemming Madsen] but
-[LibUEvent](http://code.google.com/p/libuevent/) by
+has been completely rewritten with a much clearer API.  Now more similar
-[Flemming Madsen](http://www.madsensoft.dk/) but has been completely
+to the famous [libev][2] by [Mark Lehmann].  Another small event library
-rewritten with a much clearer API.  Now more similar to the famous
+used for inspiration is the very small [Picoev][9] by [Oku Kazuho].
-[libev](http://software.schmorp.de/pkg/libev.html) by Mark Lehmann.
-Another small event library used for inspiration is the very small
-[Picoev](https://github.com/kazuho/picoev) by
-[Oku Kazuho](https://github.com/kazuho).
 
-* http://code.google.com/p/libuevent/
+[1]: http://libevent.org
-* http://software.schmorp.de/pkg/libev.html
+[2]: http://software.schmorp.de/pkg/libev.html
-* http://libev.schmorp.de/bench.html
+[3]: http://unix.com/man-page/All/3x/XtDispatchEvent
-* http://libevent.org/
+[4]: http://lwn.net/Articles/415684/
-* http://developer.cybozu.co.jp/archives/kazuho/2009/08/picoev-a-tiny-e.html
+[5]: https://github.com/troglobit/uftpd
-* http://coderepos.org/share/browser/lang/c/picoev/
+[6]: https://github.com/troglobit/finit
-
+[7]: http://libev.schmorp.de/bench.html
-LibuEv is maintained by [Joachim Nilsson](mailto:troglobit@gmail.com) at
+[8]: http://code.google.com/p/libuevent/
-[GitHub](https://github.com/troglobit/libuev)
+[9]: https://github.com/kazuho/picoev
+[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
+[LibuEV]:          https://github.com/troglobit/libuev
+[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
 
+[libuEv] is developed and maintained by [Joachim Nilsson]

TODO

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

TODO.md

@@ -0,0 +1,5 @@
+LibuEv TODO
+===========
+
+* Make port to *BSD kqueue API, http://en.wikipedia.org/wiki/Kqueue
+

examples/Makefile

@@ -0,0 +1,54 @@
+# libuEv examples
+#
+# Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
+# Copyright (c) 2013-2015  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.
+#
+.PHONY: all clean
+
+TARGET      = signal test joystick
+OBJS       := $(addsuffix .o, $(TARGET))
+SRCS       := $(OBJS:.o=.c)
+DEPS       := $(SRCS:.c=.d)
+CPPFLAGS   += -I../
+LDFLAGS    := -L../
+LDLIBS     := ../$(STATICLIB)
+
+# This magic trick looks like a comment, but works on BSD PMake
+#include <../rules.mk>
+include ../rules.mk
+
+all: $(TARGET)
+
+signal: signal.o
+
+test: test.o
+
+joystick: joystick.o
+
+clean:
+	-@$(RM) $(TARGET) *.o
+
+distclean: clean
+	-@$(RM) $(DEPS) $(JUNK)
+
+# Include automatically generated rules
+-include $(DEPS)

examples/joystick.c

@@ -1,6 +1,6 @@
 /* Simple example of how to use libuEv with Linux joystick API
  *
- * Copyright (c) 2014  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2014-2015  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

examples/signal.c

@@ -0,0 +1,136 @@
+/* Multiple signals, segfault and fork() to test sub-processes.
+ *
+ * Copyright (c) 2015  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.
+ */
+
+#define _GNU_SOURCE
+#include <err.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "uev.h"
+
+#define UNUSED(arg) arg __attribute__ ((unused))
+#define DO_SEGFAULT 1
+
+typedef struct {
+	int magic;
+	void *ptr;
+} arg_t;
+
+/* Stack is not shared between parent and child, only the heap. */
+static arg_t arg = {
+	.magic = 1337,
+	.ptr = NULL
+};
+
+static int callback(arg_t *arg, int event, void *foo)
+{
+	arg_t *event_arg  = (arg_t *)foo;
+
+	printf("child: got magic %d and ptr %p, with event %d and event arg %p\n",
+	       arg->magic, arg->ptr, event, event_arg);
+
+	arg->magic = 7331;
+	arg->ptr   = &event_arg;
+
+	/* Cause segfault! */
+#if DO_SEGFAULT == 1
+	event_arg->ptr = arg->ptr;
+	printf("child: segfaulting failed!\n");
+#endif
+
+        return 42;
+}
+
+static void sigsegv_cb(uev_ctx_t *UNUSED(ctx), uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+{
+	warnx("PID %d caused segfault.", getpid());
+	exit(-1);
+}
+
+static void sigchld_cb(uev_ctx_t *UNUSED(ctx), uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+{
+        pid_t pid = waitpid(-1, NULL, WNOHANG);
+
+        if (-1 != pid)
+                warnx("PID %d exited, bye.", pid);
+}
+
+static void work_cb(uev_ctx_t *UNUSED(ctx), uev_t *UNUSED(w), void *arg, int UNUSED(events))
+{
+	int    status = 0;
+        pid_t  pid;
+
+        pid = fork();
+        if (-1 == pid)
+                err(1, "fork");
+	if (!pid) {
+		status = callback(arg, 6137, NULL);
+                exit(status);
+        }
+
+        if (waitpid(pid, &status, 0) == -1)
+                err(1, "waitpid");
+
+	if (WIFEXITED(status))
+		printf("Child exited normally => %d\n", WEXITSTATUS(status));
+	else if (WCOREDUMP(status))
+		printf("Child crashed!\n");
+}
+
+static void exit_cb(uev_ctx_t *ctx, uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+{
+        printf("Process deadline reached, exiting!\n");
+	uev_exit(ctx);
+}
+
+int main(void)
+{
+	uev_t sigsegv_watcher, sigchld_watcher, timeout_watcher, deadline_watcher;
+	uev_ctx_t ctx;
+
+	/* Initialize libuEv */
+	uev_init(&ctx);
+	uev_signal_init(&ctx, &sigsegv_watcher, sigsegv_cb, NULL, SIGSEGV);
+	uev_signal_init(&ctx, &sigchld_watcher, sigchld_cb, NULL, SIGCHLD);
+	uev_timer_init(&ctx, &timeout_watcher, work_cb, &arg, 400, 0);
+	uev_timer_init(&ctx, &deadline_watcher, exit_cb, NULL, 1000, 0);
+
+	/* Start event loop */
+	return uev_run(&ctx, 0);
+}
+
+/**
+ * Local Variables:
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

examples/test.c

@@ -1,7 +1,7 @@
 /* Test libuEv event library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  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
@@ -42,17 +42,17 @@ static uev_t *watchdog;
 
 static void lifetime_cb(uev_ctx_t *ctx, uev_t UNUSED(*w), void *arg, int UNUSED(events))
 {
-	fprintf(stderr, "\nLifetime exceeded %p\n", arg);
+	fprintf(stderr, "\nLifetime exceeded, program completed successfully! (arg:%p)\n", arg);
 	uev_exit(ctx);
 }
 
 /* The pipe watchdog, if it triggers we haven't received data in time. */
-static void timeout_cb(uev_ctx_t *ctx, uev_t *w, void *arg, int UNUSED(events))
+static void timeout_cb(uev_ctx_t *ctx, uev_t *UNUSED(w), void *arg, int UNUSED(events))
 {
 	watchdog = NULL;
 	fprintf(stderr, "\nTimeout exceeded %p\n", arg);
 
-	uev_timer_stop(w);
+	// uev_timer_stop(w); <-- No need to stop timers with period=0 :)
 	uev_exit(ctx);
 }
 
@@ -111,7 +111,7 @@ int main(void)
 	if (pipe(fd) < 0)
 		return 1;
 
-	/*  */
+	/* Initialize libuEv */
 	uev_init(&ctx);
 
 	/* Signal watchers, Ctrl-C => SIGINT, Ctrl-\ => SIGQUIT */
@@ -141,7 +141,7 @@ int main(void)
 	fprintf(stderr, "Period is %d must be 10: %s\n", period, 10 == period ? "OK" : "ERROR!");
 	if (10 != period)
 		return 1;
-                
+
 	return 0;
 }
 

io.c

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  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
@@ -23,6 +23,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#include <errno.h>
+
 #include "uev.h"
 
 
@@ -39,12 +41,14 @@
  */
 int uev_io_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events)
 {
+	if (fd < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
 	if (uev_watcher_init(ctx, w, UEV_IO_TYPE, cb, arg, fd, events))
 		return -1;
 
-	if (fd < 0)
-		return 0;
-
 	return uev_watcher_start(w);
 }
 
@@ -67,15 +71,28 @@ int uev_io_set(uev_t *w, int fd, int events)
 	return uev_io_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, fd, events);
 }
 
+/**
+ * Start an I/O watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_io_start(uev_t *w)
+{
+	return uev_io_set(w, w->fd, w->events);
+}
+
 /**
  * Stop an I/O watcher
- * @param w  Pointer to an uev_t watcher
+ * @param w  Watcher to stop
  *
  * @return POSIX OK(0) or non-zero with @param errno set on error.
  */
 int uev_io_stop(uev_t *w)
 {
-	return uev_watcher_stop(w);
+	int status = uev_watcher_stop(w);
+
+	return status;
 }
 
 /**

queue.h

@@ -0,0 +1,648 @@
+/*	$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_ */

rules.mk

@@ -0,0 +1,9 @@
+# Pretty printing and GCC -M for auto dep files
+%.o: %.c
+	@printf "  CC      $(subst $(ROOTDIR)/,,$(shell pwd)/)$@\n"
+	@$(CC) $(CFLAGS) $(CPPFLAGS) -c -MMD -MP -o $@ $<
+
+%: %.o
+	@printf "  LINK    $(subst $(ROOTDIR)/,,$(shell pwd)/)$@\n"
+	@$(CC) $(CFLAGS) $(LDFLAGS) -Wl,-Map,$@.map -o $@ $^ $(LDLIBS$(LDLIBS-$(@)))
+

signal.c

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  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
@@ -46,6 +46,12 @@ int uev_signal_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo
 	int fd;
 	sigset_t mask;
 
+	if (!w || !ctx) {
+		errno = EINVAL;
+		return -1;
+	}
+	w->fd = -1;
+
 	sigemptyset(&mask);
 	fd = signalfd(-1, &mask, SFD_NONBLOCK);
 	if (fd < 0)
@@ -81,6 +87,9 @@ int uev_signal_set(uev_t *w, int signo)
 		return -1;
 	}
 
+	/* Remember for callbacks and start/stop */
+	w->signo = signo;
+
 	/* Handle stopped signal watchers */
 	if (w->fd < 0) {
 		/* Remove from internal list */
@@ -104,6 +113,26 @@ int uev_signal_set(uev_t *w, int signo)
 	return uev_watcher_start(w);
 }
 
+
+/**
+ * Start a stopped signal watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_signal_start(uev_t *w)
+{
+	if (!w) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (-1 != w->fd)
+		uev_signal_stop(w);
+
+	return uev_signal_set(w, w->signo);
+}
+
 /**
  * Stop a signal watcher
  * @param w  Watcher to stop

timer.c

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  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
@@ -130,6 +130,25 @@ int uev_timer_set(uev_t *w, int timeout, int period)
 	return 0;
 }
 
+/**
+ * Start a stopped timer watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_timer_start(uev_t *w)
+{
+	if (!w) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (-1 != w->fd)
+		uev_watcher_stop(w);
+
+	return uev_timer_set(w, w->timeout, w->period);
+}
+
 /**
  * Stop and unregister a timer watcher
  * @param w  Watcher to stop

uev.c

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  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
@@ -231,8 +231,6 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 				if (read(w->fd, &fdsi, sz) != sz)
 					goto exit;
-
-				w->signo = fdsi.ssi_signo;
 			}
 
 			if (w->cb)

uev.h

@@ -1,7 +1,7 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  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
@@ -28,7 +28,8 @@
 
 #include <stdio.h>
 #include <sys/epoll.h>
-#include <sys/queue.h>
+
+#include "queue.h"	       /* OpenBSD queue.h > old GLIBC version */
 
 /* Max. number of simulateneous events */
 #define UEV_MAX_EVENTS  10
@@ -97,14 +98,17 @@ int uev_run            (uev_ctx_t *ctx, int flags);
 
 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);
 
 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);
+int uev_timer_start    (uev_t *w);
 int uev_timer_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);
 int uev_signal_stop    (uev_t *w);
 
 #endif /* LIBUEV_UEV_H_ */