Shorten README title heading.

Signed-off-by: Joachim Nilsson <troglobit@gmail.com>
Update README for release.
2026-10-14 10:19:31 +00:00 · 2015-07-12 12:50:01 +02:00 · 2015-07-12 12:44:39 +02:00 · 2015-07-12 12:43:57 +02:00 · 2015-07-10 19:27:02 +02:00 · 2015-07-10 19:06:17 +02:00
22 changed files with 2236 additions and 214 deletions
@@ -0,0 +1,5 @@
+*.d
+*.o
+*.so
+*.so.*
+*.a
@@ -0,0 +1,25 @@
+Much of the code in libite (-lite) is written by Claudio Matsuoka for Finit
+and released under the MIT/X11 license.  Joachim Nilsson later improved on
+the Finit code base and included pieces of software released under the ISC
+and BSD licenses.  See each respective file for license details.
+
+Copyright (c) 2008-2010  Claudio Matsuoka <cmatsuoka@gmail.com>
+Copyright (c) 2008-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.
@@ -1,6 +1,6 @@
-# Finit libite -- Light-weight utility functions and C-library extensions
+# libite -- Light-weight utility functions and C-library extensions
 # 
-# Copyright (c) 2008-2012  Joachim Nilsson <troglobit@gmail.com>
+# Copyright (c) 2008-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
@@ -19,61 +19,127 @@
 # 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.
-
-.EXPORT_ALL_VARIABLES:
 .PHONY: all install clean

-include  ../common.mk
+# Figure out root of library, unless used as submodule
+ROOTDIR    ?= $(shell pwd)
+
+#VERSION    = $(shell git tag -l | tail -1)
+VERSION    ?= 1.0.0
+NAME        = libite
+PKG         = $(NAME)-$(VERSION)
+ARCHIVE     = $(PKG).tar.xz
+
+CC         ?= $(CROSS)gcc
+AR         ?= $(CROSS)ar
+STRIP      ?= $(CROSS)strip
+INSTALL    := install --backup=off
+STRIPINST  := $(INSTALL) -s --strip-program=$(CROSS)strip -m 0755

 CFLAGS     += -fPIC
+CFLAGS     += -Os
+CPPFLAGS   += -D_GNU_SOURCE
+CPPFLAGS   += -W -Wall
+ARFLAGS     = crus
+
+# Default to silent build, use V=1 to get verbose mode.
+ifeq ($V,1)
+Q           =
+PRINT       = @true
+MAKEFLAGS   =
+else
+Q           = @
+PRINT       = @printf
+MAKEFLAGS   = --no-print-directory --silent
+endif
+
+DISTFILES   = README LICENSE
 HEADERS     = lite.h
-OBJS       := copyfile.o dir.o fexist.o fisdir.o fmode.o rsync.o
-DEPS       := $(addprefix ., $(OBJS:.o=.d))
+OBJS       := chomp.o copyfile.o dir.o fexist.o fisdir.o fmode.o fsendfile.o
+OBJS       += ifconfig.o makepath.o pidfile.o pidfilefn.o rsync.o
+OBJS       += strlcpy.o strlcat.o strtonum.o tempfile.o
+DEPS       := $(OBJS:.o=.d)
+JUNK        = *~ *.bak *.map .*.d *.d DEADJOE semantic.cache *.gdb *.elf core core.*

-VER         = 0
-LIBNAME     = libite
-TARGET      = $(LIBNAME).so
-VERLIB      = $(TARGET).$(VER)
+VER         = 1
+LIBNAME     = $(NAME)
+SOLIB       = $(LIBNAME).so.$(VER)
+SYMLIB      = $(LIBNAME).so
 STATICLIB   = $(LIBNAME).a
+TARGET      = $(STATICLIB) $(SOLIB)

-CHECK_FLAGS = $(CFLAGS) $(CPPFLAGS)
+# Default install paths
+prefix     ?= /usr/local
+libdir     ?= $(prefix)/lib
+datadir    ?= $(prefix)/share/doc/$(LIBNAME)
+incdir     ?= $(prefix)/include

+# This magic trick looks like a comment, but works on BSD PMake
+#include <rules.mk>
+include rules.mk
+
+# Build rules
 all: $(TARGET)

 $(OBJS): Makefile

-$(TARGET): $(OBJS)
-	@printf "  LINK    %s\n" $@
-#	@$(AR) $(ARFLAGS) $(STATICLIB) $(OBJS)
-	@$(CC) $(LDFLAGS) -shared $(OBJS) -lrt -lcrypt -Wl,-soname,$@ -o $@
-	@ln -sf $@ $(VERLIB)
+$(SOLIB): Makefile $(OBJS)
+	$(PRINT) "  LINK    %s\n" $@
+	$(Q)$(CC) $(LDFLAGS) -shared -Wl,-soname,$@ -o $@ $(OBJS)
+
+$(STATICLIB): Makefile $(OBJS)
+	$(Q)$(PRINT) "  ARCHIVE $@\n"
+	$(Q)$(AR) $(ARFLAGS) $@ $(OBJS)

 install-exec: all
-	@install -d $(DESTDIR)$(libdir)
-	@echo "  INSTALL $(DESTDIR)$(libdir)/$(TARGET)"
-	@$(STRIPINST) $(TARGET) $(DESTDIR)$(libdir)/$(TARGET)
-	@ln -sf $(TARGET) $(DESTDIR)$(libdir)/$(VERLIB)
+	$(PRINT) "  INSTALL $(DESTDIR)$(libdir)/$(SOLIB)\n"
+	$(Q)install -d $(DESTDIR)$(libdir)
+	$(Q)$(STRIPINST) $(SOLIB) $(DESTDIR)$(libdir)/$(SOLIB)
+	$(Q)ln -sf $(SOLIB) $(DESTDIR)$(libdir)/$(SYMLIB)

 install-dev:
-	@for file in $(HEADERS); do	                                \
-		printf "  INSTALL $(DESTDIR)$(incdir)/$$file\n";	\
-		$(INSTALL) -m 0644 $$file $(DESTDIR)$(incdir)/$$file;	\
+	$(Q)install -d $(DESTDIR)$(incdir)/$(LIBNAME)
+	$(Q)for file in $(HEADERS); do	                                		\
+		printf "  INSTALL $(DESTDIR)$(incdir)/$(LIBNAME)/$$file\n";		\
+		$(INSTALL) -m 0644 $$file $(DESTDIR)$(incdir)/$(LIBNAME)/$$file;	\
+	done
+	$(PRINT) "  INSTALL $(DESTDIR)$(libdir)/$(STATICLIB)\n"
+	$(Q)install -d $(DESTDIR)$(libdir)
+	$(Q)$(INSTALL) $(STATICLIB) $(DESTDIR)$(libdir)/$(STATICLIB)
+	$(Q)install -d $(DESTDIR)$(datadir)
+	$(Q)for file in $(DISTFILES); do					\
+		printf "  INSTALL $(DESTDIR)$(datadir)/$$file\n";	\
+		install -m 0644 $$file $(DESTDIR)$(datadir)/$$file;	\
 	done

-install: install-dev install-exec
+install: install-exec install-dev

 uninstall:
-	-@$(RM) $(DESTDIR)$(libdir)/$(VERLIB)
-	-@$(RM) $(DESTDIR)$(libdir)/$(TARGET)
+	-$(Q)$(RM) -r $(DESTDIR)$(datadir)
+	-$(Q)$(RM) -r $(DESTDIR)$(incdir)/$(LIBNAME)
+	-$(Q)$(RM) $(DESTDIR)$(libdir)/$(SOLIB)
+	-$(Q)$(RM) $(DESTDIR)$(libdir)/$(SYMLIB)
+	-$(Q)$(RM) $(DESTDIR)$(libdir)/$(STATICLIB)

-clean: uninstall
-	-@$(RM) $(OBJS) $(DEPS) $(TARGET) $(VERLIB) $(STATICLIB)
+strip: $(TARGET)
+	$(Q)$(PRINT) "  STRIP   %s\n" $(TARGET)
+	$(Q)$(STRIP) --strip-unneeded $(TARGET)
+	$(Q)size $(TARGET)

-distclean: clean
-	-@$(RM) $(JUNK) unittest *.o .*.d *.unittest
+# Runs Clang scan-build on the whole tree
+check: clean
+	$(Q)scan-build $(MAKE) all

-ifneq ($(MAKECMDGOALS),clean)
-ifneq ($(MAKECMDGOALS),distclean)
+clean:
+	-$(Q)$(RM) $(OBJS) $(DEPS) $(TARGET) $(SOLIB) $(STATICLIB)
+
+distclean:
+	-$(Q)$(RM) $(JUNK) unittest *.o *.a *.so* *.unittest
+
+dist:
+	$(Q)echo "Building .xz tarball of $(PKG) in parent dir..."
+	git archive --format=tar --prefix=$(PKG)/ v$(VERSION) | xz >../$(ARCHIVE)
+	$(Q)(cd ..; md5sum $(ARCHIVE) | tee $(ARCHIVE).md5)
+
+# Include automatically generated rules
 -include $(DEPS)
-endif
-endif
@@ -0,0 +1 @@
+README.md
@@ -0,0 +1,209 @@
+-lite | Frog DNA, basically
+===========================
+
+Libite is a lightweight library of *frog DNA*.  It can be used to fill
+the gaps in any dinosaur project.  It holds useful functions and macros
+developed by both [Finit][1] and the [OpenBSD][2] project.  Most notably
+the string functions: [strlcpy(3)][3], [strlcat(3)][3] and the highly
+useful *BSD [sys/queue.h][4] API.
+
+Libite aims to fill in the gaps missing in GLIBC/EGLIBC.  (It does not
+aimo to become another [GLIB][5] though.)  One such gap in GLIBC is the
+missing `_SAFE` macros in `sys/queue.h` &mdash; highly recommended when
+traversing lists to delete/free nodes.
+
+The code is open sourced under a mix of the [MIT/X11 license][MIT], the
+[ISC license][ISC] used by OpenBSD, and [BSD licenses][BSD], all of them
+are extremely liberal and can be used freely in proprietary software if
+needed.
+
+For an introduction to why Libite happened, and how you can use it, see
+[this blog post][6].
+
+
+Helper Macros
+-------------
+
+- `atonum(str)`
+
+  Convert string to natural number, works for 32-bit non-negative
+  integers.  Returns -1 on error.  (Uses `strtonum()` internally.)
+
+- `blkdev(dev)`
+
+Create block device
+
+- `chardev(dev)`
+
+Create character device
+
+- `erase(path)`
+
+  Erase file/directory with `remove()`.  Errors on stderr
+
+- `makedir(path)`
+
+  Create directory, like `mkdir()`.  Errors on stderr
+
+- `makefifo(path)`
+
+  Create a FIFO, like `mkfifo()`.  Errors on stderr
+
+- `touch(path)`
+
+  Create a file, or update mtime.  Errors on stderr
+
+- `S_ISEXEC(mode_t m)`
+
+Mysteriously missing from GLIBC
+
+- `UNUSED(var)`
+
+Shorter and more readable version of `var __attribute__ ((unused))`
+
+
+Generic Functions
+-----------------
+
+- `chomp(str)`
+
+  Perl like chomp function, chop off last char if newline.
+
+- `copyfile(src, dst, len, symlink)`
+
+  Like the shell `cp(1)` and `dd(1),` can also create symlinks.
+
+- `dir(dir, ext, filter, list, strip)`
+
+  Wrapper for `scandir()` with optional filter.  Returns a list of
+  names: files and directories that must be freed after use.  See
+  the unit test at the bottom for an example.
+
+- `fcopyfile(src, dst)`
+
+  Like `copyfile()` but uses already open `FILE *` pointers.  Copies
+  from current file positions to current file positions until EOF.
+
+- `fexist(file)`
+
+  Check for the existance of a file, returns True(1) or False(0).
+
+- `fisdir(path)`
+
+  Check for the existance of a directory, returns True(1) or False(0).
+
+- `fmode(file)`
+
+  Returns the `mode_t` bits of a file or directory.
+
+- `fsendfile(src, dst, len)`
+
+  Copy data between file streams, very similar to `fcopyfile()`, but
+  `dst` is allowed to be `NULL` to be able to read and discard `len`
+  bytes from `src`.
+
+- `ifconfig(ifname, addr, mask, up)`
+
+  Basic ifconfig like operations on an interface.  Only supports IPv4
+  adresses.  Note that mask is not CIDR notation.
+
+- `makepath(dir)`
+
+  Create all components of the specified directory.
+
+- `mkpath(dir, mode)`
+
+  Like `makepath()`, but also takes a `mode_t` permission mode argument.
+
+- `movefile(src, dst)`
+
+  Like `copyfile()`, but renames `src` to `dst`, or recreates symlink
+  with the `dst` name.  On successful operation the source is removed
+  and the function returns POSIX OK (0).
+
+- `pidfile(basename)`
+
+  Write a daemon pid file.  Creates a pidfile in `_PATH_VARRUN` using
+  either `basename` or, if `basename` is `NULL`, `__progname`.  The
+  file name has the form `/var/run/basename.pid`.
+
+  Use this function to create a pid file for your daemon when it is
+  ready to receive signals.  A client application may poll for the
+  existence of this file, so make sure to have your signal handlers
+  properly setup before calling this function.
+  
+  The pidfile is removed when the program exits, using an `atexit()`
+  handler.  However, depending on how the program terminates the file
+  may still exist even though the program is no longer running.  This
+  is only a problem for clients.
+
+  See below for link to OpenBSD man page.
+
+- `pidfile_read(pidfile)`
+
+  Read PID from pid file created by `pidfile()`.
+
+- `pidfile_signal(pidfile, signal)`
+
+  Send signal to PID found in pid file created by `pidfile()`.
+
+- `rsync(src, dst, delete, *filter())`
+
+  Very simple `rsync()` to copy files files and directories
+  recursively.
+
+- `tempfile()`
+
+  Secure replacement for `tmpfile()`.  Creates an invisible temporary
+  file in `/tmp` that is removed when the returned `FILE` pointer is
+  closed.  **Note:** Requires Linux v3.11, or later.
+
+
+OpenBSD Functions
+-----------------
+
+The following are the popular OpenBSD string functions.
+
+- `pidfile(basename)`
+
+  http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man3/pidfile.3
+
+- `strlcpy(dst, src, len)`
+
+  http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man3/strlcpy.3
+
+- `strlcat(dst, src, len)`
+
+  http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man3/strlcat.3
+
+- `strtonum()`
+
+  http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man3/strtonum.3
+
+- `sys/queue.h` API
+
+  http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man3/LIST_EMPTY.3
+
+
+TODO
+----
+
+- Improve documentation, possibly use kdoc or gdoc2 to generate docs from API.
+- Continuously, update OpenBSD functions/macros.
+
+[1]: https://github.com/troglobit/finit
+[2]: http://www.openbsd.org/
+[3]: http://www.openbsd.org/cgi-bin/man.cgi?query=strlcpy
+[4]: http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man3/LIST_EMPTY.3
+[5]: https://developer.gnome.org/glib/
+[6]: http://troglobit.com/blog/2015/07/02/howto-using-lite-with-a-git-based-application/
+[MIT]: https://en.wikipedia.org/wiki/MIT_License
+[ISC]: https://en.wikipedia.org/wiki/ISC_license
+[BSD]: https://en.wikipedia.org/wiki/BSD_licenses
+
+
+<!--
+  -- Local Variables:
+  -- mode: markdown
+  -- End:
+  -->
@@ -0,0 +1,64 @@
+/* Perl inspired chomp() implementation.
+ *
+ * Copyright (c) 2014-2015  Joachim Nilsson <troglobit@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <errno.h>
+#include <string.h>
+
+/**
+ * chomp - Perl like chomp function, chop off last char(s) if newline.
+ * @str: String to chomp
+ *
+ * This function is like Perl chomp, but it's set to chop of all
+ * trailing newlines.
+ *
+ * Returns:
+ * If @str is a valid pointer this function returns @str, otherwise
+ * @errno is set to %EINVAL and this function returns %NULL.
+ */
+char *chomp(char *str)
+{
+	char *p;
+
+	if (!str || strlen(str) < 1) {
+		errno = EINVAL;
+		return NULL;
+	}
+
+	p = str + strlen(str) - 1;
+        while (*p == '\n')
+		*p-- = 0;
+
+	return str;
+}
+
+#ifdef UNITTEST
+#include <stdio.h>
+int main(void)
+{
+	int i; char t[][16] = { "hej\ndej", "Slime\n\n\\n", "Tripple\n\n\n", "" };
+	for (i = 0; t[i][0]; i++) printf("'%s'\n", chomp(t[i])); return 0;
+}
+#endif
+
+/**
+ * Local Variables:
+ *  compile-command: "gcc -DUNITTEST -o chompy chomp.c && ./chompy"
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */
@@ -23,89 +23,157 @@

 #include <errno.h>
 #include <fcntl.h>
-#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
-#include <sys/param.h> /* MAX(), isset(), setbit(), TRUE, FALSE, et consortes. :-) */
 #include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>

 #include "lite.h"

-static int __isdir_and_append_filename(char *src, char **dst);
+
+/* Tests if dst is a directory, if so, reallocates dst and appends src filename returning 1 */
+static int adjust_target(char *src, char **dst)
+{
+	int isdir = 0;
+
+	if (fisdir(*dst)) {
+		int slash = 0;
+		char *tmp, *ptr = strrchr(src, '/');
+
+		if (!ptr)
+			ptr = src;
+		else
+			ptr++;
+
+		tmp = malloc(strlen(*dst) + strlen(ptr) + 2);
+		if (!tmp) {
+			errno = EISDIR;
+			return 0;
+		}
+
+		isdir = 1;	/* Free dst before exit! */
+		slash = fisslashdir(*dst);
+
+		sprintf(tmp, "%s%s%s", *dst, slash ? "" : "/", ptr);
+		*dst = tmp;
+	}
+
+	return isdir;
+}
+
+/* Actual copy loop, used by both copyfile() and fcopyfile()
+ * breaks loop on error and EOF */
+static ssize_t do_copy(int in, int out, size_t num, char *buffer, size_t len)
+{
+	ssize_t ret = 0, size = 0;
+
+	do {
+		size_t count = num > len ? len : num;
+
+		ret = read(in, buffer, count);
+		if (ret <= 0) {
+			if (ret == -1 && EINTR == errno)
+				continue;
+			break;
+		}
+
+		if (ret > 0)
+			size += write(out, buffer, ret);
+		num  -= count;
+	} while (num > 0);
+
+	return size;
+}

 /**
 * copyfile - Copy a file to another.
- * @src: Source file.
- * @dst: Target file.
+ * @src: Full path name to source file.
+ * @dst: Full path name to target file.
 * @len: Number of bytes to copy, zero (0) for entire file.
+ * @sym: Should symlinks be recreated (1) or followed (0)
 *
 * This is a C implementation of the command line cp(1) utility.  It is one
 * of the classic missing links in the UNIX C library.  This version is from
 * the finit project, http://helllabs.org/finit/, which is a reimplementation
 * of fastinit for the Asus EeePC.
 *
- * Only some small changes to save stack space have been introduced.
- *
 * Returns:
 * The number of bytes copied, zero may be error (check errno!), but it
- * may also indicate that @src was empty. If @src is a directory errno
+ * may also indicate that @src was empty.  If @src is a directory @errno
 * will be set to %EISDIR since copyfile() is not recursive.
 */
-ssize_t copyfile(char *src, char *dst, int len)
+ssize_t copyfile(char *src, char *dst, int len, int sym)
 {
 	char *buffer;
-	int s, d, n, isdir = 0, saved_errno = 0;
+	int in, out, isdir = 0, saved_errno = 0;
+	size_t num;
 	ssize_t size = 0;
+	struct stat st;

-	errno = 0;		/* Reset before leaving this function. */
-//   fprintf (stderr, "%s() src: %s, dst: %s, len: %d\n", __func__, src, dst, len);
+	errno = 0;

 	buffer = malloc(BUFSIZ);
 	if (!buffer)
 		return 0;

 	if (fisdir(src)) {
-		errno = EISDIR;	/* Error: source is a directory */
-		return 0;
+		saved_errno = EISDIR;	/* Error: source is a directory */
+		goto exit;
 	}

-	/* Check if target is a directory, then append the src base filename. */
-	isdir = __isdir_and_append_filename(src, &dst);
+	/* Check if target is a directory, then append src filename. */
+	isdir = adjust_target(src, &dst);

-	/* Len == 0 means copy entire file */
-	if (len == 0) {
-		/* XXX: This feels a bit unsafe, but 2047 MiB may be sufficient for us.
-		 *       --Jocke 2008-08-11 */
-		len = INT_MAX;
+	/* Check if the source file is a symlink ... */
+	if (stat(src, &st)) {
+		size = -1;
+		goto exit;
 	}

-	if ((s = open(src, O_RDONLY)) >= 0) {
-		if ((d =
-		     open(dst, O_WRONLY | O_CREAT | O_TRUNC,
-			  fmode(src))) >= 0) {
-			do {
-				int clen = len > BUFSIZ ? BUFSIZ : len;
-
-				if ((n = read(s, buffer, clen)) > 0) {
-					size += write(d, buffer, n);
-				}
-				len -= clen;
+	/* ... only try readlink() if symlink and @sym is set. */
+	if (sym && (st.st_mode & S_IFMT) == S_IFLNK) {
+		size = readlink(src, buffer, BUFSIZ);
+		if (size > 0) {
+			if (size >= (ssize_t)BUFSIZ) {
+				saved_errno = ENOBUFS;
+				size = -1;
+			} else {
+				buffer[size] = 0;
+				size = !symlink(buffer, dst);
 			}
-			while (len > 0 && n == BUFSIZ);
-
-			close(d);
-		} else {
-			saved_errno = errno;
 		}

-		close(s);
-	} else {
-		saved_errno = errno;
+		/* Don't fall back to copy, that is a potentially
+		 * dangerous race condition, see CWE-367. */
+		goto exit;
 	}

+	/* 0: copy entire file */
+	if (len == 0)
+		num = st.st_size;
+	else
+		num = (size_t)len;
+
+	in = open(src, O_RDONLY);
+	if (in < 0) {
+		saved_errno = errno;
+		goto exit;
+	}
+
+	out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, fmode(src));
+	if (out < 0) {
+		close(in);
+		saved_errno = errno;
+		goto exit;
+	}
+
+	size = do_copy(in, out, num, buffer, BUFSIZ);
+	if (!size && errno)
+		saved_errno = errno;
+
+	close(out);
+	close(in);
+
+exit:
 	free(buffer);
 	if (isdir)
 		free(dst);
@@ -135,12 +203,12 @@ int movefile(char *src, char *dst)
 	int isdir, result = 0;

 	/* Check if target is a directory, then append the src base filename. */
-	isdir = __isdir_and_append_filename(src, &dst);
+	isdir = adjust_target(src, &dst);

 	if (rename(src, dst)) {
 		if (errno == EXDEV) {
 			errno = 0;
-			copyfile(src, dst, 0);
+			copyfile(src, dst, 0, 1);
 			if (errno)
 				result = 1;
 			else
@@ -157,105 +225,42 @@ int movefile(char *src, char *dst)
 }

 /**
- * copy_filep - Copy between FILE *fp.
+ * fcopyfile - Copy between FILE *fp.
 * @src: Source FILE.
 * @dst: Destination FILE.
 *
- * Function takes signals into account and will restart the syscalls as long
- * as error is %EINTR.
+ * Function takes signals into account and will restart the syscalls as
+ * long as error is %EINTR.
 *
 * Returns:
 * POSIX OK(0), or non-zero with errno set on error.
 */
-int copy_filep(FILE *src, FILE *dst)
+int fcopyfile(FILE *src, FILE *dst)
 {
-	int result = 0;
-	char *buf = (char *)malloc(BUFSIZ);
+	int ret;
+	char *buffer;

-	if (!src || !dst)
-		return EINVAL;
-
-	if (!buf)
-		return errno;
-
-	while (1) {
-		if (!fgets(buf, BUFSIZ, src)) {
-			if (errno == EINTR) {
-				clearerr(src);
-				continue;
-			}
-			if (feof(src))
-				break;
-
-			result = errno;
-			goto exit;
-		}
-		while (EOF == fputs(buf, dst)) {
-			if (errno == EINTR) {
-				clearerr(dst);
-				continue;
-			}
-
-			result = errno;
-			goto exit;
-		}
+	if (!src || !dst) {
+		errno = EINVAL;
+		return -1;
 	}

- exit:
-	free(buf);
-	return errno = result;
-}
+	buffer = malloc(BUFSIZ);
+	if (!buffer)
+		return -1;

-/* Tests if dst is a directory, if so, reallocates dst and appends src filename returning 1 */
-static int __isdir_and_append_filename(char *src, char **dst)
-{
-	int isdir = 0;
+	ret = do_copy(fileno(src), fileno(dst), BUFSIZ, buffer, BUFSIZ);
+	if (ret > 0)
+		ret = 0;
+	else if (errno)
+		ret = -1;

-	if (fisdir(*dst)) {
-		int slash = 0;
-		char *tmp, *ptr = strrchr(src, '/');
+	free(buffer);

-		if (!ptr)
-			ptr = src;
-		else
-			ptr++;
-
-//      fprintf (stderr, "Yes %s is a dir --> add %s\n", *dst, ptr);
-		tmp = malloc(strlen(*dst) + strlen(ptr) + 2);
-		if (!tmp) {
-			errno = EISDIR;
-			return 0;
-		}
-
-		isdir = 1;	/* Free dst before exit! */
-		slash = fisslashdir(*dst);
-
-		sprintf(tmp, "%s%s%s", *dst, slash ? "" : "/", ptr);
-		*dst = tmp;
-//      fprintf (stderr, "NEW DST:%s\n", *dst);
-	}
-
-	return isdir;
+	return ret;
 }

 #ifdef UNITTEST
-#include <stdio.h>
-/* XXX: Make a real set of unit tests ... */
-#if 0
-int main(int argc, char *argv[])
-{
-	if (argc < 3) {
-		fprintf(stderr,
-			"Usage: %s <src> <dst>\nCopies the <src> file to the <dst> file.\n",
-			argv[0]);
-		return 1;
-	}
-
-	printf("Copying file %s to %s\n", argv[1], argv[2]);
-
-	return copyfile(argv[1], argv[2], 0);
-}
-#else
 int main(void)
 {
 	int i = 0;
@@ -269,11 +274,11 @@ int main(void)

 	fprintf(stderr, "\n=>Start testing copy_filep()\n");
 	while (files[i]) {
-		fprintf(stderr, "copy_filep(%s, %s)\t", files[i],
+		fprintf(stderr, "fcopyfile(%s, %s)\t", files[i],
 			files[i + 1]);
 		src = fopen(files[i], "r");
 		dst = fopen(files[i + 1], "w");
-		if (copy_filep(src, dst))
+		if (fcopyfile(src, dst))
 			perror("Failed");

 		if (src)
@@ -284,7 +289,7 @@ int main(void)
 		if (fexist(files[i + 2]))
 			fprintf(stderr, "OK => %s\n", files[i + 2]);

-		remove(files[i + 2]);
+		erase(files[i + 2]);
 		i += 3;
 	}

@@ -292,26 +297,25 @@ int main(void)
 	i = 0;
 	while (files[i]) {
 		fprintf(stderr, "copyfile(%s, %s)\t", files[i], files[i + 1]);
-		if (!copyfile(files[i], files[i + 1], 0))
+		if (!copyfile(files[i], files[i + 1], 0, 0))
 			perror("Failed");

 		if (fexist(files[i + 2]))
 			fprintf(stderr, "OK => %s\n", files[i + 2]);

-		remove(files[i + 2]);
+		erase(files[i + 2]);
 		i += 3;
 	}

 	return 0;
 }
-#endif
-#endif				/* UNITTEST */
+#endif /* UNITTEST */

 /**
 * Local Variables:
- *  compile-command: "gcc -g -I../include -o unittest -DUNITTEST copyfile.c && ./unittest"
+ *  compile-command: "gcc -g -o coppy -DUNITTEST copyfile.c fisdir.c fexist.c fmode.c && ./coppy"
 *  version-control: t
- *  kept-new-versions: 2
- *  c-file-style: "ellemtel"
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
 * End:
 */
@@ -1,6 +1,6 @@
 /* Functions for operating on files in directories.
 *
- * Copyright (c) 2008-2012  Joachim Nilsson <troglobit@gmail.com>
+ * Copyright (c) 2008-2014  Joachim Nilsson <troglobit@gmail.com>
 * 
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
@@ -94,7 +94,7 @@ int dir(const char *dir, const char *type, int (*filter) (const char *file), cha
 	n = scandir(dir, &namelist, matcher, alphasort);
 	if (n < 0) {
 		perror("scandir");
-	} else {
+	} else if (n > 0) {
 		files = (char **)malloc(n * sizeof(char *));
 		for (i = 0; i < n; i++) {
 			if (files) {
@@ -109,11 +109,12 @@ int dir(const char *dir, const char *type, int (*filter) (const char *file), cha
 			}
 			free(namelist[i]);
 		}
-		free(namelist);
+		if (num)
+			*list = files;
 	}

-	if (num)
-		*list = files;
+	if (namelist)
+		free(namelist);

 	return num;
 }
@@ -141,13 +142,13 @@ int simulate_files(int creat)
 		if (creat)
 			touch(files[i]);
 		else
-			remove(files[i]);
+			erase(files[i]);
 	}

 	if (creat)
 		symlink("config2.cfg", STARTUP_CONFIG);
 	else
-		remove(STARTUP_CONFIG);
+		erase(STARTUP_CONFIG);

 	return 0;
 }
@@ -39,7 +39,7 @@ mode_t fmode(char *file)

 	if (!file) {
 		errno = EINVAL;
-		return 0;	/* Doesn't exist ... */
+		return 0;
 	}

 	if (!stat(file, &sb))
@@ -0,0 +1,118 @@
+/* Copy data between file streams
+ *
+ * Copyright (c) 2013  Tobias Waldekranz <tobias@waldekranz.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 <stdio.h>
+#include <stdlib.h>
+
+
+/**
+ * fsendfile - copy data between file streams
+ * @src: Source stream
+ * @dst: Destination stream
+ * @len: Number of bytes to copy
+ *
+ * @dst may be %NULL, in which case @len bytes are read and discarded
+ * from @src.  This can be useful for streams where seeking is not
+ * permitted.  Additionally, @len may be the special value zero (0), in
+ * which case fsendfile() will copy until %EOF is seen on @src.
+ *
+ * Returns:
+ * The number of bytes copied.  If an error is detected -1 is returned
+ * and @errno will be set accordingly.
+ */
+size_t fsendfile(FILE *src, FILE *dst, size_t len)
+{
+	char *buf;
+	size_t blk = BUFSIZ, num = 0, tot = 0;
+
+        if (!src) {
+                errno = EINVAL;
+                return -1;
+        }
+                
+	buf = (char *)malloc(BUFSIZ);
+	if (!buf)
+		return -1;
+
+	while (!len || tot < len) {
+		if (len && ((len - tot) < BUFSIZ))
+			blk = len - tot;
+
+		num = fread(buf, 1, blk, src);
+		if (num == 0)
+			break;
+
+		if (dst && (fwrite(buf, num, 1, dst) != 1)) {
+			num = -1;
+			break;
+		}
+
+		tot += num;
+	}
+
+	free(buf);
+
+	return (num == (size_t)-1) ? (size_t)-1 : tot;
+}
+
+#ifdef UNITTEST
+#include <unistd.h>
+
+int main(void)
+{
+	int i = 0;
+	char *files[] = {
+		"/etc/passwd", "/tmp/tok",
+		"/etc/passwd", "/tmp/passwd",
+		"/etc/passwd", "/tmp/passwd",
+		NULL
+	};
+	FILE *src, *dst;
+
+	while (files[i]) {
+                src = fopen(files[i], "r");
+                dst = fopen(files[i + 1], "w");
+		fprintf(stderr, "fsendfile(%s, %s, 512)\t", files[i], files[i + 1]);
+		if (-1 == fsendfile(src, dst, 512))
+			perror("Failed");
+
+		if (!access(files[i + 1], F_OK))
+			fprintf(stderr, "OK => %s\n", files[i + 1]);
+
+		remove(files[i + 1]);
+		i += 2;
+	}
+
+	return 0;
+}
+#endif /* UNITTEST */
+
+/**
+ * Local Variables:
+ *  compile-command: "gcc -g -o sendy -DUNITTEST fsendfile.c && ./sendy"
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */
@@ -0,0 +1,92 @@
+/* Fastinit (finit) ifconfig() implementation.
+ *
+ * Copyright (c) 2008 Claudio Matsuoka <http://helllabs.org/finit/>
+ * Copyright (C) 2009-2014  Joachim Nilsson <joachim.nilsson@westermo.se>
+ *
+ * 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 <arpa/inet.h>
+#include <errno.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+extern size_t strlcpy(char *dst, const char *src, size_t siz);
+
+/**
+ * ifconfig - Basic ifconfig like operations on an interface
+ * @ifname: Name of interface to operate on
+ * @addr:   If @up then set this optional IPv4 address
+ * @mask:   If @up and @addr, and @addr is not INADDR_ANY, then set netmask
+ * @up:     Control %IFF_UP flag on interface
+ *
+ * Returns:
+ * POSIX OK(0) on success, or non-zero on error.
+ */
+int ifconfig(char *ifname, char *addr, char *mask, int up)
+{
+	int sd, ret = -1;
+	struct ifreq ifr;
+	struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
+
+	if ((sd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0)
+		return -1;
+
+	memset(&ifr, 0, sizeof (ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_addr.sa_family = AF_INET;
+
+	if (up) {
+		if (addr) {
+			if (inet_pton(AF_INET, addr, &sin->sin_addr) == 1)
+				ret = ioctl(sd, SIOCSIFADDR, &ifr);
+		}
+
+		/* Non-zero IP address */
+		if (mask && addr && strcmp(addr, "0.0.0.0")) {
+			if (inet_pton(AF_INET, mask, &sin->sin_addr) == -1)
+				ret = ioctl(sd, SIOCSIFNETMASK, &ifr);
+		}
+	}
+
+	if (!ioctl(sd, SIOCGIFFLAGS, &ifr)) {
+		if (up)
+			ifr.ifr_flags |=  IFF_UP;
+		else
+			ifr.ifr_flags &= ~IFF_UP;
+
+		ret = ioctl(sd, SIOCSIFFLAGS, &ifr);
+	}
+
+	close(sd);
+
+	return ret;
+}
+
+/**
+ * Local Variables:
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */
@@ -1,7 +1,7 @@
 /* Collection of utility funcs and C library extensions for finit & its plugins
 *
 * Copyright (c) 2008-2010  Claudio Matsuoka <cmatsuoka@gmail.com>
- * Copyright (c) 2008-2012  Joachim Nilsson <troglobit@gmail.com>
+ * Copyright (c) 2008-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
@@ -25,23 +25,76 @@
 #ifndef FINIT_LITE_H_
 #define FINIT_LITE_H_

+#include <error.h>
 #include <stdio.h>
+#include <stdint.h>    /* uint8_t, uint16_t, uint32_t, INT32_MAX, etc. */
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <sys/param.h> /* MAX(), isset(), setbit(), TRUE, FALSE, et consortes. :-) */
 #include <unistd.h>

+char   *chomp      (char *str);
+
 int     fexist     (char *file);
 int     fisdir     (char *file);
 mode_t  fmode      (char *file);

-ssize_t copyfile   (char *src, char *dst, int len);
+FILE   *tempfile   (void);
+ssize_t copyfile   (char *src, char *dst, int len, int sym);
 int     movefile   (char *src, char *dst);
-int     copy_filep (FILE *src, FILE *dst);
+int     fcopyfile  (FILE *src, FILE *dst);
+size_t  fsendfile  (FILE *src, FILE *dst, size_t len);
+
+int     ifconfig   (char *ifname, char *addr, char *mask, int up);
+
+int     mkpath     (char *dir, mode_t mode);
+int     makepath   (char *dir);

 int     dir        (const char *dir, const char *type, int (*filter) (const char *file), char ***list, int strip);
 int     rsync      (char *src, char *dst, int delete, int (*filter) (const char *file));

+int     pidfile       (const char *basename);
+int     pidfile_signal(const char *pidfile, int signal);
+pid_t   pidfile_read  (const char *pidfile);
+pid_t   pidfile_poll  (const char *pidfile);
+
+#ifndef strlcpy
+size_t  strlcpy    (char *dst, const char *src, size_t siz);
+#endif
+#ifndef strlcat
+size_t  strlcat    (char *dst, const char *src, size_t siz);
+#endif
+#ifndef strtonum
+long long strtonum (const char *numstr, long long minval, long long maxval, const char **errstrp);
+#endif
+
+#ifndef touch
+# define touch(x) do { if (mknod((x), S_IFREG|0644, 0) && errno != EEXIST) error(0, errno, "Failed creating %s", x); } while (0)
+#endif
+#ifndef makedir
+# define makedir(x, p) do { if (mkdir(x, p) && errno != EEXIST) error(0, errno, "Failed creating directory %s", x); } while (0)
+#endif
+#ifndef makefifo
+# define makefifo(x, p) do { if (mkfifo(x, p) && errno != EEXIST) error(0, errno, "Failed creating FIFO %s", x); } while (0)
+#endif
+#ifndef erase
+# define erase(x) do { if (remove(x) && errno != ENOENT) error(0, errno, "Failed removing %s", x); } while (0)
+#endif
+#ifndef chardev
+# define chardev(x,m,maj,min) mknod((x), S_IFCHR|(m), makedev((maj),(min)))
+#endif
+#ifndef blkdev
+# define blkdev(x,m,maj,min) mknod((x), S_IFBLK|(m), makedev((maj),(min)))
+#endif
+#ifndef S_ISEXEC
+# define S_ISEXEC(m) (((m) & S_IXUSR) == S_IXUSR)
+#endif
+#ifndef UNUSED
+#define UNUSED(x) UNUSED_ ## x __attribute__ ((unused))
+#endif
+
+
 static inline int fisslashdir(char *dir)
 {
   if (!dir)             return 0;
@@ -49,6 +102,54 @@ static inline int fisslashdir(char *dir)
                         return 0;
 }

+/* Convert string to natural number (0-2147483647), returns -1 on error. */
+static inline int atonum(const char *str)
+{
+	int val = -1;
+	const char *errstr;
+
+	if (str) {
+		val = strtonum(str, 0, INT32_MAX, &errstr);
+		if (errstr)
+			return -1;
+	}
+
+	return val;
+}
+
+/* Validate string, non NULL and not zero length */
+static inline int string_valid (const char *s)
+{
+   return s && strlen (s);
+}
+
+/* Relaxed comparison, e.g., sys_string_match("small", "smaller") => TRUE */
+static inline int string_match (const char *a, const char *b)
+{
+   size_t min = MIN(strlen (a), strlen (b));
+
+   return !strncasecmp (a, b, min);
+}
+
+/* Strict comparison, e.g., sys_string_match("small", "smaller") => FALSE */
+static inline int string_compare (const char *a, const char *b)
+{
+   return strlen (a) == strlen (b) && !strcmp (a, b);
+}
+
+/* Strict comparison, like sys_string_compare(), but case insensitive,
+ * e.g., sys_string_match("small", "SmAlL") => TRUE
+ */
+static inline int string_case_compare (const char *a, const char *b)
+{
+   return strlen (a) == strlen (b) && !strcasecmp (a, b);
+}
+
+/* Compat */
+#define copy_filep       (src, dst)    fcopyfile      (src,dst)
+#define pidfile_read_pid (file)        pifile_read    (file)
+#define signal_pidfile   (file, signo) pidfile_signal (file,signo)
+
 #endif /* FINIT_LITE_H_ */

 /**
@@ -0,0 +1,120 @@
+/* mkpath() -- Create all components leading up to a given directory
+ *
+ * Copyright (c) 2013  Joachim Nilsson <troglobit@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <errno.h>
+#include <libgen.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+int mkpath(char *dir, mode_t mode)
+{
+	if (!dir) {
+		errno = EINVAL;
+		return 1;
+	}
+
+	if (strlen(dir) == 1 && dir[0] == '/')
+		return 0;
+
+	mkpath(dirname(strdupa(dir)), mode);
+
+	return mkdir(dir, mode);
+}
+
+/**
+ * makepath - Create all components of the specified directory.
+ * @dir: Directory to create.
+ *
+ * Returns:
+ * POSIX OK (0) on success, otherwise -1 and errno set appropriately.
+ * This function returns EINVAL on bad argument, or ENOMEM when it
+ * fails allocating temporary memory.  For other error codes see the
+ * mkdir() syscall description.
+ */
+int makepath(char *dir)
+{
+	return mkpath(dir, 0777);
+}
+
+/********************************* UNIT TESTS ************************************/
+#ifdef UNITTEST
+#include <stdio.h>
+
+int checkpath(char *dir)
+{
+	char tmp[256];
+	struct stat sb;
+
+	snprintf(tmp, sizeof(tmp), "ls -ld %s", dir);
+	system(tmp);
+
+	if (!stat(dir, &sb) && S_ISDIR(sb.st_mode))
+		return 0;
+
+	errno = ENOTDIR;
+	return 1;
+}
+
+int test_makepath(char *dir)
+{
+	int ret = makepath(dir);
+
+	if (!ret)
+		ret = checkpath(dir);
+	if (ret)
+		perror("Failed");
+
+	return ret;
+}
+
+int main(void)
+{
+	int i, ret = 0;
+	char *list[] = {
+		"/tmp/tok/",
+		"/tmp/tok2",
+		"/tmp/ab",
+		"/tmp/b",
+		"/tmp/a/",
+		"/tmp/a/b",
+		"/tmp/a/c/",
+		NULL
+	};
+
+	fprintf(stderr, "Testing makepath() ...\n");
+	for (i = 0; list[i] && !ret; i++)
+		ret = test_makepath(list[i]);
+
+	fprintf(stderr, "\nCleaning up ...\n");
+	for (i = 0; list[i]; i++)
+		rmdir(list[i]);
+
+	return ret;
+}
+#endif  /* UNITTEST */
+
+/**
+ * Local Variables:
+ *  compile-command: "gcc -g -o unittest -D_GNU_SOURCE -DUNITTEST makepath.c && ./unittest"
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */
@@ -0,0 +1,107 @@
+/*	$OpenBSD: pidfile.c,v 1.10 2014/06/30 00:26:22 deraadt Exp $	*/
+/*	$NetBSD: pidfile.c,v 1.4 2001/02/19 22:43:42 cgd Exp $	*/
+
+/*-
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Jason R. Thorpe.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ */
+
+#include <sys/types.h>
+#include <errno.h>
+#include <paths.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static char *pidfile_path;
+static pid_t pidfile_pid;
+
+static void pidfile_cleanup(void);
+
+extern char *__progname;
+
+int
+pidfile(const char *basename)
+{
+	int save_errno, result;
+	pid_t pid;
+	FILE *f;
+
+	if (basename == NULL)
+		basename = __progname;
+
+	if (pidfile_path != NULL) {
+		free(pidfile_path);
+		pidfile_path = NULL;
+	}
+
+	/* _PATH_VARRUN includes trailing / */
+	result = asprintf(&pidfile_path, "%s%s.pid", _PATH_VARRUN, basename);
+	if (result == -1 || pidfile_path == NULL)
+		return (-1);
+
+	if ((f = fopen(pidfile_path, "w")) == NULL) {
+		save_errno = errno;
+		free(pidfile_path);
+		pidfile_path = NULL;
+		errno = save_errno;
+		return (-1);
+	}
+
+	pid = getpid();
+	if (fprintf(f, "%ld\n", (long)pid) <= 0 || fflush(f) != 0) {
+		save_errno = errno;
+		(void) fclose(f);
+		(void) unlink(pidfile_path);
+		free(pidfile_path);
+		pidfile_path = NULL;
+		errno = save_errno;
+		return (-1);
+	}
+	(void) fclose(f);
+
+	pidfile_pid = pid;
+	if (atexit(pidfile_cleanup) < 0) {
+		save_errno = errno;
+		(void) unlink(pidfile_path);
+		free(pidfile_path);
+		pidfile_path = NULL;
+		pidfile_pid = 0;
+		errno = save_errno;
+		return (-1);
+	}
+
+	return (0);
+}
+
+static void
+pidfile_cleanup(void)
+{
+
+	if (pidfile_path != NULL && pidfile_pid == getpid())
+		(void) unlink(pidfile_path);
+}
@@ -0,0 +1,166 @@
+/* Functions for dealing with PID files (client side)
+ *
+ * Copyright (c) 2009-2015  Joachim Nilsson <troglobit@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+
+extern char *chomp(char *str);
+
+/**
+ * pidfile_read - Reads a PID value from a pidfile.
+ * @pidfile: File containing PID, usually in /var/run/<PROC>.pid
+ *
+ * This function takes a @pidfile and returns the PID found therein.
+ *
+ * Returns:
+ * On invalid @pidfile -1 and errno set to %EINVAL, when @pidfile does not exist -1
+ * and errno set to %ENOENT.  When the pidfile is empty or when its contents cannot
+ * be translated this function returns zero (0), on success this function returns
+ * a PID value greater than one. PID 1 is reserved for the system init process.
+ */
+pid_t pidfile_read(const char *pidfile)
+{
+	int pid = 0;
+	char buf[16];
+	FILE *fp;
+
+	if (!pidfile) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	fp = fopen(pidfile, "r");
+	if (!fp)
+		return -1;
+
+	if (fgets(buf, sizeof(buf), fp)) {
+                char *ptr = chomp(buf);
+
+                if (ptr) {
+                        errno = 0;
+                        pid = strtoul(ptr, NULL, 0);
+                        if (errno)
+                                pid = 0; /* Failed conversion. */
+                }
+	}
+	fclose(fp);
+
+	return pid;
+}
+
+/**
+ * pidfile_poll - Poll for the existence of a pidfile and return PID
+ * @pidfile: Path to pidfile to poll for
+ *
+ * This function polls for the pidfile at @pidfile for at most 5 seconds
+ * before timing out. If the file is created within that time span the
+ * file is read and its PID contents returned.
+ *
+ * Returns:
+ * The PID read from @pidfile, or zero on timeout.
+ */
+pid_t pidfile_poll(const char *pidfile)
+{
+	pid_t pid = 0;
+	int tries = 0;
+
+	/* Timeout = 100 * 50ms = 5s */
+	while ((pid = pidfile_read(pidfile)) <= 0 && tries++ < 100)
+		usleep(50000);	/* Wait 50ms between retries */
+
+	if (pid < 0)
+		pid = 0;
+
+	return pid;
+}
+
+/**
+ * pidfile_signal - Send signal to a PID and cleanup pidfile afterwards
+ * @pidfile: File containing PID, usually in /var/run/<PROC>.pid
+ * @signal: Signal to send to PID found in @pidfile.
+ *
+ * If @signal is any of %SIGTERM, %SIGKILL, or if kill() returns -1 the
+ * @pidfile is removed.
+ *
+ * Returns:
+ * POSIX OK(0) on success, non-zero otherwise.
+ */
+int pidfile_signal(const char *pidfile, int signal)
+{
+	int pid = -1, ret = -1;
+
+	pid = pidfile_read(pidfile);
+	if (pid <= 0)
+		return 1;
+
+	ret = kill(pid, signal);
+	if ((ret == -1) || (signal == SIGTERM) || (signal == SIGKILL))
+		(void)remove(pidfile);
+
+	return 0;
+}
+
+
+/********************************* UNIT TESTS ************************************/
+#ifdef UTEST_PIDFN
+#define PIDFILE "/var/run/unittest.pid"
+
+static void sigterm_handler(int signo)
+{
+	fprintf(stderr, "Exiting ...\n");
+}
+
+static void sigalrm_handler(int signo)
+{
+	fprintf(stderr, "Testing pidfile() ...\n");
+	pidfile(NULL);
+}
+
+int main(void)
+{
+	signal(SIGTERM, sigterm_handler);
+	signal(SIGALRM, sigalrm_handler);
+	alarm(3);
+
+	fprintf(stderr, "Testing pidfile_poll() ...\n");
+	if (!pidfile_poll(PIDFILE))
+		fprintf(stderr, "Timed out!\n");
+	else
+		fprintf(stderr, "We got signal!\n");
+
+	system("ls -ld " PIDFILE);
+
+	fprintf(stderr, "Reading pid file, should be %d ...\n", getpid());
+        fprintf(stderr, "=> %d\n", pidfile_read(PIDFILE));
+
+        fprintf(stderr, "Signalling ourselves ...\n");
+
+	return pidfile_signal(PIDFILE, SIGTERM);
+}
+#endif  /* UTEST_PIDFN */
+
+/**
+ * Local Variables:
+ *  compile-command: "gcc -g -o unittest -DUTEST_PIDFN pidfile.c chomp.c pidfilefn.c && ./unittest"
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */
@@ -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_ */
@@ -25,9 +25,9 @@
 #include <sys/types.h>

 #include "lite.h"
-#include "../helpers.h"

-static int makedir(char *buf, size_t buf_len, char *dir, char *name, mode_t mode);
+static int copy(char *src, char *dst);
+static int mdir(char *buf, size_t buf_len, char *dir, char *name, mode_t mode);
 static int prune(char *dst, char **new_files, int new_num);


@@ -58,21 +58,16 @@ int rsync(char *src, char *dst, int delete, int (*filter) (const char *file))
 	int i = 0, num = 0, result = 0;
 	char **files;		/* Array of file names. */

-	void copy(char *src, char *dst)
-	{
-		errno = 0;
-		copyfile(src, dst, 0);
-		if (errno) result++;
-	}
-
 	if (!fisdir(dst))
-		mkdir(dst, 0755);
+		makedir(dst, 0755);

 	if (!fisdir(src)) {
 		if (!fexist(src))
 			return 1;

-		copy(src, dst);
+		if (copy(src, dst))
+			result++;
+
 		return errno;
 	}

@@ -85,7 +80,7 @@ int rsync(char *src, char *dst, int delete, int (*filter) (const char *file))
 		else
 			ptr++;

-		if (makedir(dest, sizeof(dest), dst, ptr, fmode(src)))
+		if (mdir(dest, sizeof(dest), dst, ptr, fmode(src)))
 			return 1;
 		dst = dest;
 	}
@@ -98,7 +93,7 @@ int rsync(char *src, char *dst, int delete, int (*filter) (const char *file))
 			char dst2[256];

 			strcat(source, "/");
-			if (makedir (dst2, sizeof(dst2), dst, files[i], fmode(source))) {
+			if (mdir (dst2, sizeof(dst2), dst, files[i], fmode(source))) {
 				result++;
 				continue;
 			}
@@ -106,7 +101,9 @@ int rsync(char *src, char *dst, int delete, int (*filter) (const char *file))
 			rsync(source, dst2, delete, filter);
 			continue;	/* Next file/dir in @src to copy... */
 		}
-		copy(source, dst);
+
+		if (copy(source, dst))
+			result++;
 	}

 	/* We ignore any errors from the pruning, that phase albeit useful is only
@@ -123,36 +120,60 @@ int rsync(char *src, char *dst, int delete, int (*filter) (const char *file))
 	return result;
 }

-/* Creates dir/name @mode ... skipping / if dir already ends so. */
-static int makedir(char *buf, size_t buf_len, char *dir, char *name, mode_t mode)
+static int copy(char *src, char *dst)
 {
-	snprintf(buf, buf_len, "%s%s%s/", dir, fisslashdir(dir) ? "" : "/", name);
-	if (mkdir(buf, mode))
-		return 1;
+	errno = 0;
+
+	copyfile(src, dst, 0, 1);
+	if (errno) {
+		if (errno != EEXIST)
+			return 1;
+
+		errno = 0;
+	}

 	return 0;
 }

+/* Creates dir/name @mode ... skipping / if dir already ends so. */
+static int mdir(char *buf, size_t buf_len, char *dir, char *name, mode_t mode)
+{
+	snprintf(buf, buf_len, "%s%s%s/", dir, fisslashdir(dir) ? "" : "/", name);
+	if (mkdir(buf, mode)) {
+		if (EEXIST != errno)
+			return 1;
+
+		errno = 0;
+	}
+
+	return 0;
+}
+
+
+static int find(char *file, char **files, int num)
+{
+	int n;
+
+	for (n = 0; n < num; n++)
+		if (!strncmp (files[n], file, MAX(strlen(files[n]), strlen(file))))
+			return 1;
+
+	return 0;
+}
+
+
 /* Prune old files, no longer existing on source, from destination directory. */
 static int prune(char *dst, char **new_files, int new_num)
 {
-	int i, num, result = 0;
+	int num, result = 0;
 	char **files;

-	int find(char *file) {
-		int n;
-
-		for (n = 0; n < new_num; n++)
-			if (!strncmp (new_files[n], file, MAX(strlen(new_files[n]), strlen(file))))
-				return 1;
-
-		return 0;
-	}
-
 	num = dir(dst, "", NULL, &files, 0);
 	if (num) {
+		int i;
+
 		for (i = 0; i < num; i++) {
-			if (!find(files[i])) {
+			if (!find(files[i], new_files, new_num)) {
 				char *name;
 				size_t len = strlen(files[i]) + 2 + strlen(dst);

@@ -0,0 +1,9 @@
+# Pretty printing and GCC -M for auto dep files
+%.o: %.c
+	$(PRINT) "  CC      $(subst $(ROOTDIR)/,,$(shell pwd)/)$@\n"
+	$(Q)$(CC) $(CFLAGS) $(CPPFLAGS) -c -MMD -MP -o $@ $<
+
+%: %.o
+	$(PRINT) "  LINK    $(subst $(ROOTDIR)/,,$(shell pwd)/)$@\n"
+	$(Q)$(CC) $(CFLAGS) $(LDFLAGS) -Wl,-Map,$@.map -o $@ $^ $(LDLIBS$(LDLIBS-$(@)))
+
@@ -0,0 +1,66 @@
+/*	$OpenBSD: strlcat.c,v 1.13 2005/08/08 08:05:37 espie Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+#ifndef strlcat
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+strlcat(char *dst, const char *src, size_t siz)
+{
+	char *d = dst;
+	const char *s = src;
+	size_t n = siz;
+	size_t dlen;
+
+	/* Find the end of dst and adjust bytes left but don't go past end */
+	while (n-- != 0 && *d != '\0')
+		d++;
+	dlen = d - dst;
+	n = siz - dlen;
+
+	if (n == 0)
+		return(dlen + strlen(s));
+	while (*s != '\0') {
+		if (n != 1) {
+			*d++ = *s;
+			n--;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return(dlen + (s - src));	/* count does not include NUL */
+}
+#endif
+
+/**
+ * Local Variables:
+ *  version-control: t
+ *  c-file-style: "bsd"
+ * End:
+ */
+
+
@@ -0,0 +1,61 @@
+/*	$OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+#ifndef strlcpy
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+strlcpy(char *dst, const char *src, size_t siz)
+{
+	char *d = dst;
+	const char *s = src;
+	size_t n = siz;
+
+	/* Copy as many bytes as will fit */
+	if (n != 0) {
+		while (--n != 0) {
+			if ((*d++ = *s++) == '\0')
+				break;
+		}
+	}
+
+	/* Not enough room in dst, add NUL and traverse rest of src */
+	if (n == 0) {
+		if (siz != 0)
+			*d = '\0';		/* NUL-terminate dst */
+		while (*s++)
+			;
+	}
+
+	return(s - src - 1);	/* count does not include NUL */
+}
+
+#endif
+
+/**
+ * Local Variables:
+ *  version-control: t
+ *  c-file-style: "bsd"
+ * End:
+ */
@@ -0,0 +1,67 @@
+/*	$OpenBSD: strtonum.c,v 1.6 2004/08/03 19:38:01 millert Exp $	*/
+
+/*
+ * Copyright (c) 2004 Ted Unangst and Todd Miller
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+#ifndef strtonum
+#define INVALID 	1
+#define TOOSMALL 	2
+#define TOOLARGE 	3
+
+long long
+strtonum(const char *numstr, long long minval, long long maxval,
+    const char **errstrp)
+{
+	long long ll = 0;
+	char *ep;
+	int error = 0;
+	struct errval {
+		const char *errstr;
+		int err;
+	} ev[4] = {
+		{ NULL,		0 },
+		{ "invalid",	EINVAL },
+		{ "too small",	ERANGE },
+		{ "too large",	ERANGE },
+	};
+
+	ev[0].err = errno;
+	errno = 0;
+	if (minval > maxval)
+		error = INVALID;
+	else {
+		ll = strtoll(numstr, &ep, 10);
+		if (numstr == ep || *ep != '\0')
+			error = INVALID;
+		else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
+			error = TOOSMALL;
+		else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
+			error = TOOLARGE;
+	}
+	if (errstrp != NULL)
+		*errstrp = ev[error].errstr;
+	errno = ev[error].err;
+	if (error)
+		ll = 0;
+
+	return (ll);
+}
+#endif
@@ -0,0 +1,71 @@
+/* A secure tmpfile() replacement.
+ *
+ * Copyright (c) 2015  Joachim Nilsson <troglobit@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <paths.h>
+#include <fcntl.h>		/* O_TMPFILE requires -D_GNU_SOURCE */
+#include <stdlib.h>		/* mkstemp() */
+#include <stdio.h>		/* fdopen() */
+#include <sys/stat.h>		/* umask() */
+
+#ifndef  O_TMPFILE		/* Too old GLIBC or kernel */
+#warning O_TMPFILE missing on your system, tempfile() may not work!
+#define  O_TMPFILE 020200000	/* Define and let it fail at runtime */
+#endif
+
+/**
+ * tempfile - A secure tmpfile() replacement
+ *
+ * This is the secure replacement for tmpfile() that does not exist in
+ * GLIBC.  The function uses the Linux specific %O_TMPFILE and %O_EXCL
+ * for security.  When the %FILE is fclose()'ed the file contents is
+ * lost.  The file is hidden in the %_PATH_TMP directory on the system.
+ *
+ * This function requires Linux 3.11, or later, due to %O_TMPFILE.
+ *
+ * Returns:
+ * An open %FILE pointer, or %NULL on error.
+ */
+FILE *tempfile(void)
+{
+	int fd;
+	mode_t oldmask;
+
+	oldmask = umask(0077);
+	fd = open(_PATH_TMP, O_TMPFILE | O_RDWR | O_EXCL | O_CLOEXEC, S_IRUSR | S_IWUSR);
+	umask(oldmask);
+	if (-1 == fd)
+		return NULL;
+
+	return fdopen(fd, "rw");
+}
+
+#ifdef UNITTEST
+int main(void)
+{
+	FILE *fp = tempfile(); system("ls -lrt "
+	_PATH_TMP " | tail -10"); return fclose(fp);
+}
+#endif
+
+/**
+ * Local Variables:
+ *  compile-command: "gcc -D_GNU_SOURCE -DUNITTEST -o tempy tempfile.c && ./tempy"
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */
Author	SHA1	Message	Date
Joachim Nilsson	6d2717726f	Shorten README title heading. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-12 12:50:01 +02:00
Joachim Nilsson	2675426845	Update README for release. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-12 12:44:39 +02:00
Joachim Nilsson	51c73030e0	Minor change. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-12 12:43:57 +02:00
Joachim Nilsson	a9d11d0498	ifconfig.c: Fix possible NULL pointer deref. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-10 19:27:02 +02:00
Joachim Nilsson	1147e547dc	Followup to atonum(), missing include file and const. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-10 19:06:17 +02:00
Joachim Nilsson	41c9caff17	Add atonum() - Convert string to natural number, returns -1 on error. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-10 19:00:11 +02:00
Joachim Nilsson	4005dd5e2c	Add simple IPv4 only ifconfig() function from Finit Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-10 18:28:57 +02:00
Joachim Nilsson	614c8cbe47	Update documentation of OpenBSD derived functions with pointers to man pages. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-10 18:27:46 +02:00
Joachim Nilsson	8db314623a	Followup to pidfilefn.c, add system include file for usleep() Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-09 03:22:53 +02:00
Joachim Nilsson	e731d83881	Add pidfile_poll() from Finit, waits max 5 sec for pidfile. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-09 03:19:56 +02:00
Joachim Nilsson	c2d0ed0d12	Fix minor issues in pidfile_read() and pidfile_signal(), caught by Coverity - Simplify pidfile_read(), no need to call access() when fopen() is more than capable of failing on its own if we do not have READ access. - The remove() syscall requires that you check the return value, but we don't care about that when having signalled a TERM signal to a process. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-09 01:59:10 +02:00
Joachim Nilsson	5a50a6add1	Add client side pidfile functions: pidfile_read(), pidfile_signal(). Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-09 01:36:58 +02:00
Joachim Nilsson	9ed00baa94	Add pidfile() from NetBSD/OpenBSD, missing in GLIBC. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-09 01:25:19 +02:00
Joachim Nilsson	1561e7567e	Add recursive mkpath() and makepath(), works like mkdir -p Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-09 01:25:19 +02:00
Joachim Nilsson	c5366a33da	fsendfile(): Break ABI by switching src and dst to match rest of API. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-06 02:04:28 +02:00
Joachim Nilsson	af39ae5fa9	Refactor copyfile(), and copy_filep() --> fcopyfile() to use same backend. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-06 02:03:28 +02:00
Tobias Waldekranz	1423edc044	Factor out fsendfile() to reduce overall size when linking. Signed-off-by: Tobias Waldekranz <tobias@waldekranz.com> Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-05 15:21:55 +02:00
Joachim Nilsson	c48ce14739	Default to silent build, use V=1 to get verbose mode. Use kernel standard silent mode instead, and adopt kernel nomenclature for enabling verbose mode. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-05 11:46:48 +02:00
Joachim Nilsson	6f19d1407a	Default to verbose style build, use SILENT=1 to get silent mode. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-05 11:28:03 +02:00
Joachim Nilsson	436a07ee06	Remove STATIC ifdef, always build .a and .so files Using libite as a GIT submodule in a autoconf/automake based project it is non-trivial to set a separate environment variable when descending into the libite subdirectory. It is better to instead simplify the build process and always build both .a and .so files. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-05 11:06:33 +02:00
Joachim Nilsson	e37aad9530	Update on tmpfile() requirements. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-03 01:50:15 +02:00
Joachim Nilsson	32827cdea9	Add OpenBSD version of the extremely useful sys/queue.h API Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-07-03 01:47:22 +02:00
Joachim Nilsson	e4c5a0e77e	copyfile(): Fix potentially dangerous time of check-time of use bug. Coverity reports a potenatially TOCTOU bug, CWE-367, in copyfile(). Turns out we tried to fall back to copy when readlink() failed, in the case when the user requested to copy symlinks. It's better to fail hard if stat() reports symlink and readlink() right after fails to read the symlink ... Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-22 22:39:59 +02:00
Joachim Nilsson	35b43c5c56	Handle missing O_TMPFILE gracefully and document tempfile() in README Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-22 22:02:39 +02:00
Joachim Nilsson	c5434a4bc0	Add tempfile() - a secure tmpfile() replacement using O_TMPFILE. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-22 21:42:38 +02:00
Joachim Nilsson	84c3667eba	Default to -fPIC, bloats archives slightly, but works for everyone. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-18 02:24:17 +02:00
Joachim Nilsson	262f8b8936	Cleanup: Fix install/uninstall of both static and dynamic builds. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-18 02:14:55 +02:00
Joachim Nilsson	c045bc7264	Add small clarification on licenses used in libite (-lite) Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-18 01:06:05 +02:00
Joachim Nilsson	82ca189a52	Fix buggy chomp() -- Chop off only trailing newlines, all of them. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 23:45:39 +02:00
Joachim Nilsson	1b4dd15614	Document helper macros. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 23:10:50 +02:00
Tobias Waldekranz	121e8ee888	Add Westermo chomp() function, slightly improved from Finit original. Signed-off-by: Tobias Waldekranz <tobias@waldekranz.com> Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 22:07:10 +02:00
Joachim Nilsson	745256909e	Shorten title. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 21:57:29 +02:00
Joachim Nilsson	552f917b9b	Update README slightly. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 21:56:03 +02:00
Joachim Nilsson	08ce3d503e	Add basic README. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 21:26:58 +02:00
Joachim Nilsson	22a79ee947	Make libite standalone Add basic .gitignore, cleanup inherited Makefile from Finit and add a small rules.mk from libuEv. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 21:13:02 +02:00
Joachim Nilsson	1758f9a847	rsync.c: Use makedir() from lite.h Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 20:57:05 +02:00
Joachim Nilsson	9f0979daea	Add some helper macros and wrappers for C library functions. - touch() - Create a file, or update mtime. Errors on stderr - makedir() - Create directory, like mkdir(). Errors on stderr - makefifo() - Create a FIFO, like mkfifo(). Errors on stderr - erase() - Erase file/directory with remove(). Errors on stderr - chardev() - Create character device - blkdev() - Create block device - S_ISEXEC() - Mysteriously missing from GLIBC - UNUSED() - Shorter and more readable version of __attribute__ ((unused)) Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 20:56:07 +02:00
Joachim Nilsson	95922a9536	Add standard MIT/X11 license, from Finit. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-06-17 16:14:14 +02:00
Joachim Nilsson	f35f64f06f	Fix last part of issue #8 : Libite install problem with --enable-static Skip install of .so libs when user has configured with --enable-static Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-03-10 22:12:26 +01:00
Joachim Nilsson	8b7eb36d2a	Overhaul build system and add support for disabling inetd support. This patch adds support for a configure script and with it support for disabling inetd support. See the output from ./configure --help * Add configure script * Sprinkle #ifdef fairy dust on svc.c when inetd support is disabled * Use GCC built-in autodep calculator (-MMD -MP) * Fix name space issue with include files, use relative paths * Disable username/group name to uid/gid functions in static builds * Bug out (error) if a user tries to build the bootmisc plugin static Possibly fixes GitHub issue #5 and issue #6. NOTE: The static build has not received any testing at all! Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-03-10 10:25:46 +01:00
Joachim Nilsson	5e31d05110	Initial support for building Finit statically (incomplete) This patch adresses issue #5. However, there still remains a few issues to work around before Finit can be built completely standalone. $ make clean all STATIC=1 LINK finit helpers.o: In function `getgroup': helpers.c:(.text+0x10a7): warning: Using 'getgrnam' in statically linked applications requires at runtime the shared libraries from the glibc version used for linking helpers.o: In function `getuser': helpers.c:(.text+0x108e): warning: Using 'getpwnam' in statically linked applications requires at runtime the shared libraries from the glibc version used for linking inetd.o: In function `getent': inetd.c:(.text+0x127): warning: Using 'getprotobyname' in statically linked applications requires at runtime the shared libraries from the glibc version used for linking inetd.c:(.text+0xce): warning: Using 'getservbyname' in statically linked applications requires at runtime the shared libraries from the glibc version used for linking The problem is the NSS plugins and similar issues that prevent static linking when using the above functions. See issue #5 for more on this. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2015-03-06 21:58:56 +01:00
Joachim Nilsson	5d184794b4	Fix various problems with unchecked return values from syscalls. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-11-27 00:12:07 +01:00
Joachim Nilsson	0701b688fd	libite/rsync.c: Fix build regression from previous commit. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-11-26 23:37:04 +01:00
Joachim Nilsson	e0c84e25a7	Fix problem with unchecked return value of mkdir(), wrap in makedir() macro. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-11-26 23:27:15 +01:00
Joachim Nilsson	e540ea8735	libite:rsync.c - Break out nested function. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-10-31 14:56:51 +01:00
Joachim Nilsson	949d0a020f	Bump version for release and update copyright years. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-04-21 16:03:54 +02:00
Joachim Nilsson	36d24ce366	lite.h: Add some helper string comparison methods. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-04-21 15:45:23 +02:00
Joachim Nilsson	80c2a132cd	libite: Fix cppcheck warnings in rsync unit test Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-04-12 16:34:57 +02:00
Joachim Nilsson	5eb4f640b1	libite: Minor style cleanup of fsendfile() Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-04-12 16:21:41 +02:00
Joachim Nilsson	6b64189d14	libite: Simplify and fix another memleak in copyfile() - Simplify: reduce indentation depth - Always check for error condition first, cleaner code - Make sure buffer is always freed, use same exit everyhere - Use readable, but still short, local variable names Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-04-12 16:11:59 +02:00
Joachim Nilsson	bf9d1ec012	libite: Copy utility fixes and new functionality - Add support for symlinks to copyfile() - Fix memory leak in copy_filep() - New function, fsendfile(), copy data between FILE streams Also, minor whitespace and coding style cleanup. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2014-04-12 15:08:56 +02:00
Joachim Nilsson	499f4d45d3	libite: Add strtonum() from OpenBSD Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2013-05-21 19:55:41 +02:00
Mattias Walström	cd63f8a73d	libite: Fix memory leak in dir() Signed-off-by: Mattias Walström <lazzer@gmail.com> Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2013-05-19 19:01:44 +02:00
Joachim Nilsson	ddf5ecc907	libite: Improve error handling for copyfile() and rsync() When using the simple rsync() or copyfile() functions of libite some error codes should not be interpreted as error. I.e., if a file or directory already exists when attempting to create it. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2013-05-19 18:00:31 +02:00
Mattias Walström	77971a31b2	libite: Add strlcat and strlcpy. These function only exist on uClibc and BSD, so if they not already defined in string.h, define them here.	2013-01-29 13:29:45 +01:00
Joachim Nilsson	7627b5848a	Fix incorrect use of variable arguments in run_parts() and simplify code The run_parts() implementation used variable arguments in a bad way, resulting in it not working properly. Replaced va_*() code with a simple cmd argument that's passed to each script called. Also, the opendir()/readdir() code has been replaced with scandir() using regular alphasort(). This simplifies the code somewhat as well. Otherwise, minor cleanups. Signed-off-by: Joachim Nilsson <troglobit@gmail.com>	2012-10-06 15:45:42 +02:00