initial commitorigin/gh-pagesgithub/gh-pages

55 files changed, 0 insertions, 15734 deletions

diff --git a/src/Makefile b/src/Makefile
deleted file mode 100644
index ffbf8d6e..00000000
--- a/src/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
-# Released under the 2-clause BSD license.
-
-SUBDIR=		test libeinfo librc rc
-
-ifeq (${MKTOOLS},yes)
-SUBDIR+= tools
-endif
-
-MK=		../mk
-include		${MK}/subdir.mk
diff --git a/src/includes/helpers.h b/src/includes/helpers.h
deleted file mode 100644
index 43528588..00000000
--- a/src/includes/helpers.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-  helpers.h
-  This is private to us and not for user consumption
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef __HELPERS_H__
-#define __HELPERS_H__
-
-#define ERRX fprintf (stderr, "out of memory\n"); exit (1)
-
-#define UNCONST(a)		((void *)(unsigned long)(const void *)(a))
-
-#ifdef lint
-# define _unused
-#endif
-#if __GNUC__ > 2 || defined(__INTEL_COMPILER)
-# define _dead __attribute__((__noreturn__))
-# define _unused __attribute__((__unused__))
-#else
-# define _dead
-# define _unused
-#endif
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-#ifdef __GLIBC__
-#  if ! defined (__UCLIBC__) && ! defined (__dietlibc__)
-#    define strlcpy(dst, src, size) snprintf(dst, size, "%s", src)
-#  endif
-#endif
-
-#ifndef timespecsub
-#define	timespecsub(tsp, usp, vsp)					      \
-	do {								      \
-		(vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec;		      \
-		(vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec;	      \
-		if ((vsp)->tv_nsec < 0) {				      \
-			(vsp)->tv_sec--;				      \
-			(vsp)->tv_nsec += 1000000000L;			      \
-		}							      \
-	} while (/* CONSTCOND */ 0)
-#endif
-
-_unused static void *xmalloc (size_t size)
-{
-	void *value = malloc(size);
-
-	if (value)
-		return (value);
-
-	ERRX;
-	/* NOTREACHED */
-}
-
-_unused static void *xrealloc(void *ptr, size_t size)
-{
-	void *value = realloc(ptr, size);
-
-	if (value)
-		return (value);
-
-	ERRX;
-	/* NOTREACHED */
-}
-
-_unused static char *xstrdup(const char *str)
-{
-	char *value;
-
-	if (! str)
-		return (NULL);
-
-	value = strdup(str);
-
-	if (value)
-		return (value);
-
-	ERRX;
-	/* NOTREACHED */
-}
-
-#undef ERRX
-
-/* basename_c never modifies the argument. As such, if there is a trailing
- * slash then an empty string is returned. */
-_unused static const char *basename_c(const char *path)
-{
-	const char *slash = strrchr(path, '/');
-
-	if (slash)
-		return (++slash);
-	return (path);
-}
-
-#endif
diff --git a/src/includes/hidden-visibility.h b/src/includes/hidden-visibility.h
deleted file mode 100644
index 9d397c23..00000000
--- a/src/includes/hidden-visibility.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Written by Mike Frysinger
- * Placed in the Public Domain
- */
-
-#ifndef _HIDDEN_VISIBILITY_H_
-#define _HIDDEN_VISIBILITY_H_
-
-#if defined(__ELF__) && defined(__GNUC__)
-# define __hidden_asmname(name) __hidden_asmname1 (__USER_LABEL_PREFIX__, name)
-# define __hidden_asmname1(prefix, name) __hidden_asmname2(prefix, name)
-# define __hidden_asmname2(prefix, name) #prefix name
-# define __hidden_proto(name, internal) \
-	extern __typeof (name) name __asm__ (__hidden_asmname (#internal)) \
-	__attribute__ ((visibility ("hidden")));
-# define __hidden_ver(local, internal, name) \
-   extern __typeof (name) __EI_##name __asm__(__hidden_asmname (#internal)); \
-   extern __typeof (name) __EI_##name __attribute__((alias (__hidden_asmname1 (,#local))))
-# define hidden_proto(name) __hidden_proto(name, __RC_##name)
-# define hidden_def(name) __hidden_ver(__RC_##name, name, name);
-#else
-# define hidden_proto(name)
-# define hidden_def(name)
-#endif
-
-#endif
diff --git a/src/includes/queue.h b/src/includes/queue.h
deleted file mode 100644
index 67f801d7..00000000
--- a/src/includes/queue.h
+++ /dev/null
@@ -1,846 +0,0 @@
-/*	$NetBSD: queue.h,v 1.67 2014/05/17 21:22:56 rmind 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 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.
- */
-
-/*
- * Include the definition of NULL only on NetBSD because sys/null.h
- * is not available elsewhere.  This conditional makes the header
- * portable and it can simply be dropped verbatim into any system.
- * The caveat is that on other systems some other header
- * must provide NULL before the macros can be used.
- */
-#ifdef __NetBSD__
-#include <sys/null.h>
-#endif
-
-#if defined(QUEUEDEBUG)
-# if defined(_KERNEL)
-#  define QUEUEDEBUG_ABORT(...) panic(__VA_ARGS__)
-# else
-#  include <err.h>
-#  define QUEUEDEBUG_ABORT(...) err(1, __VA_ARGS__)
-# endif
-#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)	((head)->slh_first == NULL)
-#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
-
-#define	SLIST_FOREACH(var, head, field)					\
-	for((var) = (head)->slh_first;					\
-	    (var) != SLIST_END(head);					\
-	    (var) = (var)->field.sle_next)
-
-#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = SLIST_FIRST((head));				\
-	    (var) != SLIST_END(head) &&					\
-	    ((tvar) = SLIST_NEXT((var), field), 1);			\
-	    (var) = (tvar))
-
-/*
- * Singly-linked List functions.
- */
-#define	SLIST_INIT(head) do {						\
-	(head)->slh_first = SLIST_END(head);				\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
-	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
-	(slistelm)->field.sle_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
-	(elm)->field.sle_next = (head)->slh_first;			\
-	(head)->slh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_REMOVE_AFTER(slistelm, field) do {			\
-	(slistelm)->field.sle_next =					\
-	    SLIST_NEXT(SLIST_NEXT((slistelm), field), field);		\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_REMOVE_HEAD(head, field) do {				\
-	(head)->slh_first = (head)->slh_first->field.sle_next;		\
-} while (/*CONSTCOND*/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;		\
-	}								\
-} while (/*CONSTCOND*/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)		((head)->lh_first == LIST_END(head))
-#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
-
-#define	LIST_FOREACH(var, head, field)					\
-	for ((var) = ((head)->lh_first);				\
-	    (var) != LIST_END(head);					\
-	    (var) = ((var)->field.le_next))
-
-#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = LIST_FIRST((head));				\
-	    (var) != LIST_END(head) &&					\
-	    ((tvar) = LIST_NEXT((var), field), 1);			\
-	    (var) = (tvar))
-
-#define	LIST_MOVE(head1, head2) do {					\
-	LIST_INIT((head2));						\
-	if (!LIST_EMPTY((head1))) {					\
-		(head2)->lh_first = (head1)->lh_first;			\
-		LIST_INIT((head1));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-/*
- * List functions.
- */
-#if defined(QUEUEDEBUG)
-#define	QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)			\
-	if ((head)->lh_first &&						\
-	    (head)->lh_first->field.le_prev != &(head)->lh_first)	\
-		QUEUEDEBUG_ABORT("LIST_INSERT_HEAD %p %s:%d", (head),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_LIST_OP(elm, field)					\
-	if ((elm)->field.le_next &&					\
-	    (elm)->field.le_next->field.le_prev !=			\
-	    &(elm)->field.le_next)					\
-		QUEUEDEBUG_ABORT("LIST_* forw %p %s:%d", (elm),		\
-		    __FILE__, __LINE__);				\
-	if (*(elm)->field.le_prev != (elm))				\
-		QUEUEDEBUG_ABORT("LIST_* back %p %s:%d", (elm),		\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_LIST_POSTREMOVE(elm, field)				\
-	(elm)->field.le_next = (void *)1L;				\
-	(elm)->field.le_prev = (void *)1L;
-#else
-#define	QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)
-#define	QUEUEDEBUG_LIST_OP(elm, field)
-#define	QUEUEDEBUG_LIST_POSTREMOVE(elm, field)
-#endif
-
-#define	LIST_INIT(head) do {						\
-	(head)->lh_first = LIST_END(head);				\
-} while (/*CONSTCOND*/0)
-
-#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
-	QUEUEDEBUG_LIST_OP((listelm), field)				\
-	if (((elm)->field.le_next = (listelm)->field.le_next) != 	\
-	    LIST_END(head))						\
-		(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 (/*CONSTCOND*/0)
-
-#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
-	QUEUEDEBUG_LIST_OP((listelm), field)				\
-	(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 (/*CONSTCOND*/0)
-
-#define	LIST_INSERT_HEAD(head, elm, field) do {				\
-	QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field)		\
-	if (((elm)->field.le_next = (head)->lh_first) != LIST_END(head))\
-		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
-	(head)->lh_first = (elm);					\
-	(elm)->field.le_prev = &(head)->lh_first;			\
-} while (/*CONSTCOND*/0)
-
-#define	LIST_REMOVE(elm, field) do {					\
-	QUEUEDEBUG_LIST_OP((elm), field)				\
-	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;			\
-	QUEUEDEBUG_LIST_POSTREMOVE((elm), field)			\
-} while (/*CONSTCOND*/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);				\
-	QUEUEDEBUG_LIST_POSTREMOVE((elm), field)			\
-} while (/*CONSTCOND*/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)		((head)->sqh_first == SIMPLEQ_END(head))
-#define	SIMPLEQ_NEXT(elm, field)	((elm)->field.sqe_next)
-
-#define	SIMPLEQ_FOREACH(var, head, field)				\
-	for ((var) = ((head)->sqh_first);				\
-	    (var) != SIMPLEQ_END(head);					\
-	    (var) = ((var)->field.sqe_next))
-
-#define	SIMPLEQ_FOREACH_SAFE(var, head, field, next)			\
-	for ((var) = ((head)->sqh_first);				\
-	    (var) != SIMPLEQ_END(head) &&				\
-	    ((next = ((var)->field.sqe_next)), 1);			\
-	    (var) = (next))
-
-/*
- * Simple queue functions.
- */
-#define	SIMPLEQ_INIT(head) do {						\
-	(head)->sqh_first = NULL;					\
-	(head)->sqh_last = &(head)->sqh_first;				\
-} while (/*CONSTCOND*/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 (/*CONSTCOND*/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 (/*CONSTCOND*/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 (/*CONSTCOND*/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 (/*CONSTCOND*/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 (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_REMOVE(head, elm, type, field) do {			\
-	if ((head)->sqh_first == (elm)) {				\
-		SIMPLEQ_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->sqh_first;		\
-		while (curelm->field.sqe_next != (elm))			\
-			curelm = curelm->field.sqe_next;		\
-		if ((curelm->field.sqe_next =				\
-			curelm->field.sqe_next->field.sqe_next) == NULL) \
-			    (head)->sqh_last = &(curelm)->field.sqe_next; \
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_CONCAT(head1, head2) do {				\
-	if (!SIMPLEQ_EMPTY((head2))) {					\
-		*(head1)->sqh_last = (head2)->sqh_first;		\
-		(head1)->sqh_last = (head2)->sqh_last;		\
-		SIMPLEQ_INIT((head2));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_LAST(head, type, field)					\
-	(SIMPLEQ_EMPTY((head)) ?						\
-		NULL :							\
-	        ((struct type *)(void *)				\
-		((char *)((head)->sqh_last) - offsetof(struct type, field))))
-
-/*
- * Tail queue definitions.
- */
-#define	_TAILQ_HEAD(name, type, qual)					\
-struct name {								\
-	qual type *tqh_first;		/* first element */		\
-	qual type *qual *tqh_last;	/* addr of last next element */	\
-}
-#define TAILQ_HEAD(name, type)	_TAILQ_HEAD(name, struct type,)
-
-#define	TAILQ_HEAD_INITIALIZER(head)					\
-	{ TAILQ_END(head), &(head).tqh_first }
-
-#define	_TAILQ_ENTRY(type, qual)					\
-struct {								\
-	qual type *tqe_next;		/* next element */		\
-	qual type *qual *tqe_prev;	/* address of previous next element */\
-}
-#define TAILQ_ENTRY(type)	_TAILQ_ENTRY(struct type,)
-
-/*
- * 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))
-#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) = ((head)->tqh_first);				\
-	    (var) != TAILQ_END(head);					\
-	    (var) = ((var)->field.tqe_next))
-
-#define	TAILQ_FOREACH_SAFE(var, head, field, next)			\
-	for ((var) = ((head)->tqh_first);				\
-	    (var) != TAILQ_END(head) &&					\
-	    ((next) = TAILQ_NEXT(var, field), 1); (var) = (next))
-
-#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
-	for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));\
-	    (var) != TAILQ_END(head);					\
-	    (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
-
-#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, prev)	\
-	for ((var) = TAILQ_LAST((head), headname);			\
-	    (var) != TAILQ_END(head) && 				\
-	    ((prev) = TAILQ_PREV((var), headname, field), 1); (var) = (prev))
-
-/*
- * Tail queue functions.
- */
-#if defined(QUEUEDEBUG)
-#define	QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)			\
-	if ((head)->tqh_first &&					\
-	    (head)->tqh_first->field.tqe_prev != &(head)->tqh_first)	\
-		QUEUEDEBUG_ABORT("TAILQ_INSERT_HEAD %p %s:%d", (head),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)			\
-	if (*(head)->tqh_last != NULL)					\
-		QUEUEDEBUG_ABORT("TAILQ_INSERT_TAIL %p %s:%d", (head),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_OP(elm, field)					\
-	if ((elm)->field.tqe_next &&					\
-	    (elm)->field.tqe_next->field.tqe_prev !=			\
-	    &(elm)->field.tqe_next)					\
-		QUEUEDEBUG_ABORT("TAILQ_* forw %p %s:%d", (elm),	\
-		    __FILE__, __LINE__);				\
-	if (*(elm)->field.tqe_prev != (elm))				\
-		QUEUEDEBUG_ABORT("TAILQ_* back %p %s:%d", (elm),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)			\
-	if ((elm)->field.tqe_next == NULL &&				\
-	    (head)->tqh_last != &(elm)->field.tqe_next)			\
-		QUEUEDEBUG_ABORT("TAILQ_PREREMOVE head %p elm %p %s:%d",\
-		    (head), (elm), __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)				\
-	(elm)->field.tqe_next = (void *)1L;				\
-	(elm)->field.tqe_prev = (void *)1L;
-#else
-#define	QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)
-#define	QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)
-#define	QUEUEDEBUG_TAILQ_OP(elm, field)
-#define	QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)
-#define	QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)
-#endif
-
-#define	TAILQ_INIT(head) do {						\
-	(head)->tqh_first = TAILQ_END(head);				\
-	(head)->tqh_last = &(head)->tqh_first;				\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
-	QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field)		\
-	if (((elm)->field.tqe_next = (head)->tqh_first) != TAILQ_END(head))\
-		(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 (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
-	QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field)		\
-	(elm)->field.tqe_next = TAILQ_END(head);			\
-	(elm)->field.tqe_prev = (head)->tqh_last;			\
-	*(head)->tqh_last = (elm);					\
-	(head)->tqh_last = &(elm)->field.tqe_next;			\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	QUEUEDEBUG_TAILQ_OP((listelm), field)				\
-	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != 	\
-	    TAILQ_END(head))						\
-		(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 (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
-	QUEUEDEBUG_TAILQ_OP((listelm), field)				\
-	(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 (/*CONSTCOND*/0)
-
-#define	TAILQ_REMOVE(head, elm, field) do {				\
-	QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field)		\
-	QUEUEDEBUG_TAILQ_OP((elm), field)				\
-	if (((elm)->field.tqe_next) != TAILQ_END(head))			\
-		(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;			\
-	QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);			\
-} while (/*CONSTCOND*/0)
-
-#define TAILQ_REPLACE(head, elm, elm2, field) do {                      \
-        if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != 	\
-	    TAILQ_END(head))   						\
-                (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);                               \
-	QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);			\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_CONCAT(head1, head2, field) do {				\
-	if (!TAILQ_EMPTY(head2)) {					\
-		*(head1)->tqh_last = (head2)->tqh_first;		\
-		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
-		(head1)->tqh_last = (head2)->tqh_last;			\
-		TAILQ_INIT((head2));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-/*
- * Singly-linked Tail queue declarations.
- */
-#define	STAILQ_HEAD(name, type)						\
-struct name {								\
-	struct type *stqh_first;	/* first element */		\
-	struct type **stqh_last;	/* addr of last next element */	\
-}
-
-#define	STAILQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).stqh_first }
-
-#define	STAILQ_ENTRY(type)						\
-struct {								\
-	struct type *stqe_next;	/* next element */			\
-}
-
-/*
- * Singly-linked Tail queue access methods.
- */
-#define	STAILQ_FIRST(head)	((head)->stqh_first)
-#define	STAILQ_END(head)	NULL
-#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
-#define	STAILQ_EMPTY(head)	(STAILQ_FIRST(head) == STAILQ_END(head))
-
-/*
- * Singly-linked Tail queue functions.
- */
-#define	STAILQ_INIT(head) do {						\
-	(head)->stqh_first = NULL;					\
-	(head)->stqh_last = &(head)->stqh_first;				\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)	\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(head)->stqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.stqe_next = NULL;					\
-	*(head)->stqh_last = (elm);					\
-	(head)->stqh_last = &(elm)->field.stqe_next;			\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(listelm)->field.stqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_REMOVE_HEAD(head, field) do {				\
-	if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \
-		(head)->stqh_last = &(head)->stqh_first;			\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_REMOVE(head, elm, type, field) do {			\
-	if ((head)->stqh_first == (elm)) {				\
-		STAILQ_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->stqh_first;		\
-		while (curelm->field.stqe_next != (elm))			\
-			curelm = curelm->field.stqe_next;		\
-		if ((curelm->field.stqe_next =				\
-			curelm->field.stqe_next->field.stqe_next) == NULL) \
-			    (head)->stqh_last = &(curelm)->field.stqe_next; \
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_FOREACH(var, head, field)				\
-	for ((var) = ((head)->stqh_first);				\
-		(var);							\
-		(var) = ((var)->field.stqe_next))
-
-#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = STAILQ_FIRST((head));				\
-	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	STAILQ_CONCAT(head1, head2) do {				\
-	if (!STAILQ_EMPTY((head2))) {					\
-		*(head1)->stqh_last = (head2)->stqh_first;		\
-		(head1)->stqh_last = (head2)->stqh_last;		\
-		STAILQ_INIT((head2));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_LAST(head, type, field)					\
-	(STAILQ_EMPTY((head)) ?						\
-		NULL :							\
-	        ((struct type *)(void *)				\
-		((char *)((head)->stqh_last) - offsetof(struct type, field))))
-
-
-#ifndef _KERNEL
-/*
- * Circular queue definitions. Do not use. We still keep the macros
- * for compatibility but because of pointer aliasing issues their use
- * is discouraged!
- */
-
-/*
- * __launder_type():  We use this ugly hack to work around the the compiler
- * noticing that two types may not alias each other and elide tests in code.
- * We hit this in the CIRCLEQ macros when comparing 'struct name *' and
- * 'struct type *' (see CIRCLEQ_HEAD()).  Modern compilers (such as GCC
- * 4.8) declare these comparisons as always false, causing the code to
- * not run as designed.
- *
- * This hack is only to be used for comparisons and thus can be fully const.
- * Do not use for assignment.
- *
- * If we ever choose to change the ABI of the CIRCLEQ macros, we could fix
- * this by changing the head/tail sentinal values, but see the note above
- * this one.
- */
-static __inline const void * __launder_type(const void *);
-static __inline const void *
-__launder_type(const void *__x)
-{
-	__asm __volatile("" : "+r" (__x));
-	return __x;
-}
-
-#if defined(QUEUEDEBUG)
-#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)				\
-	if ((head)->cqh_first != CIRCLEQ_ENDC(head) &&			\
-	    (head)->cqh_first->field.cqe_prev != CIRCLEQ_ENDC(head))	\
-		QUEUEDEBUG_ABORT("CIRCLEQ head forw %p %s:%d", (head),	\
-		      __FILE__, __LINE__);				\
-	if ((head)->cqh_last != CIRCLEQ_ENDC(head) &&			\
-	    (head)->cqh_last->field.cqe_next != CIRCLEQ_ENDC(head))	\
-		QUEUEDEBUG_ABORT("CIRCLEQ head back %p %s:%d", (head),	\
-		      __FILE__, __LINE__);
-#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)			\
-	if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) {		\
-		if ((head)->cqh_last != (elm))				\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm last %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	} else {							\
-		if ((elm)->field.cqe_next->field.cqe_prev != (elm))	\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm forw %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	}								\
-	if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) {		\
-		if ((head)->cqh_first != (elm))				\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm first %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	} else {							\
-		if ((elm)->field.cqe_prev->field.cqe_next != (elm))	\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm prev %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	}
-#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)			\
-	(elm)->field.cqe_next = (void *)1L;				\
-	(elm)->field.cqe_prev = (void *)1L;
-#else
-#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)
-#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)
-#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)
-#endif
-
-#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 functions.
- */
-#define	CIRCLEQ_INIT(head) do {						\
-	(head)->cqh_first = CIRCLEQ_END(head);				\
-	(head)->cqh_last = CIRCLEQ_END(head);				\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field)		\
-	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
-	(elm)->field.cqe_prev = (listelm);				\
-	if ((listelm)->field.cqe_next == CIRCLEQ_ENDC(head))		\
-		(head)->cqh_last = (elm);				\
-	else								\
-		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
-	(listelm)->field.cqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field)		\
-	(elm)->field.cqe_next = (listelm);				\
-	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
-	if ((listelm)->field.cqe_prev == CIRCLEQ_ENDC(head))		\
-		(head)->cqh_first = (elm);				\
-	else								\
-		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
-	(listelm)->field.cqe_prev = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	(elm)->field.cqe_next = (head)->cqh_first;			\
-	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
-	if ((head)->cqh_last == CIRCLEQ_ENDC(head))			\
-		(head)->cqh_last = (elm);				\
-	else								\
-		(head)->cqh_first->field.cqe_prev = (elm);		\
-	(head)->cqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
-	(elm)->field.cqe_prev = (head)->cqh_last;			\
-	if ((head)->cqh_first == CIRCLEQ_ENDC(head))			\
-		(head)->cqh_first = (elm);				\
-	else								\
-		(head)->cqh_last->field.cqe_next = (elm);		\
-	(head)->cqh_last = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	QUEUEDEBUG_CIRCLEQ_ELM((head), (elm), field)			\
-	if ((elm)->field.cqe_next == CIRCLEQ_ENDC(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_ENDC(head))		\
-		(head)->cqh_first = (elm)->field.cqe_next;		\
-	else								\
-		(elm)->field.cqe_prev->field.cqe_next =			\
-		    (elm)->field.cqe_next;				\
-	QUEUEDEBUG_CIRCLEQ_POSTREMOVE((elm), field)			\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_FOREACH(var, head, field)				\
-	for ((var) = ((head)->cqh_first);				\
-		(var) != CIRCLEQ_ENDC(head);				\
-		(var) = ((var)->field.cqe_next))
-
-#define	CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
-	for ((var) = ((head)->cqh_last);				\
-		(var) != CIRCLEQ_ENDC(head);				\
-		(var) = ((var)->field.cqe_prev))
-
-/*
- * Circular queue access methods.
- */
-#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
-#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
-/* For comparisons */
-#define	CIRCLEQ_ENDC(head)		(__launder_type(head))
-/* For assignments */
-#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_ENDC(head))
-
-#define CIRCLEQ_LOOP_NEXT(head, elm, field)				\
-	(((elm)->field.cqe_next == CIRCLEQ_ENDC(head))			\
-	    ? ((head)->cqh_first)					\
-	    : (elm->field.cqe_next))
-#define CIRCLEQ_LOOP_PREV(head, elm, field)				\
-	(((elm)->field.cqe_prev == CIRCLEQ_ENDC(head))			\
-	    ? ((head)->cqh_last)					\
-	    : (elm->field.cqe_prev))
-#endif /* !_KERNEL */
-
-#endif	/* !_SYS_QUEUE_H_ */
diff --git a/src/includes/rc-misc.h b/src/includes/rc-misc.h
deleted file mode 100644
index 3cce8d02..00000000
--- a/src/includes/rc-misc.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-  rc-misc.h
-  This is private to us and not for user consumption
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef __RC_MISC_H__
-#define __RC_MISC_H__
-
-#include <sys/stat.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "helpers.h"
-
-#define RC_LEVEL_BOOT           "boot"
-#define RC_LEVEL_DEFAULT        "default"
-
-#define RC_DEPTREE_CACHE        RC_SVCDIR "/deptree"
-#define RC_DEPTREE_SKEWED	RC_SVCDIR "/clock-skewed"
-#define RC_KRUNLEVEL            RC_SVCDIR "/krunlevel"
-#define RC_STARTING             RC_SVCDIR "/rc.starting"
-#define RC_STOPPING             RC_SVCDIR "/rc.stopping"
-
-#define RC_SVCDIR_STARTING      RC_SVCDIR "/starting"
-#define RC_SVCDIR_INACTIVE      RC_SVCDIR "/inactive"
-#define RC_SVCDIR_STARTED       RC_SVCDIR "/started"
-#define RC_SVCDIR_COLDPLUGGED	RC_SVCDIR "/coldplugged"
-
-_unused static bool exists(const char *pathname)
-{
-	struct stat buf;
-
-	return (stat(pathname, &buf) == 0);
-}
-
-_unused static bool existss(const char *pathname)
-{
-	struct stat buf;
-
-	return (stat(pathname, &buf) == 0 && buf.st_size != 0);
-}
-
-char *rc_conf_value(const char *var);
-bool rc_conf_yesno(const char *var);
-void env_filter(void);
-void env_config(void);
-int signal_setup(int sig, void (*handler)(int));
-int svc_lock(const char *);
-int svc_unlock(const char *, int);
-pid_t exec_service(const char *, const char *);
-
-/*
- * Check whether path is writable or not,
- * this also works properly with read-only filesystems
- */
-int is_writable(const char *);
-
-#define service_start(service) exec_service(service, "start");
-#define service_stop(service)  exec_service(service, "stop");
-
-int parse_mode(mode_t *, char *);
-#endif
diff --git a/src/libeinfo/.gitignore b/src/libeinfo/.gitignore
deleted file mode 100644
index 373284db..00000000
--- a/src/libeinfo/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-libeinfo.so.1
diff --git a/src/libeinfo/Makefile b/src/libeinfo/Makefile
deleted file mode 100644
index ec756b47..00000000
--- a/src/libeinfo/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-LIB=			einfo
-SHLIB_MAJOR=		1
-SRCS=			libeinfo.c
-INCS=			einfo.h
-VERSION_MAP=		einfo.map
-
-CPPFLAGS+=		-I../includes
-
-MK=			../../mk
-include ${MK}/lib.mk
-include ${MK}/cc.mk
-include ${MK}/termcap.mk
diff --git a/src/libeinfo/einfo.h b/src/libeinfo/einfo.h
deleted file mode 100644
index c0325c27..00000000
--- a/src/libeinfo/einfo.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef __EINFO_H__
-#define __EINFO_H__
-
-#if defined(__GNUC__)
-# define EINFO_PRINTF(a, b)  __attribute__((__format__(__printf__, a, b)))
-# define EINFO_XPRINTF(a, b) __attribute__((__noreturn__,__format__(__printf__, a, b)))
-#else
-# define EINFO_PRINTF(a, b)
-# define EINFO_XPRINTF(a, b)
-#endif
-
-#include <sys/types.h>
-#include <stdbool.h>
-
-/* Although OpenRC requires C99, linking to us should not. */
-#ifdef restrict
-# define EINFO_RESTRICT restrict
-#else
-# ifdef __restrict
-#  define EINFO_RESTRICT __restrict
-# else
-#  define EINFO_RESTRICT
-# endif
-#endif
-
-/* __BEGIN_DECLS */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*! @brief Color types to use */
-typedef enum
-{
-	ECOLOR_NORMAL	= 1,
-	ECOLOR_GOOD	= 2,
-	ECOLOR_WARN	= 3,
-	ECOLOR_BAD	= 4,
-	ECOLOR_HILITE	= 5,
-	ECOLOR_BRACKET	= 6
-} ECOLOR;
-
-/*! @brief Returns the ASCII code for the color */
-const char *ecolor(ECOLOR);
-
-/*! @brief Writes to syslog. */
-void elog(int, const char * EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-
-/*!
- * @brief Display informational messages.
- *
- * The einfo family of functions display messages in a consistent manner
- * across applications. Basically they prefix the message with
- * " * ". If the terminal can handle color then we color the * based on
- * the command used. Otherwise we are identical to the printf function.
- *
- * - einfo  - green
- * - ewarn  - yellow
- * - eerror - red
- *
- * The n suffix denotes that no new line should be printed.
- * The v suffix means only print if EINFO_VERBOSE is yes.
- */
-/*@{*/
-int einfon(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int ewarnn(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int eerrorn(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int einfo(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int ewarn(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-void ewarnx(const char * __EINFO_RESTRICT, ...) EINFO_XPRINTF(1, 2);
-int eerror(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-void eerrorx(const char * __EINFO_RESTRICT, ...) EINFO_XPRINTF(1, 2);
-
-int einfovn(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int ewarnvn(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int ebeginvn(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int eendvn(int, const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-int ewendvn(int, const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-int einfov(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int ewarnv(const char * __EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-/*@}*/
-
-/*! @ingroup ebegin
- * @brief Display informational messages that may take some time.
- *
- * Similar to einfo, but we add ... to the end of the message */
-/*@{*/
-int ebeginv(const char * EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-int ebegin(const char * EINFO_RESTRICT, ...) EINFO_PRINTF(1, 2);
-/*@}*/
-
-/*! @ingroup eend
- * @brief End an ebegin.
- *
- * If you ebegin, you should eend also.
- * eend places [ ok ] or [ !! ] at the end of the terminal line depending on
- * retval (0 or ok, anything else for !!)
- *
- * ebracket allows you to specifiy the position, color and message */
-/*@{*/
-int eend(int, const char * EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-int ewend(int, const char * EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-void ebracket(int, ECOLOR, const char * EINFO_RESTRICT);
-
-int eendv(int, const char * EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-int ewendv(int, const char * EINFO_RESTRICT, ...) EINFO_PRINTF(2, 3);
-/*@}*/
-
-/*! @ingroup eindent
- * @brief Indents the einfo lines.
- *
- * For each indent you should outdent when done */
-/*@{*/
-void eindent(void);
-void eoutdent(void);
-void eindentv(void);
-void eoutdentv(void);
-
-/*! @brief Prefix each einfo line with something */
-void eprefix(const char * EINFO_RESTRICT);
-
-/* __END_DECLS */
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/libeinfo/einfo.map b/src/libeinfo/einfo.map
deleted file mode 100644
index 428a8954..00000000
--- a/src/libeinfo/einfo.map
+++ /dev/null
@@ -1,35 +0,0 @@
-EINFO_1.0 {
-global:
-	ecolor;
-	elog;
-	einfon;
-	ewarnn;
-	eerrorn;
-	einfo;
-	ewarn;
-	ewarnx;
-	eerror;
-	eerrorx;
-	einfovn;
-	ewarnvn;
-	ebeginvn;
-	eendvn;
-	ewendvn;
-	einfov;
-	ewarnv;
-	ebeginv;
-	ebegin;
-	eend;
-	ewend;
-	ebracket;
-	eendv;
-	ewendv;
-	eindent;
-	eoutdent;
-	eindentv;
-	eoutdentv;
-	eprefix;
-
-local:
-	*;
-};
diff --git a/src/libeinfo/libeinfo.c b/src/libeinfo/libeinfo.c
deleted file mode 100644
index 9791051f..00000000
--- a/src/libeinfo/libeinfo.c
+++ /dev/null
@@ -1,1070 +0,0 @@
-/*
-  einfo.c
-  Informational functions
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-const char libeinfo_copyright[] = "Copyright (c) 2007-2008 Roy Marples";
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <syslog.h>
-#ifdef HAVE_TERMCAP
-# include <termcap.h>
-#endif
-#include <unistd.h>
-
-#include "einfo.h"
-#include "helpers.h"
-#include "hidden-visibility.h"
-
-hidden_proto(ecolor)
-hidden_proto(ebegin)
-hidden_proto(ebeginv)
-hidden_proto(ebracket)
-hidden_proto(eend)
-hidden_proto(eendv)
-hidden_proto(eerror)
-hidden_proto(eerrorn)
-hidden_proto(eerrorx)
-hidden_proto(eindent)
-hidden_proto(eindentv)
-hidden_proto(einfo)
-hidden_proto(einfon)
-hidden_proto(einfov)
-hidden_proto(einfovn)
-hidden_proto(elog)
-hidden_proto(eoutdent)
-hidden_proto(eoutdentv)
-hidden_proto(eprefix)
-hidden_proto(ewarn)
-hidden_proto(ewarnn)
-hidden_proto(ewarnv)
-hidden_proto(ewarnvn)
-hidden_proto(ewarnx)
-hidden_proto(ewend)
-hidden_proto(ewendv)
-
-/* Incase we cannot work out how many columns from ioctl, supply a default */
-#define DEFAULT_COLS		 80
-
-#define OK			"ok"
-#define NOT_OK			"!!"
-
-/* Number of spaces for an indent */
-#define INDENT_WIDTH		2
-
-/* How wide can the indent go? */
-#define INDENT_MAX		40
-
-/* Default colours */
-#define GOOD                    2
-#define WARN                    3
-#define BAD                     1
-#define HILITE                  6
-#define BRACKET                 4
-
-/* We fallback to these escape codes if termcap isn't available
- * like say /usr isn't mounted */
-#define AF "\033[3%dm"
-#define CE "\033[K"
-#define CH "\033[%dC"
-#define MD "\033[1m"
-#define ME "\033[m"
-#define UP "\033[A"
-
-#define _GET_CAP(_d, _c) strlcpy(_d, tgoto(_c, 0, 0), sizeof(_d));
-#define _ASSIGN_CAP(_v) do {						      \
-		_v = p;							      \
-		p += strlcpy(p, tmp, sizeof(ebuffer) - (p - ebuffer)) + 1;    \
-	} while (0)
-
-/* A pointer to a string to prefix to einfo/ewarn/eerror messages */
-static const char *_eprefix = NULL;
-
-/* Buffers and structures to hold the final colours */
-static char ebuffer[100];
-struct ecolor {
-	ECOLOR color;
-	int def;
-	const char *name;
-};
-static char nullstr = '\0';
-
-static const struct ecolor ecolors[] = {
-	{ ECOLOR_GOOD,    GOOD,    "good"    },
-	{ ECOLOR_WARN,    WARN,    "warn"    },
-	{ ECOLOR_BAD,     BAD,     "bad"     },
-	{ ECOLOR_HILITE,  HILITE,  "hilite"  },
-	{ ECOLOR_BRACKET, BRACKET, "bracket" },
-	{ ECOLOR_NORMAL,  0,       NULL      },
-};
-static const char *ecolors_str[ARRAY_SIZE(ecolors)];
-
-static char *flush = NULL;
-static char *up = NULL;
-static char *goto_column = NULL;
-
-static const char *term = NULL;
-static bool term_is_cons25 = false;
-
-/* Termcap buffers and pointers
- * Static buffers suck hard, but some termcap implementations require them */
-#ifdef HAVE_TERMCAP
-static char termcapbuf[2048];
-static char tcapbuf[512];
-#else
-/* No curses support, so we hardcode a list of colour capable terms
- * Only terminals without "color" in the name need to be explicitly listed */
-static const char *const color_terms[] = {
-	"Eterm",
-	"ansi",
-	"con132x25",
-	"con132x30",
-	"con132x43",
-	"con132x60",
-	"con80x25",
-	"con80x28",
-	"con80x30",
-	"con80x43",
-	"con80x50",
-	"con80x60",
-	"cons25",
-	"console",
-	"cygwin",
-	"dtterm",
-	"gnome",
-	"konsole",
-	"kterm",
-	"linux",
-	"linux-c",
-	"mlterm",
-	"putty",
-	"rxvt",
-	"rxvt-cygwin",
-	"rxvt-cygwin-native",
-	"rxvt-unicode",
-	"screen",
-	"screen-bce",
-	"screen-w",
-	"screen.linux",
-	"vt100",
-	"vt220",
-	"wsvt25",
-	"xterm",
-	"xterm-debian",
-	NULL
-};
-#endif
-
-/* strlcat and strlcpy are nice, shame glibc does not define them */
-#ifdef __GLIBC__
-#  if ! defined (__UCLIBC__) && ! defined (__dietlibc__)
-static size_t
-strlcat(char *dst, const char *src, size_t size)
-{
-	char *d = dst;
-	const char *s = src;
-	size_t src_n = size;
-	size_t dst_n;
-
-	while (src_n-- != 0 && *d != '\0')
-		d++;
-	dst_n = d - dst;
-	src_n = size - dst_n;
-
-	if (src_n == 0)
-		return dst_n + strlen(src);
-
-	while (*s != '\0') {
-		if (src_n != 1) {
-			*d++ = *s;
-			src_n--;
-		}
-		s++;
-	}
-	*d = '\0';
-
-	return dst_n + (s - src);
-}
-#  endif
-#endif
-
-static bool
-yesno(const char *value)
-{
-	if (!value) {
-		errno = ENOENT;
-		return false;
-	}
-
-	if (strcasecmp(value, "yes") == 0 ||
-	    strcasecmp(value, "y") == 0 ||
-	    strcasecmp(value, "true") == 0 ||
-	    strcasecmp(value, "on") == 0 ||
-	    strcasecmp(value, "1") == 0)
-		return true;
-
-	if (strcasecmp(value, "no") != 0 &&
-	    strcasecmp(value, "n") != 0 &&
-	    strcasecmp(value, "false") != 0 &&
-	    strcasecmp(value, "off") != 0 &&
-	    strcasecmp(value, "0") != 0)
-		errno = EINVAL;
-
-	return false;
-}
-
-static bool
-noyes(const char *value)
-{
-	int serrno = errno;
-	bool retval;
-
-	errno = 0;
-	retval = yesno(value);
-	if (errno == 0) {
-		retval = !retval;
-		errno = serrno;
-	}
-
-	return retval;
-}
-
-static bool
-is_quiet(void)
-{
-	return yesno(getenv("EINFO_QUIET"));
-}
-
-static bool
-is_really_quiet(void)
-{
-	return yesno(getenv("EERROR_QUIET"));
-}
-
-static bool
-is_verbose(void)
-{
-	return yesno(getenv ("EINFO_VERBOSE"));
-}
-
-/* Fake tgoto call - very crapy, but works for our needs */
-#ifndef HAVE_TERMCAP
-static char *
-tgoto(const char *cap, int col, int line)
-{
-	static char buf[20];
-	char *p, *e, c, dbuf[6];
-	int oncol = 0, which = line, i;
-
-	p = buf;
-	e = p + sizeof(buf);
-	while ((c = *cap++)) {
-		if (c != '%' || ((c = *cap++) == '%')) {
-			*p++ = c;
-			if (p >= e) {
-				errno = E2BIG;
-				return NULL;
-			}
-			continue;
-		}
-		switch (c) {
-		case '3':
-		case '2':
-		case 'd':
-			i = 0;
-			do
-				dbuf[i++] = which % 10 | '0';
-			while ((which /= 10));
-			if (c != 'd') {
-				c -= '0';
-				if (i > c) {
-					errno = EINVAL;
-					return NULL;
-				}
-				while (i < c)
-					dbuf[i++] = '0';
-			}
-			if (p + i >= e) {
-				errno = E2BIG;
-				return NULL;
-			}
-			do
-				*p++ = dbuf[--i];
-			while (i);
-			break;
-		case 'r':
-			oncol = 0;
-			break;
-		case 'i':
-			col++;
-			line++;
-			which++;
-			continue;
-		default:
-			errno = EINVAL;
-			return NULL;
-		}
-
-		oncol = 1 - oncol;
-		which = oncol ? col : line;
-	}
-	*p = '\0';
-	return buf;
-}
-#endif
-
-static bool
-colour_terminal(FILE * EINFO_RESTRICT f)
-{
-	static int in_colour = -1;
-	char *e, *ee, *end, *d, *p;
-	int c;
-	const char *_af = NULL, *_ce = NULL, *_ch = NULL;
-	const char *_md = NULL, *_me = NULL, *_up = NULL;
-	const char *bold;
-	char tmp[100];
-	unsigned int i = 0;
-#ifdef HAVE_TERMCAP
-	char *bp;
-#endif
-
-	if (f && !isatty(fileno(f)))
-		return false;
-
-	if (noyes(getenv("EINFO_COLOR")))
-		return false;
-
-	if (in_colour == 0)
-		return false;
-	if (in_colour == 1)
-		return true;
-
-	term_is_cons25 = false;
-	if (!term) {
-		term = getenv("TERM");
-		if (!term)
-			return false;
-	}
-	if (strcmp(term, "cons25") == 0)
-		term_is_cons25 = true;
-
-#ifdef HAVE_TERMCAP
-	/* Check termcap to see if we can do colour or not */
-	if (tgetent(termcapbuf, term) == 1) {
-		bp = tcapbuf;
-		_af = tgetstr("AF", &bp);
-		_ce = tgetstr("ce", &bp);
-		_ch = tgetstr("ch", &bp);
-		/* Our ch use also works with RI .... for now */
-		if (!_ch)
-			_ch = tgetstr("RI", &bp);
-		_md = tgetstr("md", &bp);
-		_me = tgetstr("me", &bp);
-		_up = tgetstr("up", &bp);
-	}
-
-	/* Cheat here as vanilla BSD has the whole termcap info in /usr
-	 * which is not available to us when we boot */
-	if (term_is_cons25 || strcmp(term, "wsvt25") == 0) {
-#else
-		if (strstr(term, "color"))
-			in_colour = 1;
-
-		while (color_terms[i] && in_colour != 1) {
-			if (strcmp(color_terms[i], term) == 0) {
-				in_colour = 1;
-			}
-			i++;
-		}
-
-		if (in_colour != 1) {
-			in_colour = 0;
-			return false;
-		}
-#endif
-		if (!_af)
-			_af = AF;
-		if (!_ce)
-			_ce = CE;
-		if (!_ch)
-			_ch = CH;
-		if (!_md)
-			_md = MD;
-		if (!_me)
-			_me = ME;
-		if (!_up)
-			_up = UP;
-#ifdef HAVE_TERMCAP
-	}
-
-	if (!_af || !_ce || !_me || !_md || !_up) {
-		in_colour = 0;
-		return false;
-	}
-
-	/* Many termcap databases don't have ch or RI even though they
-	 * do work */
-	if (!_ch)
-		_ch = CH;
-#endif
-
-	/* Now setup our colours */
-	p = ebuffer;
-	for (i = 0; i < ARRAY_SIZE(ecolors); ++i) {
-		tmp[0] = '\0';
-		if (ecolors[i].name) {
-			bold = _md;
-			c = ecolors[i].def;
-
-			/* See if the user wants to override the colour
-			 * We use a :col;bold: format like 2;1: for bold green
-			 * and 1;0: for a normal red */
-			if ((e = getenv("EINFO_COLOR"))) {
-				ee = strstr(e, ecolors[i].name);
-				if (ee)
-					ee += strlen(ecolors[i].name);
-
-				if (ee && *ee == '=') {
-					d = strdup(ee + 1);
-					if (d) {
-						end = strchr(d, ':');
-						if (end)
-							*end = '\0';
-						c = atoi(d);
-						end = strchr(d, ';');
-						if (end && *++end == '0')
-							bold = _me;
-						free(d);
-					}
-				}
-			}
-			strlcpy(tmp, tgoto(bold, 0, 0), sizeof(tmp));
-			strlcat(tmp, tgoto(_af, 0, c & 0x07), sizeof(tmp));
-		} else
-			_GET_CAP(tmp, _me);
-
-		if (tmp[0])
-			_ASSIGN_CAP(ecolors_str[i]);
-		else
-			ecolors_str[i] = &nullstr;
-	}
-
-	_GET_CAP(tmp, _ce);
-	_ASSIGN_CAP(flush);
-	_GET_CAP(tmp, _up);
-	_ASSIGN_CAP(up);
-	strlcpy(tmp, _ch, sizeof(tmp));
-	_ASSIGN_CAP(goto_column);
-
-	in_colour = 1;
-	return true;
-}
-
-static int
-get_term_columns(FILE * EINFO_RESTRICT stream)
-{
-	struct winsize ws;
-	char *env = getenv("COLUMNS");
-	char *p;
-	int i;
-
-	if (env) {
-		i = strtoimax(env, &p, 10);
-		if (!*p)
-			return i;
-	}
-
-	if (ioctl(fileno(stream), TIOCGWINSZ, &ws) == 0)
-		return ws.ws_col;
-
-	return DEFAULT_COLS;
-}
-
-void
-eprefix(const char *EINFO_RESTRICT prefix)
-{
-	_eprefix = prefix;
-}
-hidden_def(eprefix)
-
-static void EINFO_PRINTF(2, 0)
-elogv(int level, const char *EINFO_RESTRICT fmt, va_list ap)
-{
-	char *e = getenv("EINFO_LOG");
-	va_list apc;
-
-	if (fmt && e) {
-		closelog();
-		openlog(e, LOG_PID, LOG_DAEMON);
-		va_copy(apc, ap);
-		vsyslog(level, fmt, apc);
-		va_end(apc);
-		closelog();
-	}
-}
-
-void
-elog(int level, const char *EINFO_RESTRICT fmt, ...)
-{
-	va_list ap;
-
-	va_start(ap, fmt);
-	elogv(level, fmt, ap);
-	va_end(ap);
-}
-hidden_def(elog)
-
-static int
-_eindent(FILE * EINFO_RESTRICT stream)
-{
-	char *env = getenv("EINFO_INDENT");
-	int amount = 0;
-	char indent[INDENT_MAX];
-
-	if (env) {
-		errno = 0;
-		amount = strtoimax(env, NULL, 0);
-		if (errno != 0 || amount < 0)
-			amount = 0;
-		else if (amount > INDENT_MAX)
-			amount = INDENT_MAX;
-
-		if (amount > 0)
-			memset(indent, ' ', (size_t)amount);
-	}
-
-	/* Terminate it */
-	memset(indent + amount, 0, 1);
-	return fprintf(stream, "%s", indent);
-}
-
-static const char *
-_ecolor(FILE * EINFO_RESTRICT f, ECOLOR color)
-{
-	unsigned int i;
-
-	if (!colour_terminal(f))
-		return "";
-
-	for (i = 0; i < ARRAY_SIZE(ecolors); ++i)
-		if (ecolors[i].color == color)
-			return ecolors_str[i];
-	return "";
-}
-hidden_def(ecolor)
-
-const char *
-ecolor(ECOLOR color)
-{
-	FILE *f = stdout;
-
-	/* Try and guess a valid tty */
-	if (!isatty(fileno(f))) {
-		f = stderr;
-		if (!isatty(fileno(f))) {
-			f = stdin;
-			if (!isatty(fileno(f)))
-				f = NULL;
-		}
-	}
-
-	return _ecolor(f, color);
-}
-
-#define LASTCMD(_cmd) {							      \
-		unsetenv("EINFO_LASTCMD");				      \
-		setenv("EINFO_LASTCMD", _cmd, 1);			      \
-	}
-
-static int EINFO_PRINTF(3, 0)
-	_einfo(FILE *f, ECOLOR color, const char *EINFO_RESTRICT fmt, va_list va)
-{
-	int retval = 0;
-	char *last = getenv("EINFO_LASTCMD");
-	va_list ap;
-
-	if (last &&
-	    !colour_terminal(f) &&
-	    strcmp(last, "ewarn") != 0 &&
-	    last[strlen(last) - 1] == 'n')
-		fprintf(f, "\n");
-	if (_eprefix)
-		fprintf(f, "%s%s%s|", _ecolor(f, color), _eprefix, _ecolor(f, ECOLOR_NORMAL));
-	fprintf(f, " %s*%s ", _ecolor(f, color), _ecolor(f, ECOLOR_NORMAL));
-	retval += _eindent(f);
-	va_copy(ap, va);
-	retval += vfprintf(f, fmt, ap) + 3;
-	va_end(ap); \
-	if (colour_terminal(f))
-		fprintf(f, "%s", flush);
-	return retval;
-}
-
-#define _einfovn(fmt, ap) _einfo(stdout, ECOLOR_GOOD, fmt, ap)
-#define _ewarnvn(fmt, ap) _einfo(stderr, ECOLOR_WARN, fmt, ap)
-#define _eerrorvn(fmt, ap) _einfo(stderr, ECOLOR_BAD, fmt, ap)
-
-int
-einfon(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_quiet())
-		return 0;
-	va_start(ap, fmt);
-	retval = _einfovn(fmt, ap);
-	va_end(ap);
-	LASTCMD("einfon");
-	return retval;
-}
-hidden_def(einfon)
-
-int
-ewarnn(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_quiet())
-		return 0;
-	va_start(ap, fmt);
-	retval = _ewarnvn(fmt, ap);
-	va_end(ap);
-	LASTCMD("ewarnn");
-	return retval;
-}
-hidden_def(ewarnn)
-
-int
-eerrorn(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_really_quiet())
-		return 0;
-	va_start(ap, fmt);
-	retval = _eerrorvn(fmt, ap);
-	va_end(ap);
-	LASTCMD("errorn");
-	return retval;
-}
-hidden_def(eerrorn)
-
-int
-einfo(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_quiet())
-		return 0;
-	va_start(ap, fmt);
-	retval = _einfovn(fmt, ap);
-	retval += printf("\n");
-	va_end(ap);
-	LASTCMD("einfo");
-	return retval;
-}
-hidden_def(einfo)
-
-int
-ewarn(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_quiet())
-		return 0;
-	va_start(ap, fmt);
-	elogv(LOG_WARNING, fmt, ap);
-	retval = _ewarnvn(fmt, ap);
-	retval += fprintf(stderr, "\n");
-	va_end(ap);
-	LASTCMD("ewarn");
-	return retval;
-}
-hidden_def(ewarn)
-
-void
-ewarnx(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (fmt && !is_quiet()) {
-		va_start(ap, fmt);
-		elogv(LOG_WARNING, fmt, ap);
-		retval = _ewarnvn(fmt, ap);
-		va_end(ap);
-		retval += fprintf(stderr, "\n");
-	}
-	exit(EXIT_FAILURE);
-}
-hidden_def(ewarnx)
-
-int
-eerror(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_really_quiet())
-		return 0;
-	va_start(ap, fmt);
-	elogv(LOG_ERR, fmt, ap);
-	retval = _eerrorvn(fmt, ap);
-	va_end(ap);
-	retval += fprintf(stderr, "\n");
-	LASTCMD("eerror");
-	return retval;
-}
-hidden_def(eerror)
-
-void
-eerrorx(const char *EINFO_RESTRICT fmt, ...)
-{
-	va_list ap;
-
-	if (fmt && !is_really_quiet()) {
-		va_start(ap, fmt);
-		elogv(LOG_ERR, fmt, ap);
-		_eerrorvn(fmt, ap);
-		va_end(ap);
-		fprintf(stderr, "\n");
-	}
-	exit(EXIT_FAILURE);
-}
-hidden_def(eerrorx)
-
-int
-ebegin(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || is_quiet())
-		return 0;
-	va_start(ap, fmt);
-	retval = _einfovn(fmt, ap);
-	va_end(ap);
-	retval += printf(" ...");
-	if (colour_terminal(stdout))
-		retval += printf("\n");
-	LASTCMD("ebegin");
-	return retval;
-}
-hidden_def(ebegin)
-
-static void
-_eend(FILE * EINFO_RESTRICT fp, int col, ECOLOR color, const char *msg)
-{
-	int i;
-	int cols;
-
-	if (!msg)
-		return;
-
-	cols = get_term_columns(fp) - (strlen(msg) + 5);
-
-	/* cons25 is special - we need to remove one char, otherwise things
-	 * do not align properly at all. */
-	if (!term) {
-		term = getenv("TERM");
-		if (term && strcmp(term, "cons25") == 0)
-			term_is_cons25 = true;
-		else
-			term_is_cons25 = false;
-	}
-	if (term_is_cons25)
-		cols--;
-
-	if (cols > 0 && colour_terminal(fp)) {
-		fprintf(fp, "%s%s %s[%s %s %s]%s\n", up, tgoto(goto_column, 0, cols),
-		    ecolor(ECOLOR_BRACKET), ecolor(color), msg,
-		    ecolor(ECOLOR_BRACKET), ecolor(ECOLOR_NORMAL));
-	} else {
-		if (col > 0)
-			for (i = 0; i < cols - col; i++)
-				fprintf(fp, " ");
-		fprintf(fp, " [ %s ]\n", msg);
-	}
-}
-
-static int EINFO_PRINTF(3, 0)
-_do_eend(const char *cmd, int retval,
-    const char *EINFO_RESTRICT fmt, va_list ap)
-{
-	int col = 0;
-	FILE *fp = stdout;
-	va_list apc;
-
-	if (fmt && *fmt != '\0' && retval != 0) {
-		fp = stderr;
-		va_copy(apc, ap);
-		if (strcmp(cmd, "ewend") == 0)
-			col = _ewarnvn(fmt, apc);
-		else
-			col = _eerrorvn(fmt, apc);
-		col += fprintf(fp, "\n");
-		va_end(apc);
-	}
-	_eend(fp, col,
-	    retval == 0 ? ECOLOR_GOOD : ECOLOR_BAD,
-	    retval == 0 ? OK : NOT_OK);
-	return retval;
-}
-
-int
-eend(int retval, const char *EINFO_RESTRICT fmt, ...)
-{
-	va_list ap;
-
-	if (is_quiet())
-		return retval;
-	va_start(ap, fmt);
-	_do_eend("eend", retval, fmt, ap);
-	va_end(ap);
-	LASTCMD("eend");
-	return retval;
-}
-hidden_def(eend)
-
-int
-ewend(int retval, const char *EINFO_RESTRICT fmt, ...)
-{
-	va_list ap;
-
-	if (is_quiet())
-		return retval;
-	va_start(ap, fmt);
-	_do_eend("ewend", retval, fmt, ap);
-	va_end(ap);
-	LASTCMD("ewend");
-	return retval;
-}
-hidden_def(ewend)
-
-void
-ebracket(int col, ECOLOR color, const char *msg)
-{
-	_eend(stdout, col, color, msg);
-}
-hidden_def(ebracket)
-
-void
-eindent(void)
-{
-	char *env = getenv("EINFO_INDENT");
-	int amount = 0;
-	char num[10];
-
-	if (env) {
-		errno = 0;
-		amount = strtoimax(env, NULL, 0);
-		if (errno != 0)
-			amount = 0;
-	}
-	amount += INDENT_WIDTH;
-	if (amount > INDENT_MAX)
-		amount = INDENT_MAX;
-	snprintf(num, 10, "%08d", amount);
-	setenv("EINFO_INDENT", num, 1);
-}
-hidden_def(eindent)
-
-void eoutdent(void)
-{
-	char *env = getenv("EINFO_INDENT");
-	int amount = 0;
-	char num[10];
-	int serrno = errno;
-
-	if (!env)
-		return;
-	errno = 0;
-	amount = strtoimax(env, NULL, 0);
-	if (errno != 0)
-		amount = 0;
-	else
-		amount -= INDENT_WIDTH;
-	if (amount <= 0)
-		unsetenv("EINFO_INDENT");
-	else {
-		snprintf(num, 10, "%08d", amount);
-		setenv("EINFO_INDENT", num, 1);
-	}
-	errno = serrno;
-}
-hidden_def(eoutdent)
-
-int
-einfovn(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || !is_verbose())
-		return 0;
-	va_start(ap, fmt);
-	retval = _einfovn(fmt, ap);
-	va_end(ap);
-	LASTCMD("einfovn");
-	return retval;
-}
-hidden_def(einfovn)
-
-int
-ewarnvn(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || !is_verbose())
-		return 0;
-	va_start(ap, fmt);
-	retval = _ewarnvn(fmt, ap);
-	va_end(ap);
-	LASTCMD("ewarnvn");
-	return retval;
-}
-hidden_def(ewarnvn)
-
-int
-einfov(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || !is_verbose())
-		return 0;
-	va_start(ap, fmt);
-	retval = _einfovn(fmt, ap);
-	retval += printf("\n");
-	va_end(ap);
-	LASTCMD("einfov");
-	return retval;
-}
-hidden_def(einfov)
-
-int
-ewarnv(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || !is_verbose())
-		return 0;
-	va_start(ap, fmt);
-	retval = _ewarnvn(fmt, ap);
-	retval += printf("\n");
-	va_end(ap);
-	LASTCMD("ewarnv");
-	return retval;
-}
-hidden_def(ewarnv)
-
-int
-ebeginv(const char *EINFO_RESTRICT fmt, ...)
-{
-	int retval;
-	va_list ap;
-
-	if (!fmt || !is_verbose())
-		return 0;
-
-	va_start(ap, fmt);
-	retval = _einfovn(fmt, ap);
-	retval += printf(" ...");
-	if (colour_terminal(stdout))
-		retval += printf("\n");
-	va_end(ap);
-	LASTCMD("ebeginv");
-	return retval;
-}
-hidden_def(ebeginv)
-
-int
-eendv(int retval, const char *EINFO_RESTRICT fmt, ...)
-{
-	va_list ap;
-
-	if (!is_verbose())
-		return 0;
-	va_start(ap, fmt);
-	_do_eend("eendv", retval, fmt, ap);
-	va_end(ap);
-	LASTCMD("eendv");
-	return retval;
-}
-hidden_def(eendv)
-
-int
-ewendv(int retval, const char *EINFO_RESTRICT fmt, ...)
-{
-	va_list ap;
-
-	if (!is_verbose())
-		return 0;
-	va_start(ap, fmt);
-	_do_eend("ewendv", retval, fmt, ap);
-	va_end(ap);
-	LASTCMD("ewendv");
-	return retval;
-}
-hidden_def(ewendv)
-
-void
-eindentv(void)
-{
-	if (is_verbose())
-		eindent();
-}
-hidden_def(eindentv)
-
-void
-eoutdentv(void)
-{
-	if (is_verbose())
-		eoutdent();
-}
-hidden_def(eoutdentv)
diff --git a/src/librc/.gitignore b/src/librc/.gitignore
deleted file mode 100644
index e7fafe8c..00000000
--- a/src/librc/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-librc.so.1
-rc.h
diff --git a/src/librc/Makefile b/src/librc/Makefile
deleted file mode 100644
index 73075608..00000000
--- a/src/librc/Makefile
+++ /dev/null
@@ -1,48 +0,0 @@
-LIB=		rc
-SHLIB_MAJOR=	1
-SRCS=		librc.c librc-daemon.c librc-depend.c librc-misc.c \
-		librc-stringlist.c
-INCS=		rc.h
-VERSION_MAP=	rc.map
-
-LDADD+=		${LIBKVM}
-
-CPPFLAGS+=	-I../includes
-
-MK=		../../mk
-include ${MK}/lib.mk
-include ${MK}/cc.mk
-
-# Massage our header file for our dirs
-SED_CMD=	-e 's:@PREFIX@:${PREFIX}:g'
-SED_CMD+=	-e 's:@LIB@:${LIBNAME}:g'
-SED_CMD+=	-e 's:@SYSCONFDIR@:${SYSCONFDIR}:g'
-SED_CMD+=	-e 's:@LIBEXECDIR@:${LIBEXECDIR}:g'
-SED_CMD+=	-e 's:@BINDIR@:${BINDIR}:g'
-SED_CMD+=	-e 's:@SBINDIR@:${SBINDIR}:g'
-
-_PKG_PREFIX=	-e 's:.*@PKG_PREFIX@.*:\#undef RC_PKG_PREFIX:g'
-ifneq (${PKG_PREFIX},)
-ifneq (${PKG_PREFIX},/)
-ifneq (${PKG_PREFIX},${PREFIX})
-_PKG_PREFIX=	-e 's:@PKG_PREFIX@:${PKG_PREFIX}:g'
-endif
-endif
-endif
-SED_CMD+=	${_PKG_PREFIX}
-
-_LCL_PREFIX=	-e 's:@LOCAL_PREFIX@::g'
-ifneq (${LOCAL_PREFIX},)
-ifneq (${LOCAL_PREFIX},/)
-ifneq (${LOCAL_PREFIX},${PREFIX})
-_LCL_PREFIX=	-e 's:@LOCAL_PREFIX@:${LOCAL_PREFIX}:g'
-endif
-endif
-endif
-SED_CMD+=	${_LCL_PREFIX}
-
-%.h: %.h.in
-	${SED} ${SED_CMD} $< > $@
-${SRCS}:	rc.h
-
-CLEANFILES+=	rc.h
diff --git a/src/librc/librc-daemon.c b/src/librc/librc-daemon.c
deleted file mode 100644
index 02aff5a9..00000000
--- a/src/librc/librc-daemon.c
+++ /dev/null
@@ -1,645 +0,0 @@
-/*
-  librc-daemon
-  Finds PID for given daemon criteria
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 "queue.h"
-#include "librc.h"
-
-#if defined(__linux__) || (defined (__FreeBSD_kernel__) && defined(__GLIBC__))
-static bool
-pid_is_exec(pid_t pid, const char *exec)
-{
-	char buffer[32];
-	FILE *fp;
-	int c;
-	bool retval = false;
-
-	exec = basename_c(exec);
-	snprintf(buffer, sizeof(buffer), "/proc/%d/stat", pid);
-	if ((fp = fopen(buffer, "r"))) {
-		while ((c = getc(fp)) != EOF && c != '(')
-			;
-		if (c == '(') {
-			while ((c = getc(fp)) != EOF && c == *exec)
-				exec++;
-			if (c == ')' && *exec == '\0')
-				retval = true;
-		}
-		fclose(fp);
-	}
-	return retval;
-}
-
-static bool
-pid_is_argv(pid_t pid, const char *const *argv)
-{
-	char cmdline[32];
-	int fd;
-	char buffer[PATH_MAX];
-	char *p;
-	ssize_t bytes;
-
-	snprintf(cmdline, sizeof(cmdline), "/proc/%u/cmdline", pid);
-	if ((fd = open(cmdline, O_RDONLY)) < 0)
-		return false;
-	bytes = read(fd, buffer, sizeof(buffer));
-	close(fd);
-	if (bytes == -1)
-		return false;
-
-	buffer[bytes] = '\0';
-	p = buffer;
-	while (*argv) {
-		if (strcmp(*argv, p) != 0)
-			return false;
-		argv++;
-		p += strlen(p) + 1;
-		if ((unsigned)(p - buffer) > sizeof(buffer))
-			return false;
-	}
-	return true;
-}
-
-RC_PIDLIST *
-rc_find_pids(const char *exec, const char *const *argv, uid_t uid, pid_t pid)
-{
-	DIR *procdir;
-	struct dirent *entry;
-	FILE *fp;
-	bool container_pid = false;
-	bool openvz_host = false;
-	char *line = NULL;
-	size_t len = 0;
-	pid_t p;
-	char buffer[PATH_MAX];
-	struct stat sb;
-	pid_t runscript_pid = 0;
-	char *pp;
-	RC_PIDLIST *pids = NULL;
-	RC_PID *pi;
-
-	if ((procdir = opendir("/proc")) == NULL)
-		return NULL;
-
-	/*
-	  We never match RC_RUNSCRIPT_PID if present so we avoid the below
-	  scenario
-
-	  /etc/init.d/ntpd stop does
-	  start-stop-daemon --stop --name ntpd
-	  catching /etc/init.d/ntpd stop
-
-	  nasty
-	*/
-
-	if ((pp = getenv("RC_RUNSCRIPT_PID"))) {
-		if (sscanf(pp, "%d", &runscript_pid) != 1)
-			runscript_pid = 0;
-	}
-
-	/*
-	If /proc/self/status contains EnvID: 0, then we are an OpenVZ host,
-	and we will need to filter out processes that are inside containers
-	from our list of pids.
-	*/
-
-	if (exists("/proc/self/status")) {
-		fp = fopen("/proc/self/status", "r");
-		if (fp) {
-			while (! feof(fp)) {
-				rc_getline(&line, &len, fp);
-				if (strncmp(line, "envID:\t0", 8) == 0) {
-					openvz_host = true;
-					break;
-				}
-			}
-			fclose(fp);
-		}
-	}
-
-	while ((entry = readdir(procdir)) != NULL) {
-		if (sscanf(entry->d_name, "%d", &p) != 1)
-			continue;
-		if (runscript_pid != 0 && runscript_pid == p)
-			continue;
-		if (pid != 0 && pid != p)
-			continue;
-		if (uid) {
-			snprintf(buffer, sizeof(buffer), "/proc/%d", p);
-			if (stat(buffer, &sb) != 0 || sb.st_uid != uid)
-				continue;
-		}
-		if (exec && !pid_is_exec(p, exec))
-			continue;
-		if (argv &&
-		    !pid_is_argv(p, (const char *const *)argv))
-			continue;
-		/* If this is an OpenVZ host, filter out container processes */
-		if (openvz_host) {
-			snprintf(buffer, sizeof(buffer), "/proc/%d/status", p);
-			if (exists(buffer)) {
-				fp = fopen(buffer, "r");
-				if (! fp)
-					continue;
-				while (! feof(fp)) {
-					rc_getline(&line, &len, fp);
-					if (strncmp(line, "envID:", 6) == 0) {
-						container_pid = ! (strncmp(line, "envID:\t0", 8) == 0);
-						break;
-					}
-				}
-				fclose(fp);
-			}
-		}
-		if (container_pid)
-			continue;
-		if (!pids) {
-			pids = xmalloc(sizeof(*pids));
-			LIST_INIT(pids);
-		}
-		pi = xmalloc(sizeof(*pi));
-		pi->pid = p;
-		LIST_INSERT_HEAD(pids, pi, entries);
-	}
-	if (line != NULL)
-		free(line);
-	closedir(procdir);
-	return pids;
-}
-librc_hidden_def(rc_find_pids)
-
-#elif BSD
-
-# if defined(__NetBSD__) || defined(__OpenBSD__)
-#  define _KVM_GETPROC2
-#  define _KINFO_PROC kinfo_proc2
-#  define _KVM_GETARGV kvm_getargv2
-#  define _GET_KINFO_UID(kp) (kp.p_ruid)
-#  define _GET_KINFO_COMM(kp) (kp.p_comm)
-#  define _GET_KINFO_PID(kp) (kp.p_pid)
-#  define _KVM_PATH NULL
-#  define _KVM_FLAGS KVM_NO_FILES
-# else
-#  ifndef KERN_PROC_PROC
-#    define KERN_PROC_PROC KERN_PROC_ALL
-#  endif
-#  define _KINFO_PROC kinfo_proc
-#  define _KVM_GETARGV kvm_getargv
-#  if defined(__DragonFly__)
-#    define _GET_KINFO_UID(kp) (kp.kp_ruid)
-#    define _GET_KINFO_COMM(kp) (kp.kp_comm)
-#    define _GET_KINFO_PID(kp) (kp.kp_pid)
-#  else
-#    define _GET_KINFO_UID(kp) (kp.ki_ruid)
-#    define _GET_KINFO_COMM(kp) (kp.ki_comm)
-#    define _GET_KINFO_PID(kp) (kp.ki_pid)
-#  endif
-#  define _KVM_PATH _PATH_DEVNULL
-#  define _KVM_FLAGS O_RDONLY
-# endif
-
-RC_PIDLIST *
-rc_find_pids(const char *exec, const char *const *argv, uid_t uid, pid_t pid)
-{
-	static kvm_t *kd = NULL;
-	char errbuf[_POSIX2_LINE_MAX];
-	struct _KINFO_PROC *kp;
-	int i;
-	int processes = 0;
-	int pargc = 0;
-	char **pargv;
-	RC_PIDLIST *pids = NULL;
-	RC_PID *pi;
-	pid_t p;
-	const char *const *arg;
-	int match;
-
-	if ((kd = kvm_openfiles(_KVM_PATH, _KVM_PATH,
-		    NULL, _KVM_FLAGS, errbuf)) == NULL)
-	{
-		fprintf(stderr, "kvm_open: %s\n", errbuf);
-		return NULL;
-	}
-
-#ifdef _KVM_GETPROC2
-	kp = kvm_getproc2(kd, KERN_PROC_ALL, 0, sizeof(*kp), &processes);
-#else
-	kp = kvm_getprocs(kd, KERN_PROC_PROC, 0, &processes);
-#endif
-	if ((kp == NULL && processes > 0) || (kp != NULL && processes < 0)) {
-		fprintf(stderr, "kvm_getprocs: %s\n", kvm_geterr(kd));
-		kvm_close(kd);
-		return NULL;
-	}
-
-	if (exec)
-		exec = basename_c(exec);
-	for (i = 0; i < processes; i++) {
-		p = _GET_KINFO_PID(kp[i]);
-		if (pid != 0 && pid != p)
-			continue;
-		if (uid != 0 && uid != _GET_KINFO_UID(kp[i]))
-			continue;
-		if (exec) {
-			if (!_GET_KINFO_COMM(kp[i]) ||
-			    strcmp(exec, _GET_KINFO_COMM(kp[i])) != 0)
-				continue;
-		}
-		if (argv && *argv) {
-			pargv = _KVM_GETARGV(kd, &kp[i], pargc);
-			if (!pargv || !*pargv)
-				continue;
-			arg = argv;
-			match = 1;
-			while (*arg && *pargv)
-				if (strcmp(*arg++, *pargv++) != 0) {
-					match = 0;
-					break;
-				}
-			if (!match)
-				continue;
-		}
-		if (!pids) {
-			pids = xmalloc(sizeof(*pids));
-			LIST_INIT(pids);
-		}
-		pi = xmalloc(sizeof(*pi));
-		pi->pid = p;
-		LIST_INSERT_HEAD(pids, pi, entries);
-	}
-	kvm_close(kd);
-
-	return pids;
-}
-librc_hidden_def(rc_find_pids)
-
-#else
-#  error "Platform not supported!"
-#endif
-
-static bool
-_match_daemon(const char *path, const char *file, RC_STRINGLIST *match)
-{
-	char *line = NULL;
-	size_t len = 0;
-	char ffile[PATH_MAX];
-	FILE *fp;
-	RC_STRING *m;
-
-	snprintf(ffile, sizeof(ffile), "%s/%s", path, file);
-	fp = fopen(ffile, "r");
-
-	if (!fp)
-		return false;
-
-	while ((rc_getline(&line, &len, fp))) {
-		TAILQ_FOREACH(m, match, entries)
-		    if (strcmp(line, m->value) == 0) {
-			    TAILQ_REMOVE(match, m, entries);
-			    break;
-		    }
-		if (!TAILQ_FIRST(match))
-			break;
-	}
-	fclose(fp);
-	free(line);
-	if (TAILQ_FIRST(match))
-		return false;
-	return true;
-}
-
-static RC_STRINGLIST *
-_match_list(const char *exec, const char *const *argv, const char *pidfile)
-{
-	RC_STRINGLIST *match = rc_stringlist_new();
-	int i = 0;
-	size_t l;
-	char *m;
-
-	if (exec) {
-		l = strlen(exec) + 6;
-		m = xmalloc(sizeof(char) * l);
-		snprintf(m, l, "exec=%s", exec);
-		rc_stringlist_add(match, m);
-		free(m);
-	}
-
-	while (argv && argv[i]) {
-		l = strlen(*argv) + strlen("argv_=") + 16;
-		m = xmalloc(sizeof(char) * l);
-		snprintf(m, l, "argv_0=%s", argv[i++]);
-		rc_stringlist_add(match, m);
-		free(m);
-	}
-
-	if (pidfile) {
-		l = strlen(pidfile) + 9;
-		m = xmalloc(sizeof(char) * l);
-		snprintf(m, l, "pidfile=%s", pidfile);
-		rc_stringlist_add(match, m);
-		free(m);
-	}
-
-	return match;
-}
-
-bool
-rc_service_daemon_set(const char *service, const char *exec,
-    const char *const *argv,
-    const char *pidfile, bool started)
-{
-	char dirpath[PATH_MAX];
-	char file[PATH_MAX];
-	int nfiles = 0;
-	char oldfile[PATH_MAX] = { '\0' };
-	bool retval = false;
-	DIR *dp;
-	struct dirent *d;
-	RC_STRINGLIST *match;
-	int i = 0;
-	FILE *fp;
-
-	if (!exec && !pidfile) {
-		errno = EINVAL;
-		return false;
-	}
-
-	snprintf(dirpath, sizeof(dirpath), RC_SVCDIR "/daemons/%s",
-	    basename_c(service));
-
-	/* Regardless, erase any existing daemon info */
-	if ((dp = opendir(dirpath))) {
-		match = _match_list(exec, argv, pidfile);
-		while ((d = readdir(dp))) {
-			if (d->d_name[0] == '.')
-				continue;
-
-			snprintf(file, sizeof(file), "%s/%s",
-			    dirpath, d->d_name);
-			nfiles++;
-
-			if (!*oldfile) {
-				if (_match_daemon(dirpath, d->d_name, match)) {
-					unlink(file);
-					strlcpy(oldfile, file, sizeof(oldfile));
-					nfiles--;
-				}
-			} else {
-				rename(file, oldfile);
-				strlcpy(oldfile, file, sizeof(oldfile));
-			}
-		}
-		closedir(dp);
-		rc_stringlist_free(match);
-	}
-
-	/* Now store our daemon info */
-	if (started) {
-		if (mkdir(dirpath, 0755) == 0 || errno == EEXIST) {
-			snprintf(file, sizeof(file), "%s/%03d",
-			    dirpath, nfiles + 1);
-			if ((fp = fopen(file, "w"))) {
-				fprintf(fp, "exec=");
-				if (exec)
-					fprintf(fp, "%s", exec);
-				while (argv && argv[i]) {
-					fprintf(fp, "\nargv_%d=%s", i, argv[i]);
-					i++;
-				}
-				fprintf(fp, "\npidfile=");
-				if (pidfile)
-					fprintf(fp, "%s", pidfile);
-				fprintf(fp, "\n");
-				fclose(fp);
-				retval = true;
-			}
-		}
-	} else
-		retval = true;
-
-	return retval;
-}
-librc_hidden_def(rc_service_daemon_set)
-
-bool
-rc_service_started_daemon(const char *service,
-    const char *exec, const char *const *argv, int indx)
-{
-	char dirpath[PATH_MAX];
-	char file[16];
-	RC_STRINGLIST *match;
-	bool retval = false;
-	DIR *dp;
-	struct dirent *d;
-
-	if (!service || !exec)
-		return false;
-
-	snprintf(dirpath, sizeof(dirpath), RC_SVCDIR "/daemons/%s",
-	    basename_c(service));
-	match = _match_list(exec, argv, NULL);
-
-	if (indx > 0) {
-		snprintf(file, sizeof(file), "%03d", indx);
-		retval = _match_daemon(dirpath, file, match);
-	} else {
-		if ((dp = opendir(dirpath))) {
-			while ((d = readdir(dp))) {
-				if (d->d_name[0] == '.')
-					continue;
-				retval = _match_daemon(dirpath, d->d_name, match);
-				if (retval)
-					break;
-			}
-			closedir(dp);
-		}
-	}
-
-	rc_stringlist_free(match);
-	return retval;
-}
-librc_hidden_def(rc_service_started_daemon)
-
-bool
-rc_service_daemons_crashed(const char *service)
-{
-	char dirpath[PATH_MAX];
-	DIR *dp;
-	struct dirent *d;
-	char *path = dirpath;
-	FILE *fp;
-	char *line = NULL;
-	size_t len = 0;
-	char **argv = NULL;
-	char *exec = NULL;
-	char *name = NULL;
-	char *pidfile = NULL;
-	pid_t pid = 0;
-	RC_PIDLIST *pids;
-	RC_PID *p1;
-	RC_PID *p2;
-	char *p;
-	char *token;
-	bool retval = false;
-	RC_STRINGLIST *list = NULL;
-	RC_STRING *s;
-	size_t i;
-
-	path += snprintf(dirpath, sizeof(dirpath), RC_SVCDIR "/daemons/%s",
-	    basename_c(service));
-
-	if (!(dp = opendir(dirpath)))
-		return false;
-
-	while ((d = readdir(dp))) {
-		if (d->d_name[0] == '.')
-			continue;
-
-		snprintf(path, sizeof(dirpath) - (path - dirpath), "/%s",
-		    d->d_name);
-		fp = fopen(dirpath, "r");
-		if (!fp)
-			break;
-
-		while ((rc_getline(&line, &len, fp))) {
-			p = line;
-			if ((token = strsep(&p, "=")) == NULL || !p)
-				continue;
-
-			if (!*p)
-				continue;
-
-			if (strcmp(token, "exec") == 0) {
-				if (exec)
-					free(exec);
-				exec = xstrdup(p);
-			} else if (strncmp(token, "argv_", 5) == 0) {
-				if (!list)
-					list = rc_stringlist_new();
-				rc_stringlist_add(list, p);
-			} else if (strcmp(token, "name") == 0) {
-				if (name)
-					free(name);
-				name = xstrdup(p);
-			} else if (strcmp(token, "pidfile") == 0) {
-				pidfile = xstrdup(p);
-				break;
-			}
-		}
-		fclose(fp);
-
-		char *ch_root = rc_service_value_get(basename_c(service), "chroot");
-		char *spidfile = pidfile;
-		if (ch_root && pidfile) {
-			spidfile = xmalloc(strlen(ch_root) + strlen(pidfile) + 1);
-			strcpy(spidfile, ch_root);
-			strcat(spidfile, pidfile);
-		}
-
-		pid = 0;
-		if (spidfile) {
-			retval = true;
-			if ((fp = fopen(spidfile, "r"))) {
-				if (fscanf(fp, "%d", &pid) == 1)
-					retval = false;
-				fclose(fp);
-			}
-			free(spidfile);
-			spidfile = NULL;
-			if (ch_root) {
-				free(pidfile);
-				pidfile = NULL;
-			}
-
-			/* We have the pid, so no need to match
-			   on exec or name */
-			free(exec);
-			exec = NULL;
-			free(name);
-			name = NULL;
-		} else {
-			if (exec) {
-				if (!list)
-					list = rc_stringlist_new();
-				if (!TAILQ_FIRST(list))
-					rc_stringlist_add(list, exec);
-
-				free(exec);
-				exec = NULL;
-			}
-
-			if (list) {
-				/* We need to flatten our linked list
-				   into an array */
-				i = 0;
-				TAILQ_FOREACH(s, list, entries)
-				    i++;
-				argv = xmalloc(sizeof(char *) * (i + 1));
-				i = 0;
-				TAILQ_FOREACH(s, list, entries)
-				    argv[i++] = s->value;
-				argv[i] = '\0';
-			}
-		}
-
-		if (!retval) {
-			if (pid != 0) {
-				if (kill(pid, 0) == -1 && errno == ESRCH)
-					retval = true;
-			} else if ((pids = rc_find_pids(exec,
-				    (const char *const *)argv,
-				    0, pid)))
-			{
-				p1 = LIST_FIRST(pids);
-				while (p1) {
-					p2 = LIST_NEXT(p1, entries);
-					free(p1);
-					p1 = p2;
-				}
-				free(pids);
-			} else
-				retval = true;
-		}
-		rc_stringlist_free(list);
-		list = NULL;
-		free(argv);
-		argv = NULL;
-		free(exec);
-		exec = NULL;
-		free(name);
-		name = NULL;
-		if (retval)
-			break;
-	}
-	closedir(dp);
-	free(line);
-
-	return retval;
-}
-librc_hidden_def(rc_service_daemons_crashed)
diff --git a/src/librc/librc-depend.c b/src/librc/librc-depend.c
deleted file mode 100644
index d7a8ae14..00000000
--- a/src/librc/librc-depend.c
+++ /dev/null
@@ -1,1054 +0,0 @@
-/*
-   librc-depend
-   rc service dependency and ordering
-   */
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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/utsname.h>
-
-#include "queue.h"
-#include "librc.h"
-
-#define GENDEP          RC_LIBEXECDIR "/sh/gendepends.sh"
-
-#define RC_DEPCONFIG    RC_SVCDIR "/depconfig"
-
-static const char *bootlevel = NULL;
-
-static char *
-get_shell_value(char *string)
-{
-	char *p = string;
-	char *e;
-
-	if (! string)
-		return NULL;
-
-	if (*p == '\'')
-		p++;
-
-	e = p + strlen(p) - 1;
-	if (*e == '\n')
-		*e-- = 0;
-	if (*e == '\'')
-		*e-- = 0;
-
-	if (*p != 0)
-		return p;
-
-	return NULL;
-}
-
-void
-rc_deptree_free(RC_DEPTREE *deptree)
-{
-	RC_DEPINFO *di;
-	RC_DEPINFO *di2;
-	RC_DEPTYPE *dt;
-	RC_DEPTYPE *dt2;
-
-	if (!deptree)
-		return;
-
-	di = TAILQ_FIRST(deptree);
-	while (di) {
-		di2 = TAILQ_NEXT(di, entries);
-		dt = TAILQ_FIRST(&di->depends);
-		while (dt) {
-			dt2 = TAILQ_NEXT(dt, entries);
-			rc_stringlist_free(dt->services);
-			free(dt->type);
-			free(dt);
-			dt = dt2;
-		}
-		free(di->service);
-		free(di);
-		di = di2;
-	}
-	free(deptree);
-}
-librc_hidden_def(rc_deptree_free)
-
-static RC_DEPINFO *
-get_depinfo(const RC_DEPTREE *deptree, const char *service)
-{
-	RC_DEPINFO *di;
-
-	TAILQ_FOREACH(di, deptree, entries)
-		if (strcmp(di->service, service) == 0)
-			return di;
-	return NULL;
-}
-
-static RC_DEPTYPE *
-get_deptype(const RC_DEPINFO *depinfo, const char *type)
-{
-	RC_DEPTYPE *dt;
-
-	TAILQ_FOREACH(dt, &depinfo->depends, entries)
-		if (strcmp(dt->type, type) == 0)
-			return dt;
-	return NULL;
-}
-
-RC_DEPTREE *
-rc_deptree_load(void) {
-	return rc_deptree_load_file(RC_DEPTREE_CACHE);
-}
-librc_hidden_def(rc_deptree_load)
-
-RC_DEPTREE *
-rc_deptree_load_file(const char *deptree_file)
-{
-	FILE *fp;
-	RC_DEPTREE *deptree;
-	RC_DEPINFO *depinfo = NULL;
-	RC_DEPTYPE *deptype = NULL;
-	char *line = NULL;
-	size_t len = 0;
-	char *type;
-	char *p;
-	char *e;
-	int i;
-
-	if (!(fp = fopen(deptree_file, "r")))
-		return NULL;
-
-	deptree = xmalloc(sizeof(*deptree));
-	TAILQ_INIT(deptree);
-	while ((rc_getline(&line, &len, fp)))
-	{
-		p = line;
-		e = strsep(&p, "_");
-		if (!e || strcmp(e, "depinfo") != 0)
-			continue;
-		e = strsep(&p, "_");
-		if (!e || sscanf(e, "%d", &i) != 1)
-			continue;
-		if (!(type = strsep(&p, "_=")))
-			continue;
-		if (strcmp(type, "service") == 0) {
-			/* Sanity */
-			e = get_shell_value(p);
-			if (! e || *e == '\0')
-				continue;
-			depinfo = xmalloc(sizeof(*depinfo));
-			TAILQ_INIT(&depinfo->depends);
-			depinfo->service = xstrdup(e);
-			TAILQ_INSERT_TAIL(deptree, depinfo, entries);
-			deptype = NULL;
-			continue;
-		}
-		e = strsep(&p, "=");
-		if (!e || sscanf(e, "%d", &i) != 1)
-			continue;
-		/* Sanity */
-		e = get_shell_value(p);
-		if (!e || *e == '\0')
-			continue;
-		if (!deptype || strcmp(deptype->type, type) != 0) {
-			deptype = xmalloc(sizeof(*deptype));
-			deptype->services = rc_stringlist_new();
-			deptype->type = xstrdup(type);
-			TAILQ_INSERT_TAIL(&depinfo->depends, deptype, entries);
-		}
-		rc_stringlist_add(deptype->services, e);
-	}
-	fclose(fp);
-	free(line);
-
-	return deptree;
-}
-librc_hidden_def(rc_deptree_load_file)
-
-static bool
-valid_service(const char *runlevel, const char *service, const char *type)
-{
-	RC_SERVICE state;
-
-	if (!runlevel ||
-	    strcmp(type, "ineed") == 0 ||
-	    strcmp(type, "needsme") == 0)
-		return true;
-
-	if (rc_service_in_runlevel(service, runlevel))
-		return true;
-	if (strcmp(runlevel, RC_LEVEL_SYSINIT) == 0)
-		    return false;
-	if (strcmp(runlevel, RC_LEVEL_SHUTDOWN) == 0 &&
-	    strcmp(type, "iafter") == 0)
-		    return false;
-	if (strcmp(runlevel, bootlevel) != 0) {
-		if (rc_service_in_runlevel(service, bootlevel))
-			return true;
-	}
-
-	state = rc_service_state(service);
-	if (state & RC_SERVICE_HOTPLUGGED ||
-	    state & RC_SERVICE_STARTED)
-		return true;
-
-	return false;
-}
-
-static bool
-get_provided1(const char *runlevel, RC_STRINGLIST *providers,
-	      RC_DEPTYPE *deptype, const char *level,
-	      bool hotplugged, RC_SERVICE state)
-{
-	RC_STRING *service;
-	RC_SERVICE st;
-	bool retval = false;
-	bool ok;
-	const char *svc;
-
-	TAILQ_FOREACH(service, deptype->services, entries) {
-		ok = true;
-		svc = service->value;
-		st = rc_service_state(svc);
-
-		if (level)
-			ok = rc_service_in_runlevel(svc, level);
-		else if (hotplugged)
-			ok = (st & RC_SERVICE_HOTPLUGGED &&
-			      !rc_service_in_runlevel(svc, runlevel) &&
-			      !rc_service_in_runlevel(svc, bootlevel));
-		if (!ok)
-			continue;
-		switch (state) {
-			case RC_SERVICE_STARTED:
-				ok = (st & RC_SERVICE_STARTED);
-				break;
-			case RC_SERVICE_INACTIVE:
-			case RC_SERVICE_STARTING:
-			case RC_SERVICE_STOPPING:
-				ok = (st & RC_SERVICE_STARTING ||
-				      st & RC_SERVICE_STOPPING ||
-				      st & RC_SERVICE_INACTIVE);
-				break;
-			default:
-				break;
-		}
-		if (!ok)
-			continue;
-		retval = true;
-		rc_stringlist_add(providers, svc);
-	}
-
-	return retval;
-}
-
-/* Work out if a service is provided by another service.
-   For example metalog provides logger.
-   We need to be able to handle syslogd providing logger too.
-   We do this by checking whats running, then what's starting/stopping,
-   then what's run in the runlevels and finally alphabetical order.
-
-   If there are any bugs in rc-depend, they will probably be here as
-   provided dependancy can change depending on runlevel state.
-   */
-static RC_STRINGLIST *
-get_provided(const RC_DEPINFO *depinfo, const char *runlevel, int options)
-{
-	RC_DEPTYPE *dt;
-	RC_STRINGLIST *providers = rc_stringlist_new();
-	RC_STRING *service;
-
-	dt = get_deptype(depinfo, "providedby");
-	if (!dt)
-		return providers;
-
-	/* If we are stopping then all depends are true, regardless of state.
-	   This is especially true for net services as they could force a restart
-	   of the local dns resolver which may depend on net. */
-	if (options & RC_DEP_STOP) {
-		TAILQ_FOREACH(service, dt->services, entries)
-			rc_stringlist_add(providers, service->value);
-		return providers;
-	}
-
-	/* If we're strict or starting, then only use what we have in our
-	 * runlevel and bootlevel. If we starting then check hotplugged too. */
-	if (options & RC_DEP_STRICT || options & RC_DEP_START) {
-		TAILQ_FOREACH(service, dt->services, entries)
-			if (rc_service_in_runlevel(service->value, runlevel) ||
-			    rc_service_in_runlevel(service->value, bootlevel) ||
-			    (options & RC_DEP_START &&
-			     rc_service_state(service->value) & RC_SERVICE_HOTPLUGGED))
-				rc_stringlist_add(providers, service->value);
-		if (TAILQ_FIRST(providers))
-			return providers;
-	}
-
-	/* OK, we're not strict or there were no services in our runlevel.
-	 * This is now where the logic gets a little fuzzy :)
-	 * If there is >1 running service then we return NULL.
-	 * We do this so we don't hang around waiting for inactive services and
-	 * our need has already been satisfied as it's not strict.
-	 * We apply this to these states in order:-
-	 *     started, starting | stopping | inactive, stopped
-	 * Our sub preference in each of these is in order:-
-	 *     runlevel, hotplugged, bootlevel, any
-	 */
-#define DO \
-	if (TAILQ_FIRST(providers)) { \
-		if (TAILQ_NEXT(TAILQ_FIRST(providers), entries)) { \
-			rc_stringlist_free(providers); \
-			providers = rc_stringlist_new(); \
-		} \
-		return providers; \
-	}
-
-	/* Anything running has to come first */
-	if (get_provided1(runlevel, providers, dt, runlevel, false, RC_SERVICE_STARTED))
-	{ DO }
-	if (get_provided1(runlevel, providers, dt, NULL, true, RC_SERVICE_STARTED))
-	{ DO }
-	if (bootlevel && strcmp(runlevel, bootlevel) != 0 &&
-	    get_provided1(runlevel, providers, dt, bootlevel, false, RC_SERVICE_STARTED))
-	{ DO }
-	if (get_provided1(runlevel, providers, dt, NULL, false, RC_SERVICE_STARTED))
-	{ DO }
-
-	/* Check starting services */
-	if (get_provided1(runlevel, providers, dt, runlevel, false, RC_SERVICE_STARTING))
-		return providers;
-	if (get_provided1(runlevel, providers, dt, NULL, true, RC_SERVICE_STARTING))
-		return providers;
-	if (bootlevel && strcmp(runlevel, bootlevel) != 0 &&
-	    get_provided1(runlevel, providers, dt, bootlevel, false, RC_SERVICE_STARTING))
-	    return providers;
-	if (get_provided1(runlevel, providers, dt, NULL, false, RC_SERVICE_STARTING))
-		return providers;
-
-	/* Nothing started then. OK, lets get the stopped services */
-	if (get_provided1(runlevel, providers, dt, runlevel, false, RC_SERVICE_STOPPED))
-		return providers;
-	if (get_provided1(runlevel, providers, dt, NULL, true, RC_SERVICE_STOPPED))
-	{ DO }
-	if (bootlevel && (strcmp(runlevel, bootlevel) != 0) &&
-	    get_provided1(runlevel, providers, dt, bootlevel, false, RC_SERVICE_STOPPED))
-		return providers;
-
-	/* Still nothing? OK, list our first provided service. */
-	service = TAILQ_FIRST(dt->services);
-	if (service != NULL)
-		rc_stringlist_add(providers, service->value);
-
-	return providers;
-}
-
-static void
-visit_service(const RC_DEPTREE *deptree,
-	      const RC_STRINGLIST *types,
-	      RC_STRINGLIST *sorted,
-	      RC_STRINGLIST *visited,
-	      const RC_DEPINFO *depinfo,
-	      const char *runlevel, int options)
-{
-	RC_STRING *type;
-	RC_STRING *service;
-	RC_DEPTYPE *dt;
-	RC_DEPINFO *di;
-	RC_STRINGLIST *provided;
-	RC_STRING *p;
-	const char *svcname;
-
-	/* Check if we have already visited this service or not */
-	TAILQ_FOREACH(type, visited, entries)
-		if (strcmp(type->value, depinfo->service) == 0)
-			return;
-	/* Add ourselves as a visited service */
-	rc_stringlist_add(visited, depinfo->service);
-
-	TAILQ_FOREACH(type, types, entries)
-	{
-		if (!(dt = get_deptype(depinfo, type->value)))
-			continue;
-
-		TAILQ_FOREACH(service, dt->services, entries) {
-			if (!(options & RC_DEP_TRACE) ||
-			    strcmp(type->value, "iprovide") == 0)
-			{
-				rc_stringlist_add(sorted, service->value);
-				continue;
-			}
-
-			if (!(di = get_depinfo(deptree, service->value)))
-				continue;
-			provided = get_provided(di, runlevel, options);
-
-			if (TAILQ_FIRST(provided)) {
-				TAILQ_FOREACH(p, provided, entries) {
-					di = get_depinfo(deptree, p->value);
-					if (di && valid_service(runlevel, di->service, type->value))
-						visit_service(deptree, types, sorted, visited, di,
-							      runlevel, options | RC_DEP_TRACE);
-				}
-			}
-			else if (di && valid_service(runlevel, service->value, type->value))
-				visit_service(deptree, types, sorted, visited, di,
-					      runlevel, options | RC_DEP_TRACE);
-
-			rc_stringlist_free(provided);
-		}
-	}
-
-	/* Now visit the stuff we provide for */
-	if (options & RC_DEP_TRACE &&
-	    (dt = get_deptype(depinfo, "iprovide")))
-	{
-		TAILQ_FOREACH(service, dt->services, entries) {
-			if (!(di = get_depinfo(deptree, service->value)))
-				continue;
-			provided = get_provided(di, runlevel, options);
-			TAILQ_FOREACH(p, provided, entries)
-				if (strcmp(p->value, depinfo->service) == 0) {
-					visit_service(deptree, types, sorted, visited, di,
-						       runlevel, options | RC_DEP_TRACE);
-					break;
-				}
-			rc_stringlist_free(provided);
-		}
-	}
-
-	/* We've visited everything we need, so add ourselves unless we
-	   are also the service calling us or we are provided by something */
-	svcname = getenv("RC_SVCNAME");
-	if (!svcname || strcmp(svcname, depinfo->service) != 0) {
-		if (!get_deptype(depinfo, "providedby"))
-			rc_stringlist_add(sorted, depinfo->service);
-	}
-}
-
-RC_STRINGLIST *
-rc_deptree_depend(const RC_DEPTREE *deptree,
-		  const char *service, const char *type)
-{
-	RC_DEPINFO *di;
-	RC_DEPTYPE *dt;
-	RC_STRINGLIST *svcs;
-	RC_STRING *svc;
-
-	svcs = rc_stringlist_new();
-	if (!(di = get_depinfo(deptree, service)) ||
-	    !(dt = get_deptype(di, type)))
-	{
-		errno = ENOENT;
-		return svcs;
-	}
-
-	/* For consistency, we copy the array */
-	TAILQ_FOREACH(svc, dt->services, entries)
-		rc_stringlist_add(svcs, svc->value);
-	return svcs;
-}
-librc_hidden_def(rc_deptree_depend)
-
-RC_STRINGLIST *
-rc_deptree_depends(const RC_DEPTREE *deptree,
-		   const RC_STRINGLIST *types,
-		   const RC_STRINGLIST *services,
-		   const char *runlevel, int options)
-{
-	RC_STRINGLIST *sorted = rc_stringlist_new();
-	RC_STRINGLIST *visited = rc_stringlist_new();
-	RC_DEPINFO *di;
-	const RC_STRING *service;
-
-	bootlevel = getenv("RC_BOOTLEVEL");
-	if (!bootlevel)
-		bootlevel = RC_LEVEL_BOOT;
-	TAILQ_FOREACH(service, services, entries) {
-		if (!(di = get_depinfo(deptree, service->value))) {
-			errno = ENOENT;
-			continue;
-		}
-		if (types)
-			visit_service(deptree, types, sorted, visited,
-				      di, runlevel, options);
-	}
-	rc_stringlist_free(visited);
-	return sorted;
-}
-librc_hidden_def(rc_deptree_depends)
-
-RC_STRINGLIST *
-rc_deptree_order(const RC_DEPTREE *deptree, const char *runlevel, int options)
-{
-	RC_STRINGLIST *list;
-	RC_STRINGLIST *list2;
-	RC_STRINGLIST *types;
-	RC_STRINGLIST *services;
-
-	bootlevel = getenv("RC_BOOTLEVEL");
-	if (! bootlevel)
-		bootlevel = RC_LEVEL_BOOT;
-
-	/* When shutting down, list all running services */
-	if (strcmp(runlevel, RC_LEVEL_SINGLE) == 0 ||
-	    strcmp(runlevel, RC_LEVEL_SHUTDOWN) == 0)
-	{
-		list = rc_services_in_state(RC_SERVICE_STARTED);
-		list2 = rc_services_in_state(RC_SERVICE_INACTIVE);
-		TAILQ_CONCAT(list, list2, entries);
-		free(list2);
-		list2 = rc_services_in_state(RC_SERVICE_STARTING);
-		TAILQ_CONCAT(list, list2, entries);
-		free(list2);
-	} else {
-		list = rc_services_in_runlevel(RC_LEVEL_SYSINIT);
-		if (strcmp(runlevel, RC_LEVEL_SYSINIT) != 0) {
-			list2 = rc_services_in_runlevel(runlevel);
-			TAILQ_CONCAT(list, list2, entries);
-			free(list2);
-			list2 = rc_services_in_state(RC_SERVICE_HOTPLUGGED);
-			TAILQ_CONCAT(list, list2, entries);
-			free(list2);
-			/* If we're not the boot runlevel then add that too */
-			if (strcmp(runlevel, bootlevel) != 0) {
-				list2 = rc_services_in_runlevel(bootlevel);
-				TAILQ_CONCAT(list, list2, entries);
-				free(list2);
-			}
-		}
-	}
-
-	/* Now we have our lists, we need to pull in any dependencies
-	   and order them */
-	types = rc_stringlist_new();
-	rc_stringlist_add(types, "ineed");
-	rc_stringlist_add(types, "iuse");
-	rc_stringlist_add(types, "iafter");
-	services = rc_deptree_depends(deptree, types, list, runlevel,
-				      RC_DEP_STRICT | RC_DEP_TRACE | options);
-	rc_stringlist_free(list);
-	rc_stringlist_free(types);
-	return services;
-}
-librc_hidden_def(rc_deptree_order)
-
-static bool
-mtime_check(const char *source, const char *target, bool newer,
-	    time_t *rel, char *file)
-{
-	struct stat buf;
-	time_t mtime;
-	bool retval = true;
-	DIR *dp;
-	struct dirent *d;
-	char path[PATH_MAX];
-	int serrno = errno;
-
-	/* We have to exist */
-	if (stat(source, &buf) != 0)
-		return false;
-	mtime = buf.st_mtime;
-
-	/* If target does not exist, return true to mimic shell test */
-	if (stat(target, &buf) != 0)
-		return true;
-
-	if (newer) {
-		if (mtime < buf.st_mtime) {
-			if (rel == NULL)
-				return false;
-			retval = false;
-		}
-		if (rel != NULL) {
-			if (*rel < buf.st_mtime) {
-				if (file)
-					strlcpy(file, target, PATH_MAX);
-				*rel = buf.st_mtime;
-			}
-		}
-	} else {
-		if (mtime > buf.st_mtime) {
-			if (rel == NULL)
-				return false;
-			retval = false;
-		}
-		if (rel != NULL) {
-			if (*rel > buf.st_mtime) {
-				if (file)
-					strlcpy(file, target, PATH_MAX);
-				*rel = buf.st_mtime;
-			}
-		}
-	}
-
-	/* If not a dir then reset errno */
-	if (!(dp = opendir(target))) {
-		errno = serrno;
-		return retval;
-	}
-
-	/* Check all the entries in the dir */
-	while ((d = readdir(dp))) {
-		if (d->d_name[0] == '.')
-			continue;
-		snprintf(path, sizeof(path), "%s/%s", target, d->d_name);
-		if (!mtime_check(source, path, newer, rel, file)) {
-			retval = false;
-			if (rel == NULL)
-				break;
-		}
-	}
-	closedir(dp);
-	return retval;
-}
-
-bool
-rc_newer_than(const char *source, const char *target,
-	      time_t *newest, char *file)
-{
-
-	return mtime_check(source, target, true, newest, file);
-}
-librc_hidden_def(rc_newer_than)
-
-bool
-rc_older_than(const char *source, const char *target,
-	      time_t *oldest, char *file)
-{
-	return mtime_check(source, target, false, oldest, file);
-}
-librc_hidden_def(rc_older_than)
-
-typedef struct deppair
-{
-	const char *depend;
-	const char *addto;
-} DEPPAIR;
-
-static const DEPPAIR deppairs[] = {
-	{ "ineed",	"needsme" },
-	{ "iuse",	"usesme" },
-	{ "iafter",	"ibefore" },
-	{ "ibefore",	"iafter" },
-	{ "iprovide",	"providedby" },
-	{ NULL, NULL }
-};
-
-static const char *const depdirs[] =
-{
-	RC_SVCDIR,
-	RC_SVCDIR "/starting",
-	RC_SVCDIR "/started",
-	RC_SVCDIR "/stopping",
-	RC_SVCDIR "/inactive",
-	RC_SVCDIR "/wasinactive",
-	RC_SVCDIR "/failed",
-	RC_SVCDIR "/hotplugged",
-	RC_SVCDIR "/daemons",
-	RC_SVCDIR "/options",
-	RC_SVCDIR "/exclusive",
-	RC_SVCDIR "/scheduled",
-	RC_SVCDIR "/tmp",
-	NULL
-};
-
-bool
-rc_deptree_update_needed(time_t *newest, char *file)
-{
-	bool newer = false;
-	RC_STRINGLIST *config;
-	RC_STRING *s;
-	int i;
-
-	/* Create base directories if needed */
-	for (i = 0; depdirs[i]; i++)
-		if (mkdir(depdirs[i], 0755) != 0 && errno != EEXIST)
-			fprintf(stderr, "mkdir `%s': %s\n", depdirs[i], strerror(errno));
-
-	/* Quick test to see if anything we use has changed and we have
-	 * data in our deptree */
-	if (!existss(RC_DEPTREE_CACHE))
-		return true;
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_INITDIR, newest, file))
-		return true;
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_CONFDIR, newest, file))
-		return true;
-#ifdef RC_PKG_INITDIR
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_PKG_INITDIR, newest, file))
-		return true;
-#endif
-#ifdef RC_PKG_CONFDIR
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_PKG_CONFDIR, newest, file))
-		return true;
-#endif
-#ifdef RC_LOCAL_INITDIR
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_LOCAL_INITDIR, newest, file))
-		return true;
-#endif
-#ifdef RC_LOCAL_CONFDIR
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_LOCAL_CONFDIR, newest, file))
-		return true;
-#endif
-	if (!rc_newer_than(RC_DEPTREE_CACHE, RC_CONF, newest, file))
-		return true;
-
-	/* Some init scripts dependencies change depending on config files
-	 * outside of baselayout, like syslog-ng, so we check those too. */
-	config = rc_config_list(RC_DEPCONFIG);
-	TAILQ_FOREACH(s, config, entries) {
-		if (!rc_newer_than(RC_DEPTREE_CACHE, s->value, newest, file)) {
-			newer = true;
-			break;
-		}
-	}
-	rc_stringlist_free(config);
-	return newer;
-}
-librc_hidden_def(rc_deptree_update_needed)
-
-/* This is a 6 phase operation
-   Phase 1 is a shell script which loads each init script and config in turn
-   and echos their dependency info to stdout
-   Phase 2 takes that and populates a depinfo object with that data
-   Phase 3 adds any provided services to the depinfo object
-   Phase 4 scans that depinfo object and puts in backlinks
-   Phase 5 removes broken before dependencies
-   Phase 6 saves the depinfo object to disk
-   */
-bool
-rc_deptree_update(void)
-{
-	FILE *fp;
-	RC_DEPTREE *deptree, *providers;
-	RC_DEPINFO *depinfo = NULL, *depinfo_np, *di;
-	RC_DEPTYPE *deptype = NULL, *dt_np, *dt, *provide;
-	RC_STRINGLIST *config, *types, *sorted, *visited;
-	RC_STRING *s, *s2, *s2_np, *s3, *s4;
-	char *line = NULL;
-	size_t len = 0;
-	char *depend, *depends, *service, *type, *nosys, *onosys;
-	size_t i, k, l;
-	bool retval = true;
-	const char *sys = rc_sys();
-	struct utsname uts;
-
-	/* Some init scripts need RC_LIBEXECDIR to source stuff
-	   Ideally we should be setting our full env instead */
-	if (!getenv("RC_LIBEXECDIR"))
-		setenv("RC_LIBEXECDIR", RC_LIBEXECDIR, 0);
-
-	if (uname(&uts) == 0)
-		setenv("RC_UNAME", uts.sysname, 1);
-	/* Phase 1 - source all init scripts and print dependencies */
-	if (!(fp = popen(GENDEP, "r")))
-		return false;
-
-	deptree = xmalloc(sizeof(*deptree));
-	TAILQ_INIT(deptree);
-	config = rc_stringlist_new();
-	while ((rc_getline(&line, &len, fp)))
-	{
-		depends = line;
-		service = strsep(&depends, " ");
-		if (!service || !*service)
-			continue;
-
-		type = strsep(&depends, " ");
-		if (!depinfo || strcmp(depinfo->service, service) != 0) {
-			deptype = NULL;
-			depinfo = get_depinfo(deptree, service);
-			if (!depinfo) {
-				depinfo = xmalloc(sizeof(*depinfo));
-				TAILQ_INIT(&depinfo->depends);
-				depinfo->service = xstrdup(service);
-				TAILQ_INSERT_TAIL(deptree, depinfo, entries);
-			}
-		}
-
-		/* We may not have any depends */
-		if (!type || !depends)
-			continue;
-
-		/* Get the type */
-		if (strcmp(type, "config") != 0) {
-			if (!deptype || strcmp(deptype->type, type) != 0)
-				deptype = get_deptype(depinfo, type);
-			if (!deptype) {
-				deptype = xmalloc(sizeof(*deptype));
-				deptype->type = xstrdup(type);
-				deptype->services = rc_stringlist_new();
-				TAILQ_INSERT_TAIL(&depinfo->depends, deptype, entries);
-			}
-		}
-
-		/* Now add each depend to our type.
-		   We do this individually so we handle multiple spaces gracefully */
-		while ((depend = strsep(&depends, " ")))
-		{
-			if (depend[0] == 0)
-				continue;
-
-			if (strcmp(type, "config") == 0) {
-				rc_stringlist_addu(config, depend);
-				continue;
-			}
-
-			/* Don't provide ourself */
-			if (strcmp(type, "iprovide") == 0 &&
-			    strcmp(depend, service) == 0)
-				continue;
-
-			/* .sh files are not init scripts */
-			l = strlen(depend);
-			if (l > 2 &&
-			    depend[l - 3] == '.' &&
-			    depend[l - 2] == 's' &&
-			    depend[l - 1] == 'h')
-				continue;
-
-			/* Remove our dependency if instructed */
-			if (depend[0] == '!') {
-				rc_stringlist_delete(deptype->services, depend + 1);
-				continue;
-			}
-
-			rc_stringlist_add(deptype->services, depend);
-
-			/* We need to allow `after *; before local;` to work.
-			 * Conversely, we need to allow 'before *; after modules' also */
-			/* If we're before something, remove us from the after list */
-			if (strcmp(type, "ibefore") == 0) {
-				if ((dt = get_deptype(depinfo, "iafter")))
-					rc_stringlist_delete(dt->services, depend);
-			}
-			/* If we're after something, remove us from the before list */
-			if (strcmp(type, "iafter") == 0 ||
-			    strcmp(type, "ineed") == 0 ||
-			    strcmp(type, "iuse") == 0) {
-				if ((dt = get_deptype(depinfo, "ibefore")))
-					rc_stringlist_delete(dt->services, depend);
-			}
-		}
-	}
-	free(line);
-	pclose(fp);
-
-	/* Phase 2 - if we're a special system, remove services that don't
-	 * work for them. This doesn't stop them from being run directly. */
-	if (sys) {
-		len = strlen(sys);
-		nosys = xmalloc(len + 2);
-		nosys[0] = '-';
-		for (i = 0; i < len; i++)
-			nosys[i + 1] = (char)tolower((unsigned char)sys[i]);
-		nosys[i + 1] = '\0';
-
-		onosys = xmalloc(len + 3);
-		onosys[0] = 'n';
-		onosys[1] = 'o';
-		for (i = 0; i < len; i++)
-			onosys[i + 2] = (char)tolower((unsigned char)sys[i]);
-		onosys[i + 2] = '\0';
-
-		TAILQ_FOREACH_SAFE(depinfo, deptree, entries, depinfo_np)
-			if ((deptype = get_deptype(depinfo, "keyword")))
-				TAILQ_FOREACH(s, deptype->services, entries)
-					if (strcmp(s->value, nosys) == 0 ||
-					    strcmp(s->value, onosys) == 0)
-					{
-						provide = get_deptype(depinfo, "iprovide");
-						TAILQ_REMOVE(deptree, depinfo, entries);
-						TAILQ_FOREACH(di, deptree, entries) {
-							TAILQ_FOREACH_SAFE(dt, &di->depends, entries, dt_np) {
-								rc_stringlist_delete(dt->services, depinfo->service);
-								if (provide)
-									TAILQ_FOREACH(s2, provide->services, entries)
-										rc_stringlist_delete(dt->services, s2->value);
-								if (!TAILQ_FIRST(dt->services)) {
-									TAILQ_REMOVE(&di->depends, dt, entries);
-									free(dt->type);
-									free(dt->services);
-									free(dt);
-								}
-							}
-						}
-					}
-		free(nosys);
-		free(onosys);
-	}
-
-	/* Phase 3 - add our providers to the tree */
-	providers = xmalloc(sizeof(*providers));
-	TAILQ_INIT(providers);
-	TAILQ_FOREACH(depinfo, deptree, entries)
-		if ((deptype = get_deptype(depinfo, "iprovide")))
-			TAILQ_FOREACH(s, deptype->services, entries) {
-				TAILQ_FOREACH(di, providers, entries)
-					if (strcmp(di->service, s->value) == 0)
-						break;
-				if (!di) {
-					di = xmalloc(sizeof(*di));
-					TAILQ_INIT(&di->depends);
-					di->service = xstrdup(s->value);
-					TAILQ_INSERT_TAIL(providers, di, entries);
-				}
-			}
-	TAILQ_CONCAT(deptree, providers, entries);
-	free(providers);
-
-	/* Phase 4 - backreference our depends */
-	TAILQ_FOREACH(depinfo, deptree, entries)
-		for (i = 0; deppairs[i].depend; i++) {
-			deptype = get_deptype(depinfo, deppairs[i].depend);
-			if (!deptype)
-				continue;
-			TAILQ_FOREACH(s, deptype->services, entries) {
-				di = get_depinfo(deptree, s->value);
-				if (!di) {
-					if (strcmp(deptype->type, "ineed") == 0) {
-						fprintf(stderr,
-							 "Service `%s' needs non"
-							 " existent service `%s'\n",
-							 depinfo->service, s->value);
-						dt = get_deptype(depinfo, "broken");
-						if (!dt) {
-							dt = xmalloc(sizeof(*dt));
-							dt->type = xstrdup("broken");
-							dt->services = rc_stringlist_new();
-							TAILQ_INSERT_TAIL(&depinfo->depends, dt, entries);
-						}
-						rc_stringlist_addu(dt->services, s->value);
-					}
-					continue;
-				}
-
-				dt = get_deptype(di, deppairs[i].addto);
-				if (!dt) {
-					dt = xmalloc(sizeof(*dt));
-					dt->type = xstrdup(deppairs[i].addto);
-					dt->services = rc_stringlist_new();
-					TAILQ_INSERT_TAIL(&di->depends, dt, entries);
-				}
-				rc_stringlist_addu(dt->services, depinfo->service);
-			}
-		}
-
-
-	/* Phase 5 - Remove broken before directives */
-	types = rc_stringlist_new();
-	rc_stringlist_add(types, "ineed");
-	rc_stringlist_add(types, "iuse");
-	rc_stringlist_add(types, "iafter");
-	TAILQ_FOREACH(depinfo, deptree, entries) {
-		deptype = get_deptype(depinfo, "ibefore");
-		if (!deptype)
-			continue;
-		sorted = rc_stringlist_new();
-		visited = rc_stringlist_new();
-		visit_service(deptree, types, sorted, visited, depinfo,
-			      NULL, 0);
-		rc_stringlist_free(visited);
-		TAILQ_FOREACH_SAFE(s2, deptype->services, entries, s2_np) {
-			TAILQ_FOREACH(s3, sorted, entries) {
-				di = get_depinfo(deptree, s3->value);
-				if (!di)
-					continue;
-				if (strcmp(s2->value, s3->value) == 0) {
-					dt = get_deptype(di, "iafter");
-					if (dt)
-						rc_stringlist_delete(dt->services, depinfo->service);
-					break;
-				}
-				dt = get_deptype(di, "iprovide");
-				if (!dt)
-					continue;
-				TAILQ_FOREACH(s4, dt->services, entries) {
-					if (strcmp(s4->value, s2->value) == 0)
-						break;
-				}
-				if (s4) {
-					di = get_depinfo(deptree, s4->value);
-					if (di) {
-						dt = get_deptype(di, "iafter");
-						if (dt)
-							rc_stringlist_delete(dt->services, depinfo->service);
-					}
-					break;
-				}
-			}
-			if (s3)
-				rc_stringlist_delete(deptype->services, s2->value);
-		}
-		rc_stringlist_free(sorted);
-	}
-	rc_stringlist_free(types);
-
-	/* Phase 6 - save to disk
-	   Now that we're purely in C, do we need to keep a shell parseable file?
-	   I think yes as then it stays human readable
-	   This works and should be entirely shell parseable provided that depend
-	   names don't have any non shell variable characters in
-	   */
-	if ((fp = fopen(RC_DEPTREE_CACHE, "w"))) {
-		i = 0;
-		TAILQ_FOREACH(depinfo, deptree, entries) {
-			fprintf(fp, "depinfo_%zu_service='%s'\n",
-				i, depinfo->service);
-			TAILQ_FOREACH(deptype, &depinfo->depends, entries) {
-				k = 0;
-				TAILQ_FOREACH(s, deptype->services, entries) {
-					fprintf(fp,
-						"depinfo_%zu_%s_%zu='%s'\n",
-						i, deptype->type, k, s->value);
-					k++;
-				}
-			}
-			i++;
-		}
-		fclose(fp);
-	} else {
-		fprintf(stderr, "fopen `%s': %s\n",
-			RC_DEPTREE_CACHE, strerror(errno));
-		retval = false;
-	}
-
-	/* Save our external config files to disk */
-	if (TAILQ_FIRST(config)) {
-		if ((fp = fopen(RC_DEPCONFIG, "w"))) {
-			TAILQ_FOREACH(s, config, entries)
-				fprintf(fp, "%s\n", s->value);
-			fclose(fp);
-		} else {
-			fprintf(stderr, "fopen `%s': %s\n",
-				RC_DEPCONFIG, strerror(errno));
-			retval = false;
-		}
-	} else {
-		unlink(RC_DEPCONFIG);
-	}
-
-	rc_stringlist_free(config);
-	rc_deptree_free(deptree);
-	return retval;
-}
-librc_hidden_def(rc_deptree_update)
diff --git a/src/librc/librc-misc.c b/src/librc/librc-misc.c
deleted file mode 100644
index 2e9de801..00000000
--- a/src/librc/librc-misc.c
+++ /dev/null
@@ -1,425 +0,0 @@
-/*
-  rc-misc.c
-  rc misc functions
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 "queue.h"
-#include "librc.h"
-
-bool
-rc_yesno(const char *value)
-{
-	if (!value) {
-		errno = ENOENT;
-		return false;
-	}
-
-	if (strcasecmp(value, "yes") == 0 ||
-	    strcasecmp(value, "y") == 0 ||
-	    strcasecmp(value, "true") == 0 ||
-	    strcasecmp(value, "1") == 0)
-		return true;
-
-	if (strcasecmp(value, "no") != 0 &&
-	    strcasecmp(value, "n") != 0 &&
-	    strcasecmp(value, "false") != 0 &&
-	    strcasecmp(value, "0") != 0)
-		errno = EINVAL;
-
-	return false;
-}
-librc_hidden_def(rc_yesno)
-
-
-/**
- * Read the entire @file into the buffer and set @len to the
- * size of the buffer when finished. For C strings, this will
- * be strlen(buffer) + 1.
- * Don't forget to free the buffer afterwards!
- */
-bool
-rc_getfile(const char *file, char **buffer, size_t *len)
-{
-	bool ret = false;
-	FILE *fp;
-	int fd;
-	struct stat st;
-	size_t done, left;
-
-	fp = fopen(file, "re");
-	if (!fp)
-		return false;
-
-	/* assume fileno() never fails */
-	fd = fileno(fp);
-
-	if (fstat(fd, &st))
-		goto finished;
-
-	left = st.st_size;
-	*len = left + 1; /* NUL terminator */
-	*buffer = xrealloc(*buffer, *len);
-	while (left) {
-		done = fread(*buffer, sizeof(*buffer[0]), left, fp);
-		if (done == 0 && ferror(fp))
-			goto finished;
-		left -= done;
-	}
-	ret = true;
-
- finished:
-	if (!ret) {
-		free(*buffer);
-		*len = 0;
-	} else
-		(*buffer)[*len - 1] = '\0';
-	fclose(fp);
-	return ret;
-}
-librc_hidden_def(rc_getfile)
-
-ssize_t
-rc_getline(char **line, size_t *len, FILE *fp)
-{
-	char *p;
-	size_t last = 0;
-
-	while (!feof(fp)) {
-		if (*line == NULL || last != 0) {
-			*len += BUFSIZ;
-			*line = xrealloc(*line, *len);
-		}
-		p = *line + last;
-		memset(p, 0, BUFSIZ);
-		if (fgets(p, BUFSIZ, fp) == NULL)
-			break;
-		last += strlen(p);
-		if (last && (*line)[last - 1] == '\n') {
-			(*line)[last - 1] = '\0';
-			break;
-		}
-	}
-	return last;
-}
-librc_hidden_def(rc_getline)
-
-char *
-rc_proc_getent(const char *ent)
-{
-#ifdef __linux__
-	FILE *fp;
-	char *proc, *p, *value = NULL;
-	size_t i, len;
-
-	if (!exists("/proc/cmdline"))
-		return NULL;
-
-	if (!(fp = fopen("/proc/cmdline", "r")))
-		return NULL;
-
-	proc = NULL;
-	i = 0;
-	if (rc_getline(&proc, &i, fp) == -1 || proc == NULL)
-		return NULL;
-
-	if (proc != NULL) {
-		len = strlen(ent);
-
-		while ((p = strsep(&proc, " "))) {
-			if (strncmp(ent, p, len) == 0 && (p[len] == '\0' || p[len] == ' ' || p[len] == '=')) {
-				p += len;
-
-				if (*p == '=')
-					p++;
-
-				value = xstrdup(p);
-			}
-		}
-	}
-
-	if (!value)
-		errno = ENOENT;
-
-	fclose(fp);
-	free(proc);
-
-	return value;
-#else
-	return NULL;
-#endif
-}
-librc_hidden_def(rc_proc_getent)
-
-RC_STRINGLIST *
-rc_config_list(const char *file)
-{
-	FILE *fp;
-	char *buffer = NULL;
-	size_t len = 0;
-	char *p;
-	char *token;
-	RC_STRINGLIST *list = rc_stringlist_new();
-
-	if (!(fp = fopen(file, "r")))
-		return list;
-
-	while ((rc_getline(&buffer, &len, fp))) {
-		p = buffer;
-		/* Strip leading spaces/tabs */
-		while ((*p == ' ') || (*p == '\t'))
-			p++;
-
-		/* Get entry - we do not want comments */
-		token = strsep(&p, "#");
-		if (token && (strlen(token) > 1)) {
-			/* If not variable assignment then skip */
-			if (strchr(token, '=')) {
-				/* Stip the newline if present */
-				if (token[strlen(token) - 1] == '\n')
-					token[strlen(token) - 1] = 0;
-
-				rc_stringlist_add(list, token);
-			}
-		}
-	}
-	fclose(fp);
-	free(buffer);
-
-	return list;
-}
-librc_hidden_def(rc_config_list)
-
-/*
- * Override some specific rc.conf options on the kernel command line
- */
-#ifdef __linux__
-static RC_STRINGLIST *rc_config_override(RC_STRINGLIST *config)
-{
-	RC_STRINGLIST *overrides;
-	RC_STRING *cline, *override, *config_np;
-	char *tmp = NULL;
-	char *value = NULL;
-	size_t varlen = 0;
-	size_t len = 0;
-
-	overrides = rc_stringlist_new();
-
-	/* A list of variables which may be overridden on the kernel command line */
-	rc_stringlist_add(overrides, "rc_parallel");
-
-	TAILQ_FOREACH(override, overrides, entries) {
-		varlen = strlen(override->value);
-		value = rc_proc_getent(override->value);
-
-		/* No need to continue if there's nothing to override */
-		if (!value) {
-			free(value);
-			continue;
-		}
-
-		if (value != NULL) {
-			len = varlen + strlen(value) + 2;
-			tmp = xmalloc(sizeof(char) * len);
-			snprintf(tmp, len, "%s=%s", override->value, value);
-		}
-
-		/*
-		 * Whenever necessary remove the old config entry first to prevent
-		 * duplicates
-		 */
-		TAILQ_FOREACH_SAFE(cline, config, entries, config_np) {
-			if (strncmp(override->value, cline->value, varlen) == 0
-				&& cline->value[varlen] == '=') {
-				rc_stringlist_delete(config, cline->value);
-				break;
-			}
-		}
-
-		/* Add the option (var/value) to the current config */
-		rc_stringlist_add(config, tmp);
-
-		free(tmp);
-		free(value);
-	}
-
-	rc_stringlist_free(overrides);
-	return config;
-}
-#endif
-
-RC_STRINGLIST *
-rc_config_load(const char *file)
-{
-	RC_STRINGLIST *list;
-	RC_STRINGLIST *config;
-	char *token;
-	RC_STRING *line;
-	RC_STRING *cline;
-	size_t i = 0;
-	bool replaced;
-	char *entry;
-	char *newline;
-	char *p;
-
-	list = rc_config_list(file);
-	config = rc_stringlist_new();
-	TAILQ_FOREACH(line, list, entries) {
-		/* Get entry */
-		p = line->value;
-		if (! p)
-			continue;
-		if (strncmp(p, "export ", 7) == 0)
-			p += 7;
-		if (! (token = strsep(&p, "=")))
-			continue;
-
-		entry = xstrdup(token);
-		/* Preserve shell coloring */
-		if (*p == '$')
-			token = line->value;
-		else
-			do {
-				/* Bash variables are usually quoted */
-				token = strsep(&p, "\"\'");
-			} while (token && *token == '\0');
-
-		/* Drop a newline if that's all we have */
-		if (token) {
-			i = strlen(token) - 1;
-			if (token[i] == '\n')
-				token[i] = 0;
-
-			i = strlen(entry) + strlen(token) + 2;
-			newline = xmalloc(sizeof(char) * i);
-			snprintf(newline, i, "%s=%s", entry, token);
-		} else {
-			i = strlen(entry) + 2;
-			newline = xmalloc(sizeof(char) * i);
-			snprintf(newline, i, "%s=", entry);
-		}
-
-		replaced = false;
-		/* In shells the last item takes precedence, so we need to remove
-		   any prior values we may already have */
-		TAILQ_FOREACH(cline, config, entries) {
-			i = strlen(entry);
-			if (strncmp(entry, cline->value, i) == 0 && cline->value[i] == '=') {
-				/* We have a match now - to save time we directly replace it */
-				free(cline->value);
-				cline->value = newline;
-				replaced = true;
-				break;
-			}
-		}
-
-		if (!replaced) {
-			rc_stringlist_add(config, newline);
-			free(newline);
-		}
-		free(entry);
-	}
-	rc_stringlist_free(list);
-
-#ifdef __linux__
-	/* Only override rc.conf settings */
-	if (strcmp(file, RC_CONF) == 0) {
-		config = rc_config_override(config);
-	}
-#endif
-
-	return config;
-}
-librc_hidden_def(rc_config_load)
-
-char *
-rc_config_value(RC_STRINGLIST *list, const char *entry)
-{
-	RC_STRING *line;
-	char *p;
-	size_t len;
-
-	len = strlen(entry);
-	TAILQ_FOREACH(line, list, entries) {
-		p = strchr(line->value, '=');
-		if (p != NULL) {
-			if (strncmp(entry, line->value, len) == 0 && line->value[len] == '=')
-				return ++p;
-		}
-	}
-	return NULL;
-}
-librc_hidden_def(rc_config_value)
-
-/* Global for caching the strings loaded from rc.conf to avoid reparsing for
- * each rc_conf_value call */
-static RC_STRINGLIST *rc_conf = NULL;
-
-char *
-rc_conf_value(const char *setting)
-{
-	RC_STRINGLIST *old;
-	RC_STRING *s;
-	char *p;
-
-	if (! rc_conf) {
-		rc_conf = rc_config_load(RC_CONF);
-#ifdef DEBUG_MEMORY
-		atexit(_free_rc_conf);
-#endif
-
-		/* Support old configs. */
-		if (exists(RC_CONF_OLD)) {
-			old = rc_config_load(RC_CONF_OLD);
-			TAILQ_CONCAT(rc_conf, old, entries);
-#ifdef DEBUG_MEMORY
-			free(old);
-#endif
-		}
-
-		/* Convert old uppercase to lowercase */
-		TAILQ_FOREACH(s, rc_conf, entries) {
-			p = s->value;
-			while (p && *p && *p != '=') {
-				if (isupper((unsigned char)*p))
-					*p = tolower((unsigned char)*p);
-				p++;
-			}
-		}
-	}
-
-	return rc_config_value(rc_conf, setting);
-}
-librc_hidden_def(rc_conf_value)
-
-#ifdef DEBUG_MEMORY
-static void
-_free_rc_conf(void)
-{
-	rc_stringlist_free(rc_conf);
-}
-#endif
diff --git a/src/librc/librc-stringlist.c b/src/librc/librc-stringlist.c
deleted file mode 100644
index bf8d3f40..00000000
--- a/src/librc/librc-stringlist.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-  librc-strlist.h
-  String list functions to make using queue(3) a little easier.
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 "queue.h"
-#include "librc.h"
-
-RC_STRINGLIST *
-rc_stringlist_new(void)
-{
-	RC_STRINGLIST *l = xmalloc(sizeof(*l));
-	TAILQ_INIT(l);
-	return l;
-}
-librc_hidden_def(rc_stringlist_new)
-
-RC_STRING *
-rc_stringlist_add(RC_STRINGLIST *list, const char *value)
-{
-	RC_STRING *s = xmalloc(sizeof(*s));
-
-	s->value = xstrdup(value);
-	TAILQ_INSERT_TAIL(list, s, entries);
-	return s;
-}
-librc_hidden_def(rc_stringlist_add)
-
-RC_STRING *
-rc_stringlist_addu(RC_STRINGLIST *list, const char *value)
-{
-	RC_STRING *s;
-
-	TAILQ_FOREACH(s, list, entries)
-	    if (strcmp(s->value, value) == 0) {
-		    errno = EEXIST;
-		    return NULL;
-	    }
-
-	return rc_stringlist_add(list, value);
-}
-librc_hidden_def(rc_stringlist_addu)
-
-bool
-rc_stringlist_delete(RC_STRINGLIST *list, const char *value)
-{
-	RC_STRING *s;
-
-	TAILQ_FOREACH(s, list, entries)
-	    if (strcmp(s->value, value) == 0) {
-		    TAILQ_REMOVE(list, s, entries);
-		    free(s->value);
-		    free(s);
-		    return true;
-	    }
-
-	errno = EEXIST;
-	return false;
-}
-librc_hidden_def(rc_stringlist_delete)
-
-RC_STRING *
-rc_stringlist_find(RC_STRINGLIST *list, const char *value)
-{
-	RC_STRING *s;
-
-	if (list) {
-		TAILQ_FOREACH(s, list, entries)
-		    if (strcmp(s->value, value) == 0)
-			    return s;
-	}
-	return NULL;
-}
-librc_hidden_def(rc_stringlist_find)
-
-RC_STRINGLIST *
-rc_stringlist_split(const char *value, const char *sep)
-{
-	RC_STRINGLIST *list = rc_stringlist_new();
-	char *d = xstrdup(value);
-	char *p = d, *token;
-
-	while ((token = strsep(&p, sep)))
-		rc_stringlist_add(list, token);
-	free(d);
-
-	return list;
-}
-librc_hidden_def(rc_stringlist_split)
-
-void
-rc_stringlist_sort(RC_STRINGLIST **list)
-{
-	RC_STRINGLIST *l = *list;
-	RC_STRINGLIST *new = rc_stringlist_new();
-	RC_STRING *s;
-	RC_STRING *sn;
-	RC_STRING *n;
-	RC_STRING *last;
-
-	TAILQ_FOREACH_SAFE(s, l, entries, sn) {
-		TAILQ_REMOVE(l, s, entries);
-		last = NULL;
-		TAILQ_FOREACH(n, new, entries) {
-			if (strcmp(s->value, n->value) < 0)
-				break;
-			last = n;
-		}
-		if (last)
-			TAILQ_INSERT_AFTER(new, last, s, entries);
-		else
-			TAILQ_INSERT_HEAD(new, s, entries);
-	}
-
-	/* Now we've sorted the list, copy across the new head */
-	free(l);
-	*list = new;
-}
-librc_hidden_def(rc_stringlist_sort)
-
-void
-rc_stringlist_free(RC_STRINGLIST *list)
-{
-	RC_STRING *s1;
-	RC_STRING *s2;
-
-	if (!list)
-		return;
-
-	s1 = TAILQ_FIRST(list);
-	while (s1) {
-		s2 = TAILQ_NEXT(s1, entries);
-		free(s1->value);
-		free(s1);
-		s1 = s2;
-	}
-	free(list);
-}
-librc_hidden_def(rc_stringlist_free)
diff --git a/src/librc/librc.c b/src/librc/librc.c
deleted file mode 100644
index ca51aa61..00000000
--- a/src/librc/librc.c
+++ /dev/null
@@ -1,1061 +0,0 @@
-/*
-  librc
-  core RC functions
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-const char librc_copyright[] = "Copyright (c) 2007-2008 Roy Marples";
-
-#include "queue.h"
-#include "librc.h"
-#ifdef __FreeBSD__
-#  include <sys/sysctl.h>
-#endif
-
-#define RC_RUNLEVEL	RC_SVCDIR "/softlevel"
-
-#ifndef S_IXUGO
-#  define S_IXUGO (S_IXUSR | S_IXGRP | S_IXOTH)
-#endif
-
-/* File stream used for plugins to write environ vars to */
-FILE *rc_environ_fd = NULL;
-
-typedef struct rc_service_state_name {
-	RC_SERVICE state;
-	const char *name;
-} rc_service_state_name_t;
-
-/* We MUST list the states below 0x10 first
- * The rest can be in any order */
-static const rc_service_state_name_t rc_service_state_names[] = {
-	{ RC_SERVICE_STARTED,     "started" },
-	{ RC_SERVICE_STOPPED,     "stopped" },
-	{ RC_SERVICE_STARTING,    "starting" },
-	{ RC_SERVICE_STOPPING,    "stopping" },
-	{ RC_SERVICE_INACTIVE,    "inactive" },
-	{ RC_SERVICE_WASINACTIVE, "wasinactive" },
-	{ RC_SERVICE_HOTPLUGGED,  "hotplugged" },
-	{ RC_SERVICE_FAILED,      "failed" },
-	{ RC_SERVICE_SCHEDULED,   "scheduled"},
-	{ 0, NULL}
-};
-
-#define LS_INITD	0x01
-#define LS_DIR		0x02
-static RC_STRINGLIST *
-ls_dir(const char *dir, int options)
-{
-	DIR *dp;
-	struct dirent *d;
-	RC_STRINGLIST *list = NULL;
-	struct stat buf;
-	size_t l;
-	char file[PATH_MAX];
-	int r;
-
-	list = rc_stringlist_new();
-	if ((dp = opendir(dir)) == NULL)
-		return list;
-	while (((d = readdir(dp)) != NULL)) {
-		if (d->d_name[0] != '.') {
-			if (options & LS_INITD) {
-				/* Check that our file really exists.
-				 * This is important as a service maybe in a
-				 * runlevel, but could have been removed. */
-				snprintf(file, sizeof(file), "%s/%s",
-				    dir, d->d_name);
-				r = stat(file, &buf);
-				if (r != 0)
-					continue;
-
-				/* .sh files are not init scripts */
-				l = strlen(d->d_name);
-				if (l > 2 && d->d_name[l - 3] == '.' &&
-				    d->d_name[l - 2] == 's' &&
-				    d->d_name[l - 1] == 'h')
-					continue;
-			}
-			if (options & LS_DIR) {
-				if (stat(d->d_name, &buf) == 0 &&
-				    !S_ISDIR(buf.st_mode))
-					continue;
-			}
-			rc_stringlist_add(list, d->d_name);
-		}
-	}
-	closedir(dp);
-	return list;
-}
-
-static bool
-rm_dir(const char *pathname, bool top)
-{
-	DIR *dp;
-	struct dirent *d;
-	char file[PATH_MAX];
-	struct stat s;
-	bool retval = true;
-
-	if ((dp = opendir(pathname)) == NULL)
-		return false;
-
-	errno = 0;
-	while (((d = readdir(dp)) != NULL) && errno == 0) {
-		if (strcmp(d->d_name, ".") != 0 &&
-		    strcmp(d->d_name, "..") != 0)
-		{
-			snprintf(file, sizeof(file),
-			    "%s/%s", pathname, d->d_name);
-			if (stat(file, &s) != 0) {
-				retval = false;
-				break;
-			}
-			if (S_ISDIR(s.st_mode)) {
-				if (!rm_dir(file, true))
-				{
-					retval = false;
-					break;
-				}
-			} else {
-				if (unlink(file)) {
-					retval = false;
-					break;
-				}
-			}
-		}
-	}
-	closedir(dp);
-
-	if (!retval)
-		return false;
-
-	if (top && rmdir(pathname) != 0)
-		return false;
-
-	return true;
-}
-
-/* Other systems may need this at some point, but for now it's Linux only */
-#ifdef __linux__
-static bool
-file_regex(const char *file, const char *regex)
-{
-	FILE *fp;
-	char *line = NULL;
-	size_t len = 0;
-	regex_t re;
-	bool retval = true;
-	int result;
-
-	if (!(fp = fopen(file, "r")))
-		return false;
-
-	if ((result = regcomp(&re, regex, REG_EXTENDED | REG_NOSUB)) != 0) {
-		fclose(fp);
-		line = xmalloc(sizeof(char) * BUFSIZ);
-		regerror(result, &re, line, BUFSIZ);
-		fprintf(stderr, "file_regex: %s", line);
-		free(line);
-		return false;
-	}
-
-	while ((rc_getline(&line, &len, fp))) {
-		char *str = line;
-		/* some /proc files have \0 separated content so we have to
-		   loop through the 'line' */
-		do {
-			if (regexec(&re, str, 0, NULL, 0) == 0)
-				goto found;
-			str += strlen(str) + 1;
-			/* len is the size of allocated buffer and we don't
-			   want call regexec BUFSIZE times. find next str */
-			while (str < line + len && *str == '\0')
-				str++;
-		} while (str < line + len);
-	}
-	retval = false;
-found:
-	fclose(fp);
-	free(line);
-	regfree(&re);
-
-	return retval;
-}
-#endif
-
-/* New sys identification code
- * Not to be used for any binaries outside of openrc. */
-const char *
-rc_sys_v2(void)
-{
-#define __STRING_SWITCH(x) { char *__string_switch = x; if (false) {}
-#define __STRING_CASE(y) else if (strcmp(__string_switch,y) == 0)
-#define __STRING_SWITCH_END() }
-	char *systype = rc_conf_value("rc_sys");
-	if (systype) {
-		char *s = systype;
-		/* Convert to uppercase */
-		while (s && *s) {
-			if (islower((unsigned char) *s))
-				*s = toupper((unsigned char) *s);
-			s++;
-		}
-		/* Now do detection */
-		__STRING_SWITCH(systype)
-		__STRING_CASE(RC_SYS_PREFIX)	{ return RC_SYS_PREFIX; }
-#ifdef __FreeBSD__
-		__STRING_CASE(RC_SYS_JAIL) { return RC_SYS_JAIL; }
-#endif /* __FreeBSD__ */
-#ifdef __NetBSD__
-		__STRING_CASE(RC_SYS_XEN0) { return RC_SYS_XEN0; }
-		__STRING_CASE(RC_SYS_XENU) { return RC_SYS_XENU; }
-#endif /* __NetBSD__ */
-#ifdef __linux__
-		__STRING_CASE(RC_SYS_XEN0) { return RC_SYS_XEN0; }
-		__STRING_CASE(RC_SYS_XENU) { return RC_SYS_XENU; }
-		__STRING_CASE(RC_SYS_UML) { return RC_SYS_UML; }
-		__STRING_CASE(RC_SYS_VSERVER) { return RC_SYS_VSERVER; }
-		__STRING_CASE(RC_SYS_OPENVZ) { return RC_SYS_OPENVZ; }
-		__STRING_CASE(RC_SYS_LXC) { return RC_SYS_LXC; }
-#endif /* __linux__ */
-		__STRING_SWITCH_END()
-	}
-#undef __STRING_SWITCH
-#undef __STRING_CASE
-#undef __STRING_SWITCH_END
-	return NULL;
-}
-librc_hidden_def(rc_sys_v2)
-
-/* Old sys identification code.
- * Not to be used for any binaries outside of openrc. */
-const char *
-rc_sys_v1(void)
-{
-#ifdef PREFIX
-	return RC_SYS_PREFIX;
-#else
-
-#ifdef __FreeBSD__
-	int jailed = 0;
-	size_t len = sizeof(jailed);
-
-	if (sysctlbyname("security.jail.jailed", &jailed, &len, NULL, 0) == 0)
-		if (jailed == 1)
-			return RC_SYS_JAIL;
-#endif
-
-#ifdef __NetBSD__
-	if (exists("/kern/xen/privcmd"))
-		return RC_SYS_XEN0;
-	if (exists("/kern/xen"))
-		return RC_SYS_XENU;
-#endif
-
-#ifdef __linux__
-	if (exists("/proc/xen")) {
-		if (file_regex("/proc/xen/capabilities", "control_d"))
-			return RC_SYS_XEN0;
-		return RC_SYS_XENU;
-	} else if (file_regex("/proc/cpuinfo", "UML"))
-		return RC_SYS_UML;
-	else if (file_regex("/proc/self/status",
-		"(s_context|VxID):[[:space:]]*[1-9]"))
-		return RC_SYS_VSERVER;
-	else if (exists("/proc/vz/veinfo") && !exists("/proc/vz/version"))
-		return RC_SYS_OPENVZ;
-	else if (file_regex("/proc/self/status",
-		"envID:[[:space:]]*[1-9]"))
-		return RC_SYS_OPENVZ; /* old test */
-	else if (file_regex("/proc/1/environ", "container=lxc"))
-		return RC_SYS_LXC;
-#endif
-
-	return NULL;
-#endif /* PREFIX */
-}
-librc_hidden_def(rc_sys_v1)
-
-const char *
-rc_sys(void)
-{
-	if (rc_conf_value("rc_sys")) {
-		return rc_sys_v2();
-	} else {
-		return rc_sys_v1();
-	}
-}
-librc_hidden_def(rc_sys)
-
-static const char *
-rc_parse_service_state(RC_SERVICE state)
-{
-	int i;
-
-	for (i = 0; rc_service_state_names[i].name; i++) {
-		if (rc_service_state_names[i].state == state)
-			return rc_service_state_names[i].name;
-	}
-	return NULL;
-}
-
-/* Returns a list of all the chained runlevels used by the
- * specified runlevel in dependency order, including the
- * specified runlevel. */
-static void
-get_runlevel_chain(const char *runlevel, RC_STRINGLIST *level_list)
-{
-	char path[PATH_MAX];
-	RC_STRINGLIST *dirs;
-	RC_STRING *d, *dn;
-
-	/*
-	 * If we haven't been passed a runlevel or a level list, or
-	 * if the passed runlevel doesn't exist then we're done already!
-	 */
-	if (!runlevel || !level_list || !rc_runlevel_exists(runlevel))
-		return;
-
-	/*
-	 * We want to add this runlevel to the list but if
-	 * it is already in the list it needs to go at the
-	 * end again.
-	 */
-	if (rc_stringlist_find(level_list, runlevel))
-		rc_stringlist_delete(level_list, runlevel);
-	rc_stringlist_add(level_list, runlevel);
-
-	/*
-	 * We can now do exactly the above procedure for our chained
-	 * runlevels.
-	 */
-	snprintf(path, sizeof(path), "%s/%s", RC_RUNLEVELDIR, runlevel);
-	dirs = ls_dir(path, LS_DIR);
-	TAILQ_FOREACH_SAFE(d, dirs, entries, dn)
-		get_runlevel_chain(d->value, level_list);
-}
-
-bool
-rc_runlevel_starting(void)
-{
-	return exists(RC_STARTING);
-}
-librc_hidden_def(rc_runlevel_starting)
-
-bool
-rc_runlevel_stopping(void)
-{
-	return exists(RC_STOPPING);
-}
-librc_hidden_def(rc_runlevel_stopping)
-
-RC_STRINGLIST *rc_runlevel_list(void)
-{
-	return ls_dir(RC_RUNLEVELDIR, LS_DIR);
-}
-librc_hidden_def(rc_runlevel_list)
-
-char *
-rc_runlevel_get(void)
-{
-	FILE *fp;
-	char *runlevel = NULL;
-	size_t i;
-
-	if ((fp = fopen(RC_RUNLEVEL, "r"))) {
-		runlevel = xmalloc(sizeof(char) * PATH_MAX);
-		if (fgets(runlevel, PATH_MAX, fp)) {
-			i = strlen(runlevel) - 1;
-			if (runlevel[i] == '\n')
-				runlevel[i] = 0;
-		} else
-			*runlevel = '\0';
-		fclose(fp);
-	}
-
-	if (!runlevel || !*runlevel) {
-		free(runlevel);
-		runlevel = xstrdup(RC_LEVEL_SYSINIT);
-	}
-
-	return runlevel;
-}
-librc_hidden_def(rc_runlevel_get)
-
-bool
-rc_runlevel_set(const char *runlevel)
-{
-	FILE *fp = fopen(RC_RUNLEVEL, "w");
-
-	if (!fp)
-		return false;
-	fprintf(fp, "%s", runlevel);
-	fclose(fp);
-	return true;
-}
-librc_hidden_def(rc_runlevel_set)
-
-bool
-rc_runlevel_exists(const char *runlevel)
-{
-	char path[PATH_MAX];
-	struct stat buf;
-
-	if (!runlevel || strcmp(runlevel, ".") == 0 || strcmp(runlevel, "..") == 0)
-		return false;
-	snprintf(path, sizeof(path), "%s/%s", RC_RUNLEVELDIR, runlevel);
-	if (stat(path, &buf) == 0 && S_ISDIR(buf.st_mode))
-		return true;
-	return false;
-}
-librc_hidden_def(rc_runlevel_exists)
-
-bool
-rc_runlevel_stack(const char *dst, const char *src)
-{
-	char d[PATH_MAX], s[PATH_MAX];
-
-	if (!rc_runlevel_exists(dst) || !rc_runlevel_exists(src))
-		return false;
-	snprintf(s, sizeof(s), "../%s", src);
-	snprintf(d, sizeof(s), "%s/%s/%s", RC_RUNLEVELDIR, dst, src);
-	return (symlink(s, d) == 0 ? true : false);
-}
-librc_hidden_def(rc_runlevel_stack)
-
-bool
-rc_runlevel_unstack(const char *dst, const char *src)
-{
-	char path[PATH_MAX];
-
-	snprintf(path, sizeof(path), "%s/%s/%s", RC_RUNLEVELDIR, dst, src);
-	return (unlink(path) == 0 ? true : false);
-}
-librc_hidden_def(rc_runlevel_unstack)
-
-RC_STRINGLIST *
-rc_runlevel_stacks(const char *runlevel)
-{
-	RC_STRINGLIST *stack;
-	stack = rc_stringlist_new();
-	get_runlevel_chain(runlevel, stack);
-	return stack;
-}
-librc_hidden_def(rc_runlevel_stacks)
-
-/* Resolve a service name to its full path */
-char *
-rc_service_resolve(const char *service)
-{
-	char buffer[PATH_MAX];
-	char file[PATH_MAX];
-	int r;
-	struct stat buf;
-
-	if (!service)
-		return NULL;
-
-	if (service[0] == '/')
-		return xstrdup(service);
-
-	/* First check started services */
-	snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s", "started", service);
-	if (lstat(file, &buf) || ! S_ISLNK(buf.st_mode)) {
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-		    "inactive", service);
-		if (lstat(file, &buf) || ! S_ISLNK(buf.st_mode))
-			*file = '\0';
-	}
-
-	if (*file) {
-		memset(buffer, 0, sizeof(buffer));
-		r = readlink(file, buffer, sizeof(buffer));
-		if (r > 0)
-			return xstrdup(buffer);
-	}
-
-#ifdef RC_LOCAL_INITDIR
-	/* Nope, so lets see if the user has written it */
-	snprintf(file, sizeof(file), RC_LOCAL_INITDIR "/%s", service);
-	if (stat(file, &buf) == 0)
-		return xstrdup(file);
-#endif
-
-	/* System scripts take precedence over 3rd party ones */
-	snprintf(file, sizeof(file), RC_INITDIR "/%s", service);
-	if (stat(file, &buf) == 0)
-		return xstrdup(file);
-
-#ifdef RC_PKG_INITDIR
-	/* Check RC_PKG_INITDIR */
-	snprintf(file, sizeof(file), RC_PKG_INITDIR "/%s", service);
-	if (stat(file, &buf) == 0)
-		return xstrdup(file);
-#endif
-
-	return NULL;
-}
-librc_hidden_def(rc_service_resolve)
-
-bool
-rc_service_exists(const char *service)
-{
-	char *file;
-	bool retval = false;
-	size_t len;
-	struct stat buf;
-
-	if (!service) {
-		errno = EINVAL;
-		return false;
-	}
-
-	len = strlen(service);
-
-	/* .sh files are not init scripts */
-	if (len > 2 && service[len - 3] == '.' &&
-	    service[len - 2] == 's' &&
-	    service[len - 1] == 'h') {
-		errno = EINVAL;
-		return false;
-	}
-
-	if (!(file = rc_service_resolve(service))) {
-		errno = ENOENT;
-		return false;
-	}
-
-	if (stat(file, &buf) == 0) {
-		if (buf.st_mode & S_IXUGO)
-			retval = true;
-		else
-			errno = ENOEXEC;
-	}
-	free(file);
-	return retval;
-}
-librc_hidden_def(rc_service_exists)
-
-#define OPTSTR \
-". '%s'; echo $extra_commands $extra_started_commands $extra_stopped_commands"
-
-RC_STRINGLIST *
-rc_service_extra_commands(const char *service)
-{
-	char *svc;
-	char *cmd = NULL;
-	char *buffer = NULL;
-	size_t len = 0;
-	RC_STRINGLIST *commands = NULL;
-	char *token;
-	char *p;
-	FILE *fp;
-	size_t l;
-
-	if (!(svc = rc_service_resolve(service)))
-		return NULL;
-
-	l = strlen(OPTSTR) + strlen(svc) + 1;
-	cmd = xmalloc(sizeof(char) * l);
-	snprintf(cmd, l, OPTSTR, svc);
-	free(svc);
-
-	if ((fp = popen(cmd, "r"))) {
-		rc_getline(&buffer, &len, fp);
-		p = buffer;
-		commands = rc_stringlist_new();
-
-		while ((token = strsep(&p, " ")))
-			if (token[0] != '\0')
-				rc_stringlist_add(commands, token);
-
-		pclose(fp);
-		free(buffer);
-	}
-
-	free(cmd);
-	return commands;
-}
-librc_hidden_def(rc_service_extra_commands)
-
-#define DESCSTR ". '%s'; echo \"${description%s%s}\""
-char *
-rc_service_description(const char *service, const char *option)
-{
-	char *svc;
-	char *cmd;
-	char *desc = NULL;
-	size_t len = 0;
-	FILE *fp;
-	size_t l;
-
-	if (!(svc = rc_service_resolve(service)))
-		return NULL;
-
-	if (!option)
-		option = "";
-
-	l = strlen(DESCSTR) + strlen(svc) + strlen(option) + 2;
-	cmd = xmalloc(sizeof(char) * l);
-	snprintf(cmd, l, DESCSTR, svc, *option ? "_" : "", option);
-	free(svc);
-	if ((fp = popen(cmd, "r"))) {
-		rc_getline(&desc, &len, fp);
-		pclose(fp);
-	}
-	free(cmd);
-	return desc;
-}
-librc_hidden_def(rc_service_description)
-
-bool
-rc_service_in_runlevel(const char *service, const char *runlevel)
-{
-	char file[PATH_MAX];
-
-	snprintf(file, sizeof(file), RC_RUNLEVELDIR "/%s/%s",
-	    runlevel, basename_c(service));
-	return exists(file);
-}
-librc_hidden_def(rc_service_in_runlevel)
-
-bool
-rc_service_mark(const char *service, const RC_SERVICE state)
-{
-	char file[PATH_MAX];
-	int i = 0;
-	int skip_state = -1;
-	const char *base;
-	char *init = rc_service_resolve(service);
-	bool skip_wasinactive = false;
-	int s;
-	char was[PATH_MAX];
-	RC_STRINGLIST *dirs;
-	RC_STRING *dir;
-	int serrno;
-
-	if (!init)
-		return false;
-
-	base = basename_c(service);
-	if (state != RC_SERVICE_STOPPED) {
-		if (!exists(init)) {
-			free(init);
-			return false;
-		}
-
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-		    rc_parse_service_state(state), base);
-		if (exists(file))
-			unlink(file);
-		i = symlink(init, file);
-		if (i != 0) {
-			free(init);
-			return false;
-		}
-		skip_state = state;
-	}
-
-	if (state == RC_SERVICE_HOTPLUGGED || state == RC_SERVICE_FAILED) {
-		free(init);
-		return true;
-	}
-
-	/* Remove any old states now */
-	for (i = 0; rc_service_state_names[i].name; i++) {
-		s = rc_service_state_names[i].state;
-
-		if ((s != skip_state &&
-			s != RC_SERVICE_STOPPED &&
-			s != RC_SERVICE_HOTPLUGGED &&
-			s != RC_SERVICE_SCHEDULED) &&
-		    (! skip_wasinactive || s != RC_SERVICE_WASINACTIVE))
-		{
-			snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-			    rc_service_state_names[i].name, base);
-			if (exists(file)) {
-				if ((state == RC_SERVICE_STARTING ||
-					state == RC_SERVICE_STOPPING) &&
-				    s == RC_SERVICE_INACTIVE)
-				{
-					snprintf(was, sizeof(was),
-					    RC_SVCDIR "/%s/%s",
-					    rc_parse_service_state(RC_SERVICE_WASINACTIVE),
-					    base);
-					if (symlink(init, was) == -1)
-						return false;
-					skip_wasinactive = true;
-				}
-				if (unlink(file) == -1) {
-					free(init);
-					return false;
-				}
-			}
-		}
-	}
-
-	/* Remove the exclusive state if we're inactive */
-	if (state == RC_SERVICE_STARTED ||
-	    state == RC_SERVICE_STOPPED ||
-	    state == RC_SERVICE_INACTIVE)
-	{
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-		    "exclusive", base);
-		unlink(file);
-	}
-
-	/* Remove any options and daemons the service may have stored */
-	if (state == RC_SERVICE_STOPPED) {
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-		    "options", base);
-		rm_dir(file, true);
-
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-		    "daemons", base);
-		rm_dir(file, true);
-
-		rc_service_schedule_clear(service);
-	}
-
-	/* These are final states, so remove us from scheduled */
-	if (state == RC_SERVICE_STARTED || state == RC_SERVICE_STOPPED) {
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s", "scheduled");
-		dirs = ls_dir(file, 0);
-		TAILQ_FOREACH(dir, dirs, entries) {
-			snprintf(was, sizeof(was), "%s/%s/%s",
-			    file, dir->value, base);
-			unlink(was);
-
-			/* Try and remove the dir; we don't care about errors */
-			snprintf(was, sizeof(was), "%s/%s", file, dir->value);
-			serrno = errno;
-			rmdir(was);
-			errno = serrno;
-		}
-		rc_stringlist_free(dirs);
-	}
-	free(init);
-	return true;
-}
-librc_hidden_def(rc_service_mark)
-
-RC_SERVICE
-rc_service_state(const char *service)
-{
-	int i;
-	int state = RC_SERVICE_STOPPED;
-	char file[PATH_MAX];
-	RC_STRINGLIST *dirs;
-	RC_STRING *dir;
-	const char *base = basename_c(service);
-
-	for (i = 0; rc_service_state_names[i].name; i++) {
-		snprintf(file, sizeof(file), RC_SVCDIR "/%s/%s",
-		    rc_service_state_names[i].name, base);
-		if (exists(file)) {
-			if (rc_service_state_names[i].state <= 0x10)
-				state = rc_service_state_names[i].state;
-			else
-				state |= rc_service_state_names[i].state;
-		}
-	}
-
-	if (state & RC_SERVICE_STOPPED) {
-		dirs = ls_dir(RC_SVCDIR "/scheduled", 0);
-		TAILQ_FOREACH(dir, dirs, entries) {
-			snprintf(file, sizeof(file),
-			    RC_SVCDIR "/scheduled/%s/%s",
-			    dir->value, service);
-			if (exists(file)) {
-				state |= RC_SERVICE_SCHEDULED;
-				break;
-			}
-		}
-		rc_stringlist_free(dirs);
-	}
-
-	return state;
-}
-librc_hidden_def(rc_service_state)
-
-char *
-rc_service_value_get(const char *service, const char *option)
-{
-	char *buffer = NULL;
-	size_t len = 0;
-	char file[PATH_MAX];
-
-	snprintf(file, sizeof(file), RC_SVCDIR "/options/%s/%s",
-	    service, option);
-	rc_getfile(file, &buffer, &len);
-
-	return buffer;
-}
-librc_hidden_def(rc_service_value_get)
-
-bool
-rc_service_value_set(const char *service, const char *option,
-    const char *value)
-{
-	FILE *fp;
-	char file[PATH_MAX];
-	char *p = file;
-
-	p += snprintf(file, sizeof(file), RC_SVCDIR "/options/%s", service);
-	if (mkdir(file, 0755) != 0 && errno != EEXIST)
-		return false;
-
-	snprintf(p, sizeof(file) - (p - file), "/%s", option);
-	if (!(fp = fopen(file, "w")))
-		return false;
-	if (value)
-		fprintf(fp, "%s", value);
-	fclose(fp);
-	return true;
-}
-librc_hidden_def(rc_service_value_set)
-
-
-bool
-rc_service_schedule_start(const char *service, const char *service_to_start)
-{
-	char file[PATH_MAX];
-	char *p = file;
-	char *init;
-	bool retval;
-
-	/* service may be a provided service, like net */
-	if (! service || ! rc_service_exists(service_to_start))
-		return false;
-
-	p += snprintf(file, sizeof(file), RC_SVCDIR "/scheduled/%s",
-	    basename_c(service));
-	if (mkdir(file, 0755) != 0 && errno != EEXIST)
-		return false;
-
-	init = rc_service_resolve(service_to_start);
-	snprintf(p, sizeof(file) - (p - file),
-	    "/%s", basename_c(service_to_start));
-	retval = (exists(file) || symlink(init, file) == 0);
-	free(init);
-	return retval;
-}
-librc_hidden_def(rc_service_schedule_start)
-
-bool
-rc_service_schedule_clear(const char *service)
-{
-	char dir[PATH_MAX];
-
-	snprintf(dir, sizeof(dir), RC_SVCDIR "/scheduled/%s",
-	    basename_c(service));
-	if (!rm_dir(dir, true) && errno == ENOENT)
-		return true;
-	return false;
-}
-librc_hidden_def(rc_service_schedule_clear)
-
-RC_STRINGLIST *
-rc_services_in_runlevel(const char *runlevel)
-{
-	char dir[PATH_MAX];
-	RC_STRINGLIST *list = NULL;
-
-	if (!runlevel) {
-#ifdef RC_PKG_INITDIR
-		RC_STRINGLIST *pkg = ls_dir(RC_PKG_INITDIR, LS_INITD);
-#endif
-#ifdef RC_LOCAL_INITDIR
-		RC_STRINGLIST *local = ls_dir(RC_LOCAL_INITDIR, LS_INITD);
-#endif
-
-		list = ls_dir(RC_INITDIR, LS_INITD);
-
-#ifdef RC_PKG_INITDIR
-		TAILQ_CONCAT(list, pkg, entries);
-		free(pkg);
-#endif
-#ifdef RC_LOCAL_INITDIR
-		TAILQ_CONCAT(list, local, entries);
-		free(local);
-#endif
-		return list;
-	}
-
-	/* These special levels never contain any services */
-	if (strcmp(runlevel, RC_LEVEL_SINGLE) != 0) {
-		snprintf(dir, sizeof(dir), RC_RUNLEVELDIR "/%s", runlevel);
-		list = ls_dir(dir, LS_INITD);
-	}
-	if (!list)
-		list = rc_stringlist_new();
-	return list;
-}
-librc_hidden_def(rc_services_in_runlevel)
-
-RC_STRINGLIST *
-rc_services_in_runlevel_stacked(const char *runlevel)
-{
-	RC_STRINGLIST *list, *stacks, *sl;
-	RC_STRING *stack;
-
-	list = rc_services_in_runlevel(runlevel);
-	stacks = rc_runlevel_stacks(runlevel);
-	TAILQ_FOREACH(stack, stacks, entries) {
-		sl = rc_services_in_runlevel(stack->value);
-		TAILQ_CONCAT(list, sl, entries);
-		free(sl);
-	}
-	return list;
-}
-librc_hidden_def(rc_services_in_runlevel_stacked)
-
-RC_STRINGLIST *
-rc_services_in_state(RC_SERVICE state)
-{
-	RC_STRINGLIST *services;
-	RC_STRINGLIST *list;
-	RC_STRINGLIST *dirs;
-	RC_STRING *d;
-	char dir[PATH_MAX];
-	char *p = dir;
-
-	p += snprintf(dir, sizeof(dir), RC_SVCDIR "/%s",
-	    rc_parse_service_state(state));
-
-	if (state != RC_SERVICE_SCHEDULED)
-		return ls_dir(dir, LS_INITD);
-
-	dirs = ls_dir(dir, 0);
-	list = rc_stringlist_new();
-	if (! dirs)
-		return list;
-
-	TAILQ_FOREACH(d, dirs, entries) {
-		snprintf(p, sizeof(dir) - (p - dir), "/%s", d->value);
-		services = ls_dir(dir, LS_INITD);
-		if (services) {
-			TAILQ_CONCAT(list, services, entries);
-			free(services);
-		}
-	}
-	rc_stringlist_free(dirs);
-	return list;
-}
-librc_hidden_def(rc_services_in_state)
-
-bool
-rc_service_add(const char *runlevel, const char *service)
-{
-	bool retval;
-	char *init;
-	char file[PATH_MAX];
-	char path[MAXPATHLEN] = { '\0' };
-	char *p = NULL;
-	char binit[PATH_MAX];
-	char *i;
-
-	if (!rc_runlevel_exists(runlevel)) {
-		errno = ENOENT;
-		return false;
-	}
-
-	if (rc_service_in_runlevel(service, runlevel)) {
-		errno = EEXIST;
-		return false;
-	}
-
-	i = init = rc_service_resolve(service);
-	snprintf(file, sizeof(file), RC_RUNLEVELDIR "/%s/%s",
-	    runlevel, basename_c(service));
-
-	/* We need to ensure that only things in /etc/init.d are added
-	 * to the boot runlevel */
-	if (strcmp(runlevel, RC_LEVEL_BOOT) == 0) {
-		p = realpath(dirname(init), path);
-		if (!*p) {
-			free(init);
-			return false;
-		}
-		if (strcmp(path, RC_INITDIR) != 0) {
-			free(init);
-			errno = EPERM;
-			return false;
-		}
-		snprintf(binit, sizeof(binit), RC_INITDIR "/%s", service);
-		i = binit;
-	}
-
-	retval = (symlink(i, file) == 0);
-	free(init);
-	return retval;
-}
-librc_hidden_def(rc_service_add)
-
-bool
-rc_service_delete(const char *runlevel, const char *service)
-{
-	char file[PATH_MAX];
-
-	snprintf(file, sizeof(file), RC_RUNLEVELDIR "/%s/%s",
-	    runlevel, basename_c(service));
-	if (unlink(file) == 0)
-		return true;
-	return false;
-}
-librc_hidden_def(rc_service_delete)
-
-RC_STRINGLIST *
-rc_services_scheduled_by(const char *service)
-{
-	RC_STRINGLIST *dirs = ls_dir(RC_SVCDIR "/scheduled", 0);
-	RC_STRINGLIST *list = rc_stringlist_new();
-	RC_STRING *dir;
-	char file[PATH_MAX];
-
-	TAILQ_FOREACH(dir, dirs, entries) {
-		snprintf(file, sizeof(file), RC_SVCDIR "/scheduled/%s/%s",
-		    dir->value, service);
-		if (exists(file))
-			rc_stringlist_add(list, file);
-	}
-	rc_stringlist_free(dirs);
-	return list;
-}
-librc_hidden_def(rc_services_scheduled_by)
-
-RC_STRINGLIST *
-rc_services_scheduled(const char *service)
-{
-	char dir[PATH_MAX];
-
-	snprintf(dir, sizeof(dir), RC_SVCDIR "/scheduled/%s",
-	    basename_c(service));
-	return ls_dir(dir, LS_INITD);
-}
-librc_hidden_def(rc_services_scheduled)
diff --git a/src/librc/librc.h b/src/librc/librc.h
deleted file mode 100644
index 0824eba7..00000000
--- a/src/librc/librc.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * librc.h
- * Internal header file to setup build env for files in librc.so
- */
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef _LIBRC_H_
-#define _LIBRC_H_
-
-#define _IN_LIBRC
-
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/wait.h>
-
-#include <ctype.h>
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <libgen.h>
-#include <limits.h>
-#include <paths.h>
-#include <regex.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <time.h>
-#include <unistd.h>
-
-#if defined(BSD) && !defined(__GNU__)
-#include <sys/param.h>
-#include <sys/user.h>
-#include <sys/sysctl.h>
-#include <kvm.h>
-#else
-#include <sys/param.h>
-#endif
-
-#include "rc.h"
-#include "rc-misc.h"
-
-#include "hidden-visibility.h"
-#define librc_hidden_proto(x) hidden_proto(x)
-#define librc_hidden_def(x) hidden_def(x)
-
-librc_hidden_proto(rc_conf_value)
-librc_hidden_proto(rc_config_list)
-librc_hidden_proto(rc_config_load)
-librc_hidden_proto(rc_config_value)
-librc_hidden_proto(rc_deptree_depend)
-librc_hidden_proto(rc_deptree_depends)
-librc_hidden_proto(rc_deptree_free)
-librc_hidden_proto(rc_deptree_load)
-librc_hidden_proto(rc_deptree_load_file)
-librc_hidden_proto(rc_deptree_order)
-librc_hidden_proto(rc_deptree_update)
-librc_hidden_proto(rc_deptree_update_needed)
-librc_hidden_proto(rc_find_pids)
-librc_hidden_proto(rc_getfile)
-librc_hidden_proto(rc_getline)
-librc_hidden_proto(rc_newer_than)
-librc_hidden_proto(rc_proc_getent)
-librc_hidden_proto(rc_older_than)
-librc_hidden_proto(rc_runlevel_exists)
-librc_hidden_proto(rc_runlevel_get)
-librc_hidden_proto(rc_runlevel_list)
-librc_hidden_proto(rc_runlevel_set)
-librc_hidden_proto(rc_runlevel_stack)
-librc_hidden_proto(rc_runlevel_stacks)
-librc_hidden_proto(rc_runlevel_starting)
-librc_hidden_proto(rc_runlevel_stopping)
-librc_hidden_proto(rc_runlevel_unstack)
-librc_hidden_proto(rc_service_add)
-librc_hidden_proto(rc_service_daemons_crashed)
-librc_hidden_proto(rc_service_daemon_set)
-librc_hidden_proto(rc_service_delete)
-librc_hidden_proto(rc_service_description)
-librc_hidden_proto(rc_service_exists)
-librc_hidden_proto(rc_service_extra_commands)
-librc_hidden_proto(rc_service_in_runlevel)
-librc_hidden_proto(rc_service_mark)
-librc_hidden_proto(rc_service_resolve)
-librc_hidden_proto(rc_service_schedule_clear)
-librc_hidden_proto(rc_service_schedule_start)
-librc_hidden_proto(rc_services_in_runlevel)
-librc_hidden_proto(rc_services_in_runlevel_stacked)
-librc_hidden_proto(rc_services_in_state)
-librc_hidden_proto(rc_services_scheduled)
-librc_hidden_proto(rc_services_scheduled_by)
-librc_hidden_proto(rc_service_started_daemon)
-librc_hidden_proto(rc_service_state)
-librc_hidden_proto(rc_service_value_get)
-librc_hidden_proto(rc_service_value_set)
-librc_hidden_proto(rc_stringlist_add)
-librc_hidden_proto(rc_stringlist_addu)
-librc_hidden_proto(rc_stringlist_delete)
-librc_hidden_proto(rc_stringlist_find)
-librc_hidden_proto(rc_stringlist_free)
-librc_hidden_proto(rc_stringlist_new)
-librc_hidden_proto(rc_stringlist_split)
-librc_hidden_proto(rc_stringlist_sort)
-librc_hidden_proto(rc_sys)
-librc_hidden_proto(rc_sys_v1)
-librc_hidden_proto(rc_sys_v2)
-librc_hidden_proto(rc_yesno)
-
-#endif
diff --git a/src/librc/rc.h.in b/src/librc/rc.h.in
deleted file mode 100644
index 58d8eb57..00000000
--- a/src/librc/rc.h.in
+++ /dev/null
@@ -1,619 +0,0 @@
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef __RC_H__
-#define __RC_H__
-
-#include <sys/types.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-/* __BEGIN_DECLS */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define RC_PREFIX "@PREFIX@"
-#define RC_SYSCONFDIR		"@SYSCONFDIR@"
-#define RC_LIBDIR               "@PREFIX@/@LIB@/rc"
-#define RC_LIBEXECDIR           "@LIBEXECDIR@"
-#if defined(PREFIX)
-#define RC_SVCDIR               RC_LIBEXECDIR "/init.d"
-#elif defined(__linux__) || (defined(__FreeBSD_kernel__) && \
-		defined(__GLIBC__)) || defined(__GNU__)
-#define RC_SVCDIR               "/run/openrc"
-#else
-#define RC_SVCDIR               RC_LIBEXECDIR "/init.d"
-#endif
-#define RC_RUNLEVELDIR          RC_SYSCONFDIR "/runlevels"
-#define RC_INITDIR              RC_SYSCONFDIR "/init.d"
-#define RC_CONFDIR              RC_SYSCONFDIR "/conf.d"
-#define RC_PLUGINDIR            RC_LIBDIR "/plugins"
-
-#define RC_PROFILE_ENV     RC_SYSCONFDIR "/profile.env"
-#define RC_SYS_WHITELIST   RC_LIBEXECDIR "/conf.d/env_whitelist"
-#define RC_USR_WHITELIST   RC_SYSCONFDIR "/conf.d/env_whitelist"
-#define RC_CONF         RC_SYSCONFDIR "/rc.conf"
-#define RC_CONF_OLD     RC_SYSCONFDIR "/conf.d/rc"
-
-#define RC_PATH_PREFIX     RC_LIBEXECDIR "/bin:/bin:/sbin:/usr/bin:/usr/sbin"
-
-/* PKG_PREFIX is where packages are installed if different from the base OS
- * On Gentoo this is normally unset, on FreeBSD /usr/local and on NetBSD
- * /usr/pkg. */
-#define RC_PKG_PREFIX		"@PKG_PREFIX@"
-#ifdef RC_PKG_PREFIX
-#  define RC_PKG_INITDIR        RC_PKG_PREFIX "/etc/init.d"
-#  define RC_PKG_CONFDIR        RC_PKG_PREFIX "/etc/conf.d"
-#endif
-
-/* LOCAL_PREFIX is for user written stuff, which the base OS and package
- * manger don't touch. */
-#define RC_LOCAL_PREFIX		"@LOCAL_PREFIX@"
-#ifdef RC_LOCAL_PREFIX
-#  define RC_LOCAL_INITDIR      RC_LOCAL_PREFIX "/etc/init.d"
-#  define RC_LOCAL_CONFDIR      RC_LOCAL_PREFIX "/etc/conf.d"
-#endif
-
-#ifndef _SYS_QUEUE_H_
-
-/*
- * The following are copied directly from our imported queue.h.
- */
-
-/*
- * 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 */	\
-}
-
-/*
- * Tail queue definitions.
- */
-#define	_TAILQ_HEAD(name, type, qual)					\
-struct name {								\
-	qual type *tqh_first;		/* first element */		\
-	qual type *qual *tqh_last;	/* addr of last next element */	\
-}
-#define TAILQ_HEAD(name, type)	_TAILQ_HEAD(name, struct type,)
-
-#define	TAILQ_HEAD_INITIALIZER(head)					\
-	{ TAILQ_END(head), &(head).tqh_first }
-
-#define	_TAILQ_ENTRY(type, qual)					\
-struct {								\
-	qual type *tqe_next;		/* next element */		\
-	qual type *qual *tqe_prev;	/* address of previous next element */\
-}
-#define TAILQ_ENTRY(type)	_TAILQ_ENTRY(struct type,)
-
-#endif /* _SYS_QUEUE_H_ */
-
-/* A doubly linked list using queue(3) for ease of use */
-typedef struct rc_string {
-	char *value;
-	TAILQ_ENTRY(rc_string) entries;
-} RC_STRING;
-typedef TAILQ_HEAD(rc_stringlist, rc_string) RC_STRINGLIST;
-
-/*! @name Reserved runlevel names */
-#define RC_LEVEL_SYSINIT    "sysinit"
-#define RC_LEVEL_SINGLE     "single"
-#define RC_LEVEL_SHUTDOWN   "shutdown"
-
-/*! Return the current runlevel.
- * @return the current runlevel */
-char *rc_runlevel_get(void);
-
-/*! Checks if the runlevel exists or not
- * @param runlevel to check
- * @return true if the runlevel exists, otherwise false */
-bool rc_runlevel_exists(const char *);
-
-/*! Stack a runlevel onto another
- * @param runlevel to stack onto
- * @param runlevel being stacked
- * @return true if successful, otherwise false */
-bool rc_runlevel_stack(const char *, const char *);
-
-/*! Unstack a runlevel from another
- * @param runlevel to unstack from
- * @param runlevel being unstacked
- * @return true if successful, otherwise false */
-bool rc_runlevel_unstack(const char *, const char *);
-
-/*! Return a NULL terminated list of runlevel stacks in the runlevels
- * @return a NULL terminated list of runlevels */
-RC_STRINGLIST *rc_runlevel_stacks(const char *);
-
-/*! Return a NULL terminated list of runlevels
- * @return a NULL terminated list of runlevels */
-RC_STRINGLIST *rc_runlevel_list(void);
-
-/*! Set the runlevel.
- * This just changes the stored runlevel and does not start or stop any
- * services.
- * @param runlevel to store */
-bool rc_runlevel_set(const char *);
-
-/*! Is the runlevel starting?
- * @return true if yes, otherwise false */
-bool rc_runlevel_starting(void);
-
-/*! Is the runlevel stopping?
- * @return true if yes, otherwise false */
-bool rc_runlevel_stopping(void);
-
-/*! @name RC
- * A service can be given as a full path or just its name.
- * If it's just a name then we try to resolve the service to a full path.
- * This should allow the use if local init.d directories in the future. */
-
-/*! @brief States a service can be in */
-typedef enum
-{
-	/* These are actual states
-	 * The service has to be in one only at all times */
-	RC_SERVICE_STOPPED     = 0x0001,
-	RC_SERVICE_STARTED     = 0x0002,
-	RC_SERVICE_STOPPING    = 0x0004,
-	RC_SERVICE_STARTING    = 0x0008,
-	RC_SERVICE_INACTIVE    = 0x0010,
-
-	/* Service may or may not have been hotplugged */
-	RC_SERVICE_HOTPLUGGED = 0x0100,
-
-	/* Optional states service could also be in */
-	RC_SERVICE_FAILED      = 0x0200,
-	RC_SERVICE_SCHEDULED   = 0x0400,
-	RC_SERVICE_WASINACTIVE = 0x0800
-} RC_SERVICE;
-
-/*! Add the service to the runlevel
- * @param runlevel to add to
- * @param service to add
- * @return true if successful, otherwise false */
-bool rc_service_add(const char *, const char *);
-
-/*! Remove the service from the runlevel
- * @param runlevel to remove from
- * @param service to remove
- * @return true if sucessful, otherwise false */
-bool rc_service_delete(const char *, const char *);
-
-/*! Save the arguments to find a running daemon
- * @param service to save arguments for
- * @param exec that we started
- * @param name of the process (optional)
- * @param pidfile of the process (optional)
- * @param started if true, add the arguments otherwise remove existing matching arguments */
-bool rc_service_daemon_set(const char *, const char *, const char *const *, const char *,
-			   bool);
-
-/*! Returns a description of what the service and/or option does.
- * @param service to check
- * @param option to check (if NULL, service description)
- * @return a newly allocated pointer to the description */
-char *rc_service_description(const char *, const char *);
-
-/*! Checks if a service exists or not.
- * @param service to check
- * @return true if service exists, otherwise false */
-bool rc_service_exists(const char *);
-
-/*! Checks if a service is in a runlevel
- * @param service to check
- * @param runlevel it should be in
- * @return true if service is in the runlevel, otherwise false */
-bool rc_service_in_runlevel(const char *, const char *);
-
-/*! Marks the service state
- * @param service to mark
- * @param state service should be in
- * @return true if service state change was successful, otherwise false */
-bool rc_service_mark(const char *, RC_SERVICE);
-
-/*! Lists the extra commands a service has
- * @param service to load the commands from
- * @return NULL terminated string list of commands */
-RC_STRINGLIST *rc_service_extra_commands(const char *);
-
-/*! Resolves a service name to its full path.
- * @param service to check
- * @return pointer to full path of service */
-char *rc_service_resolve(const char *);
-
-/*! Schedule a service to be started when another service starts
- * @param service that starts the scheduled service when started
- * @param service_to_start service that will be started */
-bool rc_service_schedule_start(const char *, const char *);
-
-/*! Return a NULL terminated list of services that are scheduled to start
- * when the given service has started
- * @param service to check
- * @return NULL terminated list of services scheduled to start */
-RC_STRINGLIST *rc_services_scheduled_by(const char *);
-
-/*! Clear the list of services scheduled to be started by this service
- * @param service to clear
- * @return true if no errors, otherwise false */
-bool rc_service_schedule_clear(const char *);
-
-/*! Checks if a service in in a state
- * @param service to check
- * @return state of the service */
-RC_SERVICE rc_service_state(const char *);
-
-/*! Check if the service started the daemon
- * @param service to check
- * @param exec to check
- * @param argv to check
- * @param indx of the daemon (optional - 1st daemon, 2nd daemon, etc)
- * @return true if started by this service, otherwise false */
-bool rc_service_started_daemon(const char *, const char *,
-			       const char *const *, int);
-
-/*! Return a saved value for a service
- * @param service to check
- * @param option to load
- * @return saved value */
-char *rc_service_value_get(const char *, const char *);
-
-/*! Save a persistent value for a service
- * @param service to save for
- * @param option to save
- * @param value of the option
- * @return true if saved, otherwise false */
-bool rc_service_value_set(const char *, const char *, const char *);
-
-/*! List the services in a runlevel
- * @param runlevel to list
- * @return NULL terminated list of services */
-RC_STRINGLIST *rc_services_in_runlevel(const char *);
-
-/*! List the stacked services in a runlevel
- * @param runlevel to list
- * @return NULL terminated list of services */
-RC_STRINGLIST *rc_services_in_runlevel_stacked(const char *);
-
-/*! List the services in a state
- * @param state to list
- * @return NULL terminated list of services */
-RC_STRINGLIST *rc_services_in_state(RC_SERVICE);
-
-/*! List the services shceduled to start when this one does
- * @param service to check
- * @return  NULL terminated list of services */
-RC_STRINGLIST *rc_services_scheduled(const char *);
-
-/*! Checks that all daemons started with start-stop-daemon by the service
- * are still running.
- * @param service to check
- * @return true if all daemons started are still running, otherwise false */
-bool rc_service_daemons_crashed(const char *);
-
-/*! @name System types
- * OpenRC can support some special sub system types, normally virtualization.
- * Some services cannot work in these systems, or we do something else. */
-#define RC_SYS_JAIL    "JAIL"
-#define RC_SYS_OPENVZ  "OPENVZ"
-#define RC_SYS_LXC     "LXC"
-#define RC_SYS_PREFIX  "PREFIX"
-#define RC_SYS_UML     "UML"
-#define RC_SYS_VSERVER "VSERVER"
-#define RC_SYS_XEN0    "XEN0"
-#define RC_SYS_XENU    "XENU"
-
-/*! Returns the type of subsystem
- * @return string from RC_SYS_* types or NULL if none detected */
-const char *rc_sys(void);
-
-/*! Returns the type of subsystem using old automatic code
- * @return string from RC_SYS_* types or NULL if none detected */
-const char *rc_sys_v1(void);
-
-/*! Returns the type of subsystem using new rc.conf rc_sys value
- * @return string from RC_SYS_* types or NULL if none detected */
-const char *rc_sys_v2(void);
-
-/*! @name Dependency options
- * These options can change the services found by the rc_get_depinfo and
- * rc_get_depends functions. */
-/*! Trace provided services */
-#define RC_DEP_TRACE    (1<<0)
-/*! Only use services added to runlevels */
-#define RC_DEP_STRICT   (1<<1)
-/*! Runlevel is starting */
-#define RC_DEP_START    (1<<2)
-/*! Runlevel is stopping */
-#define RC_DEP_STOP     (1<<3)
-
-/*! @name Dependencies
- * We analyse each init script and cache the resultant dependency tree.
- * This tree can be accessed using the below functions. */
-
-#ifdef _IN_LIBRC
-/*! @name Dependency structures
- * private to librc */
-
-/*! Singly linked list of dependency types that list the services the
- * type is for */
-typedef struct rc_deptype
-{
-	/*! ineed, iuse, iafter, etc */
-	char *type;
-	/*! list of services */
-	RC_STRINGLIST *services;
-	/*! list of types */
-	TAILQ_ENTRY(rc_deptype) entries;
-} RC_DEPTYPE;
-
-/*! Singly linked list of services and their dependencies */
-typedef struct rc_depinfo
-{
-	/*! Name of service */
-	char *service;
-	/*! Dependencies */
-	TAILQ_HEAD(, rc_deptype) depends;
-	/*! List of entries */
-	TAILQ_ENTRY(rc_depinfo) entries;
-} RC_DEPINFO;
-
-typedef TAILQ_HEAD(,rc_depinfo) RC_DEPTREE;
-#else
-/* Handles to internal structures */
-typedef void *RC_DEPTREE;
-#endif
-
-/*! Check to see if source is newer than target.
- * If target is a directory then we traverse it and its children.
- * @param source
- * @param target
- * @param mtime of newest target
- * @param filename of the newest target (needs mtime param)
- * @return true if source is newer than target, otherwise false */
-bool rc_newer_than(const char *, const char *, time_t *, char *);
-
-/*! Check to see if source is older than target.
- * If target is a directory then we traverse it and its children.
- * @param source
- * @param target
- * @param mtime of oldest target
- * @param filename of the oldest target (needs mtime param)
- * @return true if source is older than target, otherwise false */
-bool rc_older_than(const char *, const char *, time_t *, char *);
-
-/*! Read variables/values from /proc/cmdline
- * @param value
- * @return pointer to the value, otherwise NULL */
-char *rc_proc_getent(const char *);
-
-/*! Update the cached dependency tree if it's older than any init script,
- * its configuration file or an external configuration file the init script
- * has specified.
- * time_t returns the time of the newest file that the dependency tree
- * will be checked against.
- * @return true if successful, otherwise false */
-bool rc_deptree_update(void);
-
-/*! Check if the cached dependency tree is older than any init script,
- * its configuration file or an external configuration file the init script
- * has specified.
- * @param mtime of newest file
- * @param buffer of PATH_MAX to store newest file
- * @return true if it needs updating, otherwise false */
-bool rc_deptree_update_needed(time_t *, char *);
-
-/*! Load the cached dependency tree and return a pointer to it.
- * This pointer should be freed with rc_deptree_free when done.
- * @return pointer to the dependency tree */
-RC_DEPTREE *rc_deptree_load(void);
-
-/*! Load a cached dependency tree from the specified file and return a pointer
- * to it.  This pointer should be freed with rc_deptree_free when done.
- * @return pointer to the dependency tree */
-RC_DEPTREE *rc_deptree_load_file(const char *);
-
-/*! List the depend for the type of service
- * @param deptree to search
- * @param type to use (keywords, etc)
- * @param service to check
- * @return NULL terminated list of services in order */
-RC_STRINGLIST *rc_deptree_depend(const RC_DEPTREE *, const char *, const char *);
-
-/*! List all the services in order that the given services have
- * for the given types and options.
- * @param deptree to search
- * @param types to use (ineed, iuse, etc)
- * @param services to check
- * @param options to pass
- * @return NULL terminated list of services in order */
-RC_STRINGLIST *rc_deptree_depends(const RC_DEPTREE *, const RC_STRINGLIST *,
-				  const RC_STRINGLIST *, const char *, int);
-
-/*! List all the services that should be stoppned and then started, in order,
- * for the given runlevel, including sysinit and boot services where
- * approriate.
- * @param deptree to search
- * @param runlevel to change into
- * @param options to pass
- * @return NULL terminated list of services in order */
-RC_STRINGLIST *rc_deptree_order(const RC_DEPTREE *, const char *, int);
-
-/*! Free a deptree and its information
- * @param deptree to free */
-void rc_deptree_free(RC_DEPTREE *);
-
-/*! @name Plugins
- * For each plugin loaded we will call rc_plugin_hook with the below
- * enum and either the runlevel name or service name.
- *
- * Plugins are called when rc does something. This does not indicate an
- * end result and the plugin should use the above functions to query things
- * like service status.
- *
- * The service hooks have extra ones - now and done. This is because after
- * start_in we may start other services before we start the service in
- * question. now shows we really will start the service now and done shows
- * when we have done it as may start scheduled services at this point. */
-/*! Points at which a plugin can hook into RC */
-typedef enum
-{
-	RC_HOOK_RUNLEVEL_STOP_IN   = 1,
-	RC_HOOK_RUNLEVEL_STOP_OUT  = 4,
-	RC_HOOK_RUNLEVEL_START_IN  = 5,
-	RC_HOOK_RUNLEVEL_START_OUT = 8,
-	/*! We send the abort if an init script requests we abort and drop
-	 * into single user mode if system not fully booted */
-	RC_HOOK_ABORT              = 99,
-	RC_HOOK_SERVICE_STOP_IN    = 101,
-	RC_HOOK_SERVICE_STOP_NOW   = 102,
-	RC_HOOK_SERVICE_STOP_DONE  = 103,
-	RC_HOOK_SERVICE_STOP_OUT   = 104,
-	RC_HOOK_SERVICE_START_IN   = 105,
-	RC_HOOK_SERVICE_START_NOW  = 106,
-	RC_HOOK_SERVICE_START_DONE = 107,
-	RC_HOOK_SERVICE_START_OUT  = 108
-} RC_HOOK;
-
-/*! Plugin entry point
- * @param hook point
- * @param name of runlevel or service
- * @return 0 for success otherwise -1 */
-int rc_plugin_hook(RC_HOOK, const char *);
-
-/*! Plugins should write FOO=BAR to this fd to set any environment
- * variables they wish. Variables should be separated by NULLs. */
-extern FILE *rc_environ_fd;
-
-
-/*! Return a NULL terminated list of non comment lines from a file. */
-RC_STRINGLIST *rc_config_list(const char *);
-
-/*! Return a NULL terminated list of key=value lines from a file. */
-RC_STRINGLIST *rc_config_load(const char *);
-
-/*! Return the value of the entry from a key=value list. */
-char *rc_config_value(RC_STRINGLIST *, const char *);
-
-/*! Return the value of the entry from rc.conf. */
-char *rc_conf_value(const char *);
-
-/*! Check if a variable is a boolean and return its value.
- * If variable is not a boolean then we set errno to be ENOENT when it does
- * not exist or EINVAL if it's not a boolean.
- * @param variable to check
- * @return true if it matches true, yes or 1, false if otherwise. */
-bool rc_yesno(const char *);
-
-/*! @name String List functions
- * Every string list should be released with a call to rc_stringlist_free. */
-
-/*! Create a new stringlinst
- * @return pointer to new list */
-RC_STRINGLIST *rc_stringlist_new(void);
-
-/*! Duplicate the item, add it to end of the list and return a pointer to it.
- * @param list to add the item too
- * @param item to add.
- * @return pointer to newly added item */
-RC_STRING *rc_stringlist_add(RC_STRINGLIST *, const char *);
-
-/*! If the item does not exist in the list, duplicate it, add it to the
- * list and then return a pointer to it.
- * @param list to add the item too
- * @param item to add.
- * @return pointer to newly added item */
-RC_STRING *rc_stringlist_addu(RC_STRINGLIST *, const char *);
-
-/*! Free the item and remove it from the list. Return 0 on success otherwise -1.
- * @param list to add the item too
- * @param item to add.
- * @return true on success, otherwise false */
-bool rc_stringlist_delete(RC_STRINGLIST *, const char *);
-
-/*! Find the item on the list.
- * @param list to search
- * @param item to find.
- * @return pointer to item */
-RC_STRING *rc_stringlist_find(RC_STRINGLIST *, const char *);
-
-/*! Split a string into a stringlist based on separator.
- * @param string to split
- * @param separator
- * @return new list */
-RC_STRINGLIST *rc_stringlist_split(const char *, const char *);
-
-
-/*! Sort the list according to C locale
- * @param list to sort */
-void rc_stringlist_sort(RC_STRINGLIST **);
-
-/*! Frees each item on the list and the list itself.
- * @param list to free */
-void rc_stringlist_free(RC_STRINGLIST *);
-
-typedef struct rc_pid
-{
-	pid_t pid;
-	LIST_ENTRY(rc_pid) entries;
-} RC_PID;
-typedef LIST_HEAD(rc_pidlist, rc_pid) RC_PIDLIST;
-
-/*! Find processes based on criteria.
- * All of these are optional.
- * pid overrides anything else.
- * If both exec and cmd are given then we ignore exec.
- * @param exec to check for
- * @param argv to check for
- * @param uid to check for
- * @param pid to check for
- * @return NULL terminated list of pids */
-RC_PIDLIST *rc_find_pids(const char *, const char *const *, uid_t, pid_t);
-
-/* Basically the same as rc_getline() below, it just returns multiple lines */
-bool rc_getfile(const char *, char **, size_t *);
-
-/* getline is a handy glibc function that not all libcs have, so
- * we have our own */
-ssize_t rc_getline(char **, size_t *, FILE *);
-
-/* __END_DECLS */
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/librc/rc.map b/src/librc/rc.map
deleted file mode 100644
index 2aa58dea..00000000
--- a/src/librc/rc.map
+++ /dev/null
@@ -1,68 +0,0 @@
-RC_1.0 {
-global:
-	rc_conf_value;
-	rc_config_list;
-	rc_config_load;
-	rc_config_value;
-	rc_deptree_depend;
-	rc_deptree_depends;
-	rc_deptree_free;
-	rc_deptree_load;
-	rc_deptree_load_file;
-	rc_deptree_order;
-	rc_deptree_update;
-	rc_deptree_update_needed;
-	rc_environ_fd;
-	rc_find_pids;
-	rc_getfile;
-	rc_getline;
-	rc_newer_than;
-	rc_older_than;
-	rc_proc_getent;
-	rc_runlevel_exists;
-	rc_runlevel_get;
-	rc_runlevel_list;
-	rc_runlevel_set;
-	rc_runlevel_stack;
-	rc_runlevel_stacks;
-	rc_runlevel_starting;
-	rc_runlevel_stopping;
-	rc_runlevel_unstack;
-	rc_service_add;
-	rc_service_daemons_crashed;
-	rc_service_daemon_set;
-	rc_service_delete;
-	rc_service_description;
-	rc_service_exists;
-	rc_service_extra_commands;
-	rc_service_in_runlevel;
-	rc_service_mark;
-	rc_service_options;
-	rc_service_resolve;
-	rc_service_schedule_clear;
-	rc_service_schedule_start;
-	rc_services_in_runlevel;
-	rc_services_in_runlevel_stacked;
-	rc_services_in_state;
-	rc_services_scheduled;
-	rc_services_scheduled_by;
-	rc_service_started_daemon;
-	rc_service_state;
-	rc_service_value_get;
-	rc_service_value_set;
-	rc_stringlist_add;
-	rc_stringlist_addu;
-	rc_stringlist_delete;
-	rc_stringlist_find;
-	rc_stringlist_split;
-	rc_stringlist_new;
-	rc_stringlist_sort;
-	rc_stringlist_free;
-	rc_sys;
-	rc_sys_v1;
-	rc_sys_v2;
-	rc_yesno;
-
-local:
-	*;
-};
diff --git a/src/rc/.gitignore b/src/rc/.gitignore
deleted file mode 100644
index bbfede6a..00000000
--- a/src/rc/.gitignore
+++ /dev/null
@@ -1,61 +0,0 @@
-version.h
-rc-status
-rc-service
-rc-update
-runscript
-service
-start-stop-daemon
-einfon
-einfo
-ewarnn
-ewarn
-eerrorn
-eerror
-ebegin
-eend
-ewend
-eindent
-eoutdent
-esyslog
-eval_ecolors
-ewaitfile
-veinfo
-vewarn
-vebegin
-veend
-vewend
-veindent
-veoutdent
-service_starting
-service_started
-service_stopping
-service_stopped
-service_inactive
-service_wasinactive
-service_hotplugged
-service_started_daemon
-service_crashed
-checkpath
-fstabinfo
-mountinfo
-swclock
-rc-depend
-service_get_value
-service_set_value
-get_options
-save_options
-shell_var
-is_newer_than
-is_older_than
-mark_service_starting
-mark_service_started
-mark_service_stopping
-mark_service_stopped
-mark_service_inactive
-mark_service_wasinactive
-mark_service_hotplugged
-mark_service_failed
-rc-abort
-rc
-openrc
-openrc-run
diff --git a/src/rc/Makefile b/src/rc/Makefile
deleted file mode 100644
index bd8b942c..00000000
--- a/src/rc/Makefile
+++ /dev/null
@@ -1,99 +0,0 @@
-PROG=		openrc
-SRCS=		checkpath.c fstabinfo.c mountinfo.c start-stop-daemon.c \
-		rc-applets.c rc-depend.c rc-logger.c \
-		rc-misc.c rc-plugin.c rc-service.c rc-status.c rc-update.c \
-		runscript.c rc.c swclock.c
-
-ifeq (${MKSELINUX},yes)
-SRCS+=		rc-selinux.c
-endif
-
-CLEANFILES=	version.h rc-selinux.o
-
-BINDIR=		${PREFIX}/bin
-SBINDIR=	${PREFIX}/sbin
-LINKDIR=	${LIBEXECDIR}
-
-BINLINKS=	rc-status
-SBINLINKS=	rc rc-service rc-update openrc-run runscript service \
-			start-stop-daemon
-RC_BINLINKS=	einfon einfo ewarnn ewarn eerrorn eerror ebegin eend ewend \
-		eindent eoutdent esyslog eval_ecolors ewaitfile \
-		veinfo vewarn vebegin veend vewend veindent veoutdent \
-		service_starting service_started \
-		service_stopping service_stopped \
-		service_inactive service_wasinactive \
-		service_hotplugged service_started_daemon service_crashed \
-		checkpath fstabinfo mountinfo rc-depend \
-		service_get_value service_set_value get_options save_options \
-		shell_var is_newer_than is_older_than
-RC_SBINLINKS=	mark_service_starting mark_service_started \
-		mark_service_stopping mark_service_stopped \
-		mark_service_inactive mark_service_wasinactive \
-		mark_service_hotplugged mark_service_failed \
-		rc-abort swclock
-ALL_LINKS=	${BINLINKS} ${SBINLINKS} ${RC_BINLINKS} ${RC_SBINLINKS}
-CLEANFILES+=	${ALL_LINKS}
-
-CPPFLAGS+=	-I../includes -I../librc -I../libeinfo
-LDFLAGS+=	-L../librc -L../libeinfo
-LDADD+=		-lutil -lrc -leinfo
-
-include ../../Makefile.inc
-MK=		../../mk
-include ${MK}/prog.mk
-include ${MK}/git.mk
-include ${MK}/cc.mk
-
-include ${MK}/termcap.mk
-LDADD+=		${LIBDL} ${LIBKVM}
-include ${MK}/pam.mk
-
-# create symlinks to rc if not an SELINUX system, otherwise create a wrapper
-# script to call rc with the proper name of the applet to execute.
-# $1 is a list of the links
-# $2 is the path+name of the target to link to (usually 'rc' or '/sbin/rc')
-# $3 is the path where the links are created
-define make-links
-	for x in $(1); do \
-		if [ "${MKSELINUX}" = yes ]; then \
-			printf '#!/bin/sh\nexec ${2} --applet %s "$$@"\n' $$x >${3}/$$x; \
-			chmod ${BINMODE} ${3}/$$x; \
-		else \
-			ln -sf ${2} ${3}/$$x; \
-		fi; \
-	done;
-endef
-
-${SRCS}: version.h
-
-.PHONY:	version.h.tmp
-version.h.tmp:
-	echo "#define VERSION \"${VERSION}${GITVER}\"" >$@
-	if test -n "${BRANDING}"; then \
-		echo "#define BRANDING \"${BRANDING}\"" >> $@; \
-	fi
-
-version.h: version.h.tmp
-	cmp -s $@.tmp $@ && rm $@.tmp || mv $@.tmp $@
-
-install: all
-	${INSTALL} -d ${DESTDIR}${SBINDIR}
-	${INSTALL} -m ${BINMODE} ${PROG} ${DESTDIR}${SBINDIR}
-	${INSTALL} -d ${DESTDIR}${BINDIR}
-	$(call make-links,${BINLINKS},${SBINDIR}/${PROG},${DESTDIR}${BINDIR})
-	${INSTALL} -d ${DESTDIR}${SBINDIR}
-	$(call make-links,${SBINLINKS},${SBINDIR}/${PROG},${DESTDIR}${SBINDIR})
-	${INSTALL} -d ${DESTDIR}${LINKDIR}/bin
-	$(call make-links,${RC_BINLINKS},${SBINDIR}/${PROG},${DESTDIR}${LINKDIR}/bin)
-	${INSTALL} -d ${DESTDIR}${LINKDIR}/sbin
-	$(call make-links, ${RC_SBINLINKS},${SBINDIR}/${PROG},${DESTDIR}${LINKDIR}/sbin)
-	if test "${MKPAM}" = pam; then \
-		${INSTALL} -d ${DESTDIR}${PAMDIR}; \
-		${INSTALL} -m ${PAMMODE} start-stop-daemon.pam ${DESTDIR}${PAMDIR}/start-stop-daemon; \
-	fi
-
-check test::
-
-links: ${PROG}
-	$(call make-links,${ALL_LINKS},${PROG},.)
diff --git a/src/rc/_usage.c b/src/rc/_usage.c
deleted file mode 100644
index a95e93f5..00000000
--- a/src/rc/_usage.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 "version.h"
-#include <ctype.h>
-
-#if lint
-#  define _noreturn
-#endif
-#if __GNUC__ > 2 || defined(__INTEL_COMPILER)
-#  define _noreturn __attribute__ ((__noreturn__))
-#else
-#  define _noreturn
-#endif
-
-static void set_quiet_options(void)
-{
-	static int qcount = 0;
-
-	qcount ++;
-	switch (qcount) {
-	case 1:
-		setenv ("EINFO_QUIET", "YES", 1);
-		break;
-	case 2:
-		setenv ("EERROR_QUIET", "YES", 1);
-		break;
-	}
-}
-
-_noreturn static void
-show_version(void)
-{
-	const char *bootlevel = NULL;
-
-	printf("%s (OpenRC", applet);
-	if ((bootlevel = rc_sys()))
-		printf(" [%s]", bootlevel);
-	printf(") %s", VERSION);
-#ifdef BRANDING
-	printf(" (%s)", BRANDING);
-#endif
-	printf("\n");
-	exit(EXIT_SUCCESS);
-}
-
-_noreturn static void
-usage(int exit_status)
-{
-	const char * const has_arg[] = { "", "<arg>", "[arg]" };
-	int i;
-	int len;
-	char *lo;
-	char *p;
-	char *token;
-	char val[4] = "-?,";
-
-#ifdef usagestring
-	printf(usagestring);
-#else
-	printf("Usage: %s [options] ", applet);
-#endif
-#ifdef extraopts
-	printf(extraopts);
-#endif
-	printf("\n\nOptions: [" getoptstring "]\n");
-	for (i = 0; longopts[i].name; ++i) {
-		val[1] = longopts[i].val;
-		len = printf("  %3s --%s %s", isprint(longopts[i].val) ? val : "",
-		    longopts[i].name, has_arg[longopts[i].has_arg]);
-
-		lo = p = xstrdup(longopts_help[i]);
-		while ((token = strsep(&p, "\n"))) {
-			len = 36 - len;
-			if (len > 0)
-				printf("%*s", len, "");
-			puts(token);
-			len = 0;
-		}
-		free(lo);
-	}
-	exit(exit_status);
-}
diff --git a/src/rc/_usage.h b/src/rc/_usage.h
deleted file mode 100644
index 0560e89f..00000000
--- a/src/rc/_usage.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#define getoptstring_COMMON "ChqVv"
-
-#define longopts_COMMON							      \
-	{ "help",           0, NULL, 'h'},				      \
-	{ "nocolor",        0, NULL, 'C'},				      \
-	{ "version",        0, NULL, 'V'},				      \
-	{ "verbose",        0, NULL, 'v'},				      \
-	{ "quiet",          0, NULL, 'q'},				      \
-	{ NULL,             0, NULL,  0 }
-
-#define longopts_help_COMMON						      \
-	"Display this help output",					      \
-	"Disable color output",						      \
-	"Display software version",			              \
-	"Run verbosely",						      \
-	"Run quietly (repeat to suppress errors)"
-
-#define case_RC_COMMON_getopt_case_C  setenv ("EINFO_COLOR", "NO", 1);
-#define case_RC_COMMON_getopt_case_h  usage (EXIT_SUCCESS);
-#define case_RC_COMMON_getopt_case_V  if (argc == 2) show_version();
-#define case_RC_COMMON_getopt_case_v  setenv ("EINFO_VERBOSE", "YES", 1);
-#define case_RC_COMMON_getopt_case_q  set_quiet_options();
-#define case_RC_COMMON_getopt_default usage (EXIT_FAILURE);
-
-#define case_RC_COMMON_GETOPT						      \
-	case 'C': case_RC_COMMON_getopt_case_C; break;			      \
-	case 'h': case_RC_COMMON_getopt_case_h; break;			      \
-	case 'V': case_RC_COMMON_getopt_case_V; break;			      \
-	case 'v': case_RC_COMMON_getopt_case_v; break;			      \
-	case 'q': case_RC_COMMON_getopt_case_q; break;			      \
-	default:  case_RC_COMMON_getopt_default; break;
diff --git a/src/rc/builtins.h b/src/rc/builtins.h
deleted file mode 100644
index d9bb9849..00000000
--- a/src/rc/builtins.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 "queue.h"
-#include "rc.h"
-
-int checkpath(int, char **);
-int fstabinfo(int, char **);
-int mountinfo(int, char **);
-int openrc_run(int, char **);
-int rc_depend(int, char **);
-int rc_service(int, char **);
-int rc_status(int, char **);
-int rc_update(int, char **);
-int runscript(int, char **);
-int start_stop_daemon(int, char **);
-int swclock(int, char **);
-
-void run_applets(int, char **);
-
-/* Handy function so we can wrap einfo around our deptree */
-RC_DEPTREE *_rc_deptree_load (int, int *);
-
-/* Test to see if we can see pid 1 or not */
-bool _rc_can_find_pids(void);
diff --git a/src/rc/checkpath.c b/src/rc/checkpath.c
deleted file mode 100644
index 94ab4742..00000000
--- a/src/rc/checkpath.c
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
-  checkpath.c
-  Checks for the existance of a file or directory and creates it
-  if necessary. It can also correct its ownership.
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <grp.h>
-#include <pwd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "rc-misc.h"
-
-#ifdef HAVE_SELINUX
-#include "rc-selinux.h"
-#endif
-
-typedef enum {
-	inode_unknown = 0,
-	inode_file = 1,
-	inode_dir = 2,
-	inode_fifo = 3,
-} inode_t;
-
-extern const char *applet;
-
-static int do_check(char *path, uid_t uid, gid_t gid, mode_t mode,
-	inode_t type, bool trunc, bool chowner, bool selinux_on)
-{
-	struct stat st;
-	int fd, flags;
-	int r;
-	int u;
-
-	memset(&st, 0, sizeof(st));
-	if (stat(path, &st) || trunc) {
-		if (type == inode_file) {
-			einfo("%s: creating file", path);
-			if (!mode) /* 664 */
-				mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
-			flags = O_CREAT|O_NDELAY|O_WRONLY|O_NOCTTY;
-#ifdef O_CLOEXEC
-			flags |= O_CLOEXEC;
-#endif
-#ifdef O_NOFOLLOW
-			flags |= O_NOFOLLOW;
-#endif
-			if (trunc)
-				flags |= O_TRUNC;
-			u = umask(0);
-			fd = open(path, flags, mode);
-			umask(u);
-			if (fd == -1) {
-				eerror("%s: open: %s", applet, strerror(errno));
-				return -1;
-			}
-			close (fd);
-		} else if (type == inode_dir) {
-			einfo("%s: creating directory", path);
-			if (!mode) /* 775 */
-				mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH;
-			u = umask(0);
-			/* We do not recursively create parents */
-			r = mkdir(path, mode);
-			umask(u);
-			if (r == -1 && errno != EEXIST) {
-				eerror("%s: mkdir: %s", applet,
-				    strerror (errno));
-				return -1;
-			}
-			mode = 0;
-		} else if (type == inode_fifo) {
-			einfo("%s: creating fifo", path);
-			if (!mode) /* 600 */
-				mode = S_IRUSR | S_IWUSR;
-			u = umask(0);
-			r = mkfifo(path, mode);
-			umask(u);
-			if (r == -1 && errno != EEXIST) {
-				eerror("%s: mkfifo: %s", applet,
-				    strerror (errno));
-				return -1;
-			}
-		}
-	} else {
-		if (type != inode_dir && S_ISDIR(st.st_mode)) {
-			eerror("%s: is a directory", path);
-			return 1;
-		}
-		if (type != inode_file && S_ISREG(st.st_mode)) {
-			eerror("%s: is a file", path);
-			return 1;
-		}
-		if (type != inode_fifo && S_ISFIFO(st.st_mode)) {
-			eerror("%s: is a fifo", path);
-			return -1;
-		}
-	}
-
-	if (mode && (st.st_mode & 0777) != mode) {
-		einfo("%s: correcting mode", path);
-		if (chmod(path, mode)) {
-			eerror("%s: chmod: %s", applet, strerror(errno));
-			return -1;
-		}
-	}
-
-	if (chowner && (st.st_uid != uid || st.st_gid != gid)) {
-		einfo("%s: correcting owner", path);
-		if (chown(path, uid, gid)) {
-			eerror("%s: chown: %s", applet, strerror(errno));
-			return -1;
-		}
-	}
-
-#ifdef HAVE_SELINUX
-	if (selinux_on)
-		selinux_util_label(path);
-#endif
-
-	return 0;
-}
-
-static int parse_owner(struct passwd **user, struct group **group,
-	const char *owner)
-{
-	char *u = xstrdup (owner);
-	char *g = strchr (u, ':');
-	int id = 0;
-	int retval = 0;
-
-	if (g)
-		*g++ = '\0';
-
-	if (user && *u) {
-		if (sscanf(u, "%d", &id) == 1)
-			*user = getpwuid((uid_t) id);
-		else
-			*user = getpwnam(u);
-		if (*user == NULL)
-			retval = -1;
-	}
-
-	if (group && g && *g) {
-		if (sscanf(g, "%d", &id) == 1)
-			*group = getgrgid((gid_t) id);
-		else
-			*group = getgrnam(g);
-		if (*group == NULL)
-			retval = -1;
-	}
-
-	free(u);
-	return retval;
-}
-
-#include "_usage.h"
-#define extraopts "path1 [path2] [...]"
-#define getoptstring "dDfFpm:o:W" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "directory",          0, NULL, 'd'},
-	{ "directory-truncate", 0, NULL, 'D'},
-	{ "file",               0, NULL, 'f'},
-	{ "file-truncate",      0, NULL, 'F'},
-	{ "pipe",               0, NULL, 'p'},
-	{ "mode",               1, NULL, 'm'},
-	{ "owner",              1, NULL, 'o'},
-	{ "writable",           0, NULL, 'W'},
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"Create a directory if not exists",
-	"Create/empty directory",
-	"Create a file if not exists",
-	"Truncate file",
-	"Create a named pipe (FIFO) if not exists",
-	"Mode to check",
-	"Owner to check (user:group)",
-	"Check whether the path is writable or not",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int checkpath(int argc, char **argv)
-{
-	int opt;
-	uid_t uid = geteuid();
-	gid_t gid = getgid();
-	mode_t mode = 0;
-	struct passwd *pw = NULL;
-	struct group *gr = NULL;
-	inode_t type = inode_unknown;
-	int retval = EXIT_SUCCESS;
-	bool trunc = false;
-	bool chowner = false;
-	bool writable = false;
-	bool selinux_on = false;
-
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 'D':
-			trunc = true;
-		case 'd':
-			type = inode_dir;
-			break;
-		case 'F':
-			trunc = true;
-		case 'f':
-			type = inode_file;
-			break;
-		case 'p':
-			type = inode_fifo;
-			break;
-		case 'm':
-			if (parse_mode(&mode, optarg) != 0)
-				eerrorx("%s: invalid mode `%s'",
-				    applet, optarg);
-			break;
-		case 'o':
-			chowner = true;
-			if (parse_owner(&pw, &gr, optarg) != 0)
-				eerrorx("%s: owner `%s' not found",
-				    applet, optarg);
-			break;
-		case 'W':
-			writable = true;
-			break;
-
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	if (optind >= argc)
-		usage(EXIT_FAILURE);
-
-	if (writable && type != inode_unknown)
-		eerrorx("%s: -W cannot be specified along with -d, -f or -p", applet);
-
-	if (pw) {
-		uid = pw->pw_uid;
-		gid = pw->pw_gid;
-	}
-	if (gr)
-		gid = gr->gr_gid;
-
-#ifdef HAVE_SELINUX
-	if (selinux_util_open() == 1)
-		selinux_on = true;
-#endif
-
-	while (optind < argc) {
-		if (writable)
-			exit(!is_writable(argv[optind]));
-		if (do_check(argv[optind], uid, gid, mode, type, trunc, chowner, selinux_on))
-			retval = EXIT_FAILURE;
-		optind++;
-	}
-
-#ifdef HAVE_SELINUX
-	if (selinux_on)
-		selinux_util_close();
-#endif
-
-	return retval;
-}
diff --git a/src/rc/fstabinfo.c b/src/rc/fstabinfo.c
deleted file mode 100644
index 34fea304..00000000
--- a/src/rc/fstabinfo.c
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
-  fstabinfo.c
-  Gets information about /etc/fstab.
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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/wait.h>
-
-#include <errno.h>
-#include <getopt.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-/* Yay for linux and its non liking of POSIX functions.
-   Okay, we could use getfsent but the man page says use getmntent instead
-   AND we don't have getfsent on uclibc or dietlibc for some odd reason. */
-#ifdef __linux__
-#  define HAVE_GETMNTENT
-#  include <mntent.h>
-#  define ENT mntent
-#  define START_ENT fp = setmntent ("/etc/fstab", "r");
-#  define GET_ENT getmntent (fp)
-#  define GET_ENT_FILE(_name) getmntfile (_name)
-#  define END_ENT endmntent (fp)
-#  define ENT_BLOCKDEVICE(_ent) ent->mnt_fsname
-#  define ENT_FILE(_ent) ent->mnt_dir
-#  define ENT_TYPE(_ent) ent->mnt_type
-#  define ENT_OPTS(_ent) ent->mnt_opts
-#  define ENT_PASS(_ent) ent->mnt_passno
-#else
-#  define HAVE_GETFSENT
-#  include <fstab.h>
-#  define ENT fstab
-#  define START_ENT
-#  define GET_ENT getfsent ()
-#  define GET_ENT_FILE(_name) getfsfile (_name)
-#  define END_ENT endfsent ()
-#  define ENT_BLOCKDEVICE(_ent) ent->fs_spec
-#  define ENT_TYPE(_ent) ent->fs_vfstype
-#  define ENT_FILE(_ent) ent->fs_file
-#  define ENT_OPTS(_ent) ent->fs_mntops
-#  define ENT_PASS(_ent) ent->fs_passno
-#endif
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-#ifdef HAVE_GETMNTENT
-static struct mntent *
-getmntfile(const char *file)
-{
-	struct mntent *ent;
-	FILE *fp;
-
-	START_ENT;
-	while ((ent = getmntent(fp)))
-		if (strcmp(file, ent->mnt_dir) == 0)
-			break;
-	END_ENT;
-
-	return ent;
-}
-#endif
-
-extern const char *applet;
-
-static int
-do_mount(struct ENT *ent, bool remount)
-{
-	char *argv[10];
-	pid_t pid;
-	int status;
-
-	argv[0] = UNCONST("mount");
-	argv[1] = UNCONST("-o");
-	argv[2] = ENT_OPTS(*ent);
-	argv[3] = UNCONST("-t");
-	argv[4] = ENT_TYPE(*ent);
-	if (!remount) {
-		argv[5] = ENT_BLOCKDEVICE(*ent);
-		argv[6] = ENT_FILE(*ent);
-		argv[7] = NULL;
-	} else {
-#ifdef __linux__
-		argv[5] = UNCONST("-o");
-		argv[6] = UNCONST("remount");
-		argv[7] = ENT_BLOCKDEVICE(*ent);
-		argv[8] = ENT_FILE(*ent);
-		argv[9] = NULL;
-#else
-		argv[5] = UNCONST("-u");
-		argv[6] = ENT_BLOCKDEVICE(*ent);
-		argv[7] = ENT_FILE(*ent);
-		argv[8] = NULL;
-#endif
-	}
-	switch (pid = vfork()) {
-	case -1:
-		eerrorx("%s: vfork: %s", applet, strerror(errno));
-		/* NOTREACHED */
-	case 0:
-		execvp(argv[0], argv);
-		eerror("%s: execv: %s", applet, strerror(errno));
-		_exit(EXIT_FAILURE);
-		/* NOTREACHED */
-	default:
-		waitpid(pid, &status, 0);
-		if (WIFEXITED(status))
-			return WEXITSTATUS(status);
-		else
-			return -1;
-		/* NOTREACHED */
-	}
-}
-
-#include "_usage.h"
-#define getoptstring "MRbmop:t:" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "mount",          0, NULL, 'M' },
-	{ "remount",        0, NULL, 'R' },
-	{ "blockdevice",    0, NULL, 'b' },
-	{ "mountargs",      0, NULL, 'm' },
-	{ "options",        0, NULL, 'o' },
-	{ "passno",         1, NULL, 'p' },
-	{ "fstype",         1, NULL, 't' },
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"Mounts the filesytem from the mountpoint",
-	"Remounts the filesystem based on the information in fstab",
-	"Extract the block device",
-	"Show arguments needed to mount the entry",
-	"Extract the options field",
-	"Extract or query the pass number field",
-	"List entries with matching file system type",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-#define OUTPUT_FILE      (1 << 1)
-#define OUTPUT_MOUNTARGS (1 << 2)
-#define OUTPUT_OPTIONS   (1 << 3)
-#define OUTPUT_PASSNO    (1 << 4)
-#define OUTPUT_BLOCKDEV  (1 << 5)
-#define OUTPUT_MOUNT     (1 << 6)
-#define OUTPUT_REMOUNT   (1 << 7)
-
-int
-fstabinfo(int argc, char **argv)
-{
-	struct ENT *ent;
-	int result = EXIT_SUCCESS;
-	char *token;
-	int i, p;
-	int opt;
-	int output = OUTPUT_FILE;
-	RC_STRINGLIST *files = rc_stringlist_new();
-	RC_STRING *file, *file_np;
-	bool filtered = false;
-
-#ifdef HAVE_GETMNTENT
-	FILE *fp;
-#endif
-
-	/* Ensure that we are only quiet when explicitly told to be */
-	unsetenv("EINFO_QUIET");
-
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 'M':
-			output = OUTPUT_MOUNT;
-			break;
-		case 'R':
-			output = OUTPUT_REMOUNT;
-			break;
-		case 'b':
-			output = OUTPUT_BLOCKDEV;
-			break;
-		case 'o':
-			output = OUTPUT_OPTIONS;
-			break;
-		case 'm':
-			output = OUTPUT_MOUNTARGS;
-			break;
-
-		case 'p':
-			switch (optarg[0]) {
-			case '=':
-			case '<':
-			case '>':
-				if (sscanf(optarg + 1, "%d", &i) != 1)
-					eerrorx("%s: invalid passno %s",
-					    argv[0], optarg + 1);
-
-				filtered = true;
-				opt = optarg[0];
-				START_ENT;
-				while ((ent = GET_ENT)) {
-					if (strcmp(ENT_FILE(ent), "none") == 0)
-						continue;
-					p = ENT_PASS(ent);
-					if ((opt == '=' && i == p) ||
-					    (opt == '<' && i > p && p != 0) ||
-					    (opt == '>' && i < p && p != 0))
-						rc_stringlist_add(files,
-						    ENT_FILE(ent));
-				}
-				END_ENT;
-				break;
-
-			default:
-				rc_stringlist_add(files, optarg);
-				output = OUTPUT_PASSNO;
-				break;
-			}
-			break;
-
-		case 't':
-			filtered = true;
-			while ((token = strsep(&optarg, ","))) {
-				START_ENT;
-				while ((ent = GET_ENT))
-					if (strcmp(token, ENT_TYPE(ent)) == 0)
-						rc_stringlist_add(files,
-						    ENT_FILE(ent));
-				END_ENT;
-			}
-			break;
-
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	if (optind < argc) {
-		if (TAILQ_FIRST(files)) {
-			TAILQ_FOREACH_SAFE(file, files, entries, file_np) {
-				for (i = optind; i < argc; i++)
-					if (strcmp(argv[i], file->value) == 0)
-						break;
-				if (i >= argc)
-					rc_stringlist_delete(files,
-					    file->value);
-			}
-		} else {
-			while (optind < argc)
-				rc_stringlist_add(files, argv[optind++]);
-		}
-	} else if (!filtered) {
-		START_ENT;
-		while ((ent = GET_ENT))
-			rc_stringlist_add(files, ENT_FILE(ent));
-		END_ENT;
-
-		if (!TAILQ_FIRST(files))
-			eerrorx("%s: empty fstab", argv[0]);
-	}
-
-	if (!TAILQ_FIRST(files)) {
-		rc_stringlist_free(files);
-		return (EXIT_FAILURE);
-	}
-
-	/* Ensure we always display something */
-	START_ENT;
-	TAILQ_FOREACH(file, files, entries) {
-		if (!(ent = GET_ENT_FILE(file->value))) {
-			result = EXIT_FAILURE;
-			continue;
-		}
-
-		/* mount or remount? */
-		switch (output) {
-		case OUTPUT_MOUNT:
-			result += do_mount(ent, false);
-			break;
-
-		case OUTPUT_REMOUNT:
-			result += do_mount(ent, true);
-			break;
-		}
-
-		/* No point in outputting if quiet */
-		if (rc_yesno(getenv("EINFO_QUIET")))
-			continue;
-
-		switch (output) {
-		case OUTPUT_BLOCKDEV:
-			printf("%s\n", ENT_BLOCKDEVICE(ent));
-			break;
-
-		case OUTPUT_MOUNTARGS:
-			printf("-o %s -t %s %s %s\n",
-			    ENT_OPTS(ent),
-			    ENT_TYPE(ent),
-			    ENT_BLOCKDEVICE(ent),
-			    file->value);
-			break;
-
-		case OUTPUT_OPTIONS:
-			printf("%s\n", ENT_OPTS(ent));
-			break;
-
-		case OUTPUT_FILE:
-			printf("%s\n", file->value);
-			break;
-
-		case OUTPUT_PASSNO:
-			printf("%d\n", ENT_PASS(ent));
-			break;
-		}
-	}
-	END_ENT;
-
-	rc_stringlist_free(files);
-	exit(result);
-	/* NOTREACHED */
-}
diff --git a/src/rc/mountinfo.c b/src/rc/mountinfo.c
deleted file mode 100644
index 8790dfee..00000000
--- a/src/rc/mountinfo.c
+++ /dev/null
@@ -1,496 +0,0 @@
-/*
-  mountinfo.c
-  Obtains information about mounted filesystems.
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <sys/param.h>
-
-#if defined(__DragonFly__) || defined(__FreeBSD__)
-#  include <sys/ucred.h>
-#  include <sys/mount.h>
-#  define F_FLAGS f_flags
-#elif defined(BSD) && !defined(__GNU__)
-#  include <sys/statvfs.h>
-#  define statfs statvfs
-#  define F_FLAGS f_flag
-#elif defined (__linux__) || (defined(__FreeBSD_kernel__) && \
-		defined(__GLIBC__)) || defined(__GNU__)
-#  include <mntent.h>
-#endif
-
-#include <errno.h>
-#include <getopt.h>
-#include <limits.h>
-#include <regex.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-extern const char *applet;
-
-typedef enum {
-	mount_from,
-	mount_to,
-	mount_fstype,
-	mount_options
-} mount_type;
-
-typedef enum {
-	net_ignore,
-	net_yes,
-	net_no
-} net_opts;
-
-struct args {
-	regex_t *node_regex;
-	regex_t *skip_node_regex;
-	regex_t *fstype_regex;
-	regex_t *skip_fstype_regex;
-	regex_t *options_regex;
-	regex_t *skip_options_regex;
-	RC_STRINGLIST *mounts;
-	mount_type mount_type;
-	net_opts netdev;
-};
-
-static int
-process_mount(RC_STRINGLIST *list, struct args *args,
-    char *from, char *to, char *fstype, char *options,
-    int netdev)
-{
-	char *p;
-	RC_STRING *s;
-
-	errno = ENOENT;
-
-#ifdef __linux__
-	/* Skip the really silly rootfs */
-	if (strcmp(fstype, "rootfs") == 0)
-		return -1;
-#endif
-
-	if (args->netdev == net_yes &&
-	    (netdev != -1 || TAILQ_FIRST(args->mounts)))
-	{
-		if (netdev != 0)
-			return 1;
-	} else if (args->netdev == net_no &&
-	    (netdev != -1 || TAILQ_FIRST(args->mounts)))
-	{
-		if (netdev != 1)
-			return 1;
-	} else {
-		if (args->node_regex &&
-		    regexec(args->node_regex, from, 0, NULL, 0) != 0)
-			return 1;
-		if (args->skip_node_regex &&
-		    regexec(args->skip_node_regex, from, 0, NULL, 0) == 0)
-			return 1;
-
-		if (args->fstype_regex &&
-		    regexec(args->fstype_regex, fstype, 0, NULL, 0) != 0)
-			return -1;
-		if (args->skip_fstype_regex &&
-		    regexec(args->skip_fstype_regex, fstype, 0, NULL, 0) == 0)
-			return -1;
-
-		if (args->options_regex &&
-		    regexec(args->options_regex, options, 0, NULL, 0) != 0)
-			return -1;
-		if (args->skip_options_regex &&
-		    regexec(args->skip_options_regex, options, 0, NULL, 0) == 0)
-			return -1;
-	}
-
-	if (TAILQ_FIRST(args->mounts)) {
-		TAILQ_FOREACH(s, args->mounts, entries)
-		    if (strcmp(s->value, to) == 0)
-			    break;
-		if (! s)
-			return -1;
-	}
-
-	switch (args->mount_type) {
-	case mount_from:
-		p = from;
-		break;
-	case mount_to:
-		p = to;
-		break;
-	case mount_fstype:
-		p = fstype;
-		break;
-	case mount_options:
-		p = options;
-		break;
-	default:
-		p = NULL;
-		errno = EINVAL;
-		break;
-	}
-
-	if (p) {
-		errno = 0;
-		rc_stringlist_add(list, p);
-		return 0;
-	}
-
-	return -1;
-}
-
-#if defined(BSD) && !defined(__GNU__)
-
-/* Translate the mounted options to english
- * This is taken directly from FreeBSD mount.c */
-static struct opt {
-	int o_opt;
-	const char *o_name;
-} optnames[] = {
-	{ MNT_ASYNC,        "asynchronous" },
-	{ MNT_EXPORTED,     "NFS exported" },
-	{ MNT_LOCAL,        "local" },
-	{ MNT_NOATIME,      "noatime" },
-	{ MNT_NOEXEC,       "noexec" },
-	{ MNT_NOSUID,       "nosuid" },
-#ifdef MNT_NOSYMFOLLOW
-	{ MNT_NOSYMFOLLOW,  "nosymfollow" },
-#endif
-	{ MNT_QUOTA,        "with quotas" },
-	{ MNT_RDONLY,       "read-only" },
-	{ MNT_SYNCHRONOUS,  "synchronous" },
-	{ MNT_UNION,        "union" },
-#ifdef MNT_NOCLUSTERR
-	{ MNT_NOCLUSTERR,   "noclusterr" },
-#endif
-#ifdef MNT_NOCLUSTERW
-	{ MNT_NOCLUSTERW,   "noclusterw" },
-#endif
-#ifdef MNT_SUIDDIR
-	{ MNT_SUIDDIR,      "suiddir" },
-#endif
-	{ MNT_SOFTDEP,      "soft-updates" },
-#ifdef MNT_MULTILABEL
-	{ MNT_MULTILABEL,   "multilabel" },
-#endif
-#ifdef MNT_ACLS
-	{ MNT_ACLS,         "acls" },
-#endif
-#ifdef MNT_GJOURNAL
-	{ MNT_GJOURNAL,     "gjournal" },
-#endif
-	{ 0, NULL }
-};
-
-static RC_STRINGLIST *
-find_mounts(struct args *args)
-{
-	struct statfs *mnts;
-	int nmnts;
-	int i;
-	RC_STRINGLIST *list;
-	char *options = NULL;
-	uint64_t flags;
-	struct opt *o;
-	int netdev;
-	char *tmp;
-	size_t l;
-
-	if ((nmnts = getmntinfo(&mnts, MNT_NOWAIT)) == 0)
-		eerrorx("getmntinfo: %s", strerror (errno));
-
-	list = rc_stringlist_new();
-	for (i = 0; i < nmnts; i++) {
-		netdev = 0;
-		flags = mnts[i].F_FLAGS & MNT_VISFLAGMASK;
-		for (o = optnames; flags && o->o_opt; o++) {
-			if (flags & o->o_opt) {
-				if (o->o_opt == MNT_LOCAL)
-					netdev = 1;
-				if (! options)
-					options = xstrdup(o->o_name);
-				else {
-					l = strlen(options) +
-					    strlen(o->o_name) + 2;
-					tmp = xmalloc(sizeof (char) * l);
-					snprintf(tmp, l, "%s,%s", options,
-					    o->o_name);
-					free(options);
-					options = tmp;
-				}
-			}
-			flags &= ~o->o_opt;
-		}
-
-		process_mount(list, args,
-		    mnts[i].f_mntfromname,
-		    mnts[i].f_mntonname,
-		    mnts[i].f_fstypename,
-		    options,
-		    netdev);
-
-		free(options);
-		options = NULL;
-	}
-
-	return list;
-}
-
-#elif defined (__linux__) || (defined (__FreeBSD_kernel__) && \
-		defined(__GLIBC__))
-static struct mntent *
-getmntfile(const char *file)
-{
-	struct mntent *ent = NULL;
-	FILE *fp;
-
-	fp = setmntent("/etc/fstab", "r");
-	while ((ent = getmntent(fp)))
-		if (strcmp(file, ent->mnt_dir) == 0)
-			break;
-	endmntent(fp);
-
-	return ent;
-}
-
-static RC_STRINGLIST *
-find_mounts(struct args *args)
-{
-	FILE *fp;
-	char *buffer;
-	char *p;
-	char *from;
-	char *to;
-	char *fst;
-	char *opts;
-	struct mntent *ent;
-	int netdev;
-	RC_STRINGLIST *list;
-
-	if ((fp = fopen("/proc/mounts", "r")) == NULL)
-		eerrorx("getmntinfo: %s", strerror(errno));
-
-	list = rc_stringlist_new();
-
-	buffer = xmalloc(sizeof(char) * PATH_MAX * 3);
-	while (fgets(buffer, PATH_MAX * 3, fp)) {
-		netdev = -1;
-		p = buffer;
-		from = strsep(&p, " ");
-		to = strsep(&p, " ");
-		fst = strsep(&p, " ");
-		opts = strsep(&p, " ");
-
-		if ((ent = getmntfile(to))) {
-			if (strstr(ent->mnt_opts, "_netdev"))
-				netdev = 0;
-		}
-
-		process_mount(list, args, from, to, fst, opts, netdev);
-	}
-	free(buffer);
-	fclose(fp);
-
-	return list;
-}
-
-#else
-#  error "Operating system not supported!"
-#endif
-
-static regex_t *
-get_regex(const char *string)
-{
-	regex_t *reg = xmalloc(sizeof (*reg));
-	int result;
-	char buffer[256];
-
-	if ((result = regcomp(reg, string, REG_EXTENDED | REG_NOSUB)) != 0)
-	{
-		regerror(result, reg, buffer, sizeof(buffer));
-		eerrorx("%s: invalid regex `%s'", applet, buffer);
-	}
-
-	return reg;
-}
-
-#include "_usage.h"
-#define extraopts "[mount1] [mount2] ..."
-#define getoptstring "f:F:n:N:o:O:p:P:ist" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "fstype-regex",        1, NULL, 'f'},
-	{ "skip-fstype-regex",   1, NULL, 'F'},
-	{ "node-regex",          1, NULL, 'n'},
-	{ "skip-node-regex",     1, NULL, 'N'},
-	{ "options-regex",       1, NULL, 'o'},
-	{ "skip-options-regex",  1, NULL, 'O'},
-	{ "point-regex",         1, NULL, 'p'},
-	{ "skip-point-regex",    1, NULL, 'P'},
-	{ "options",             0, NULL, 'i'},
-	{ "fstype",              0, NULL, 's'},
-	{ "node",                0, NULL, 't'},
-	{ "netdev",              0, NULL, 'e'},
-	{ "nonetdev",            0, NULL, 'E'},
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"fstype regex to find",
-	"fstype regex to skip",
-	"node regex to find",
-	"node regex to skip",
-	"options regex to find",
-	"options regex to skip",
-	"point regex to find",
-	"point regex to skip",
-	"print options",
-	"print fstype",
-	"print node",
-	"is it a network device",
-	"is it not a network device",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-mountinfo(int argc, char **argv)
-{
-	struct args args;
-	regex_t *point_regex = NULL;
-	regex_t *skip_point_regex = NULL;
-	RC_STRINGLIST *nodes;
-	RC_STRING *s;
-	char real_path[PATH_MAX + 1];
-	int opt;
-	int result;
-	char *this_path;
-
-#define DO_REG(_var)							      \
-	if (_var) free(_var);						      \
-	_var = get_regex(optarg);
-#define REG_FREE(_var)							      \
-	if (_var) { regfree(_var); free(_var); }
-
-	memset (&args, 0, sizeof(args));
-	args.mount_type = mount_to;
-	args.netdev = net_ignore;
-	args.mounts = rc_stringlist_new();
-
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 'e':
-			args.netdev = net_yes;
-			break;
-		case 'E':
-			args.netdev = net_no;
-			break;
-		case 'f':
-			DO_REG(args.fstype_regex);
-			break;
-		case 'F':
-			DO_REG(args.skip_fstype_regex);
-			break;
-		case 'n':
-			DO_REG(args.node_regex);
-			break;
-		case 'N':
-			DO_REG(args.skip_node_regex);
-			break;
-		case 'o':
-			DO_REG(args.options_regex);
-			break;
-		case 'O':
-			DO_REG(args.skip_options_regex);
-			break;
-		case 'p':
-			DO_REG(point_regex);
-			break;
-		case 'P':
-			DO_REG(skip_point_regex);
-			break;
-		case 'i':
-			args.mount_type = mount_options;
-			break;
-		case 's':
-			args.mount_type = mount_fstype;
-			break;
-		case 't':
-			args.mount_type = mount_from;
-			break;
-
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	while (optind < argc) {
-		if (argv[optind][0] != '/')
-			eerrorx("%s: `%s' is not a mount point",
-			    argv[0], argv[optind]);
-		this_path = argv[optind++];
-		if (realpath(this_path, real_path))
-			this_path = real_path;
-		rc_stringlist_add(args.mounts, this_path);
-	}
-	nodes = find_mounts(&args);
-	rc_stringlist_free(args.mounts);
-
-	REG_FREE(args.fstype_regex);
-	REG_FREE(args.skip_fstype_regex);
-	REG_FREE(args.node_regex);
-	REG_FREE(args.skip_node_regex);
-	REG_FREE(args.options_regex);
-	REG_FREE(args.skip_options_regex);
-
-	result = EXIT_FAILURE;
-
-	/* We should report the mounts in reverse order to ease unmounting */
-	TAILQ_FOREACH_REVERSE(s, nodes, rc_stringlist, entries) {
-		if (point_regex &&
-		    regexec(point_regex, s->value, 0, NULL, 0) != 0)
-			continue;
-		if (skip_point_regex &&
-		    regexec(skip_point_regex, s->value, 0, NULL, 0) == 0)
-			continue;
-		if (! rc_yesno(getenv("EINFO_QUIET")))
-			printf("%s\n", s->value);
-		result = EXIT_SUCCESS;
-	}
-	rc_stringlist_free(nodes);
-
-	REG_FREE(point_regex);
-	REG_FREE(skip_point_regex);
-
-	return result;
-}
diff --git a/src/rc/rc-applets.c b/src/rc/rc-applets.c
deleted file mode 100644
index 8fe2d223..00000000
--- a/src/rc/rc-applets.c
+++ /dev/null
@@ -1,570 +0,0 @@
-/*
-  rc-applets.c
-
-  Handle multicall applets for use in our init scripts.
-  Basically this makes us a lot faster for the most part, and removes
-  any shell incompatabilities we might otherwise encounter.
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#define SYSLOG_NAMES
-
-#include <sys/types.h>
-#include <sys/time.h>
-
-#include <errno.h>
-#include <ctype.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <string.h>
-#include <syslog.h>
-#include <time.h>
-#include <unistd.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "rc-misc.h"
-
-/* usecs to wait while we poll the file existance  */
-#define WAIT_INTERVAL	20000000
-#define ONE_SECOND      690000000
-
-/* Applet is first parsed in rc.c - no point in doing it again */
-extern const char *applet;
-
-static int
-syslog_decode(char *name, CODE *codetab)
-{
-	CODE *c;
-
-	if (isdigit((unsigned char)*name))
-		return atoi(name);
-
-	for (c = codetab; c->c_name; c++)
-		if (! strcasecmp(name, c->c_name))
-			return c->c_val;
-
-	return -1;
-}
-
-static int
-do_e(int argc, char **argv)
-{
-	int retval = EXIT_SUCCESS;
-	int i;
-	size_t l = 0;
-	char *message = NULL;
-	char *p;
-	int level = 0;
-	struct timespec ts;
-	struct timeval stop, now;
-	int (*e) (const char *, ...) EINFO_PRINTF(1, 2) = NULL;
-	int (*ee) (int, const char *, ...) EINFO_PRINTF(2, 3) = NULL;
-
-	/* Punt applet */
-	argc--;
-	argv++;
-
-	if (strcmp(applet, "eval_ecolors") == 0) {
-		printf("GOOD='%s'\nWARN='%s'\nBAD='%s'\nHILITE='%s'\nBRACKET='%s'\nNORMAL='%s'\n",
-		    ecolor(ECOLOR_GOOD),
-		    ecolor(ECOLOR_WARN),
-		    ecolor(ECOLOR_BAD),
-		    ecolor(ECOLOR_HILITE),
-		    ecolor(ECOLOR_BRACKET),
-		    ecolor(ECOLOR_NORMAL));
-		exit(EXIT_SUCCESS);
-	}
-
-	if (argc > 0) {
-		if (strcmp(applet, "eend") == 0 ||
-		    strcmp(applet, "ewend") == 0 ||
-		    strcmp(applet, "veend") == 0 ||
-		    strcmp(applet, "vweend") == 0 ||
-		    strcmp(applet, "ewaitfile") == 0)
-		{
-			errno = 0;
-			retval = (int)strtoimax(argv[0], &p, 0);
-			if (!p || *p != '\0')
-				errno = EINVAL;
-			if (errno)
-				retval = EXIT_FAILURE;
-			else {
-				argc--;
-				argv++;
-			}
-		} else if (strcmp(applet, "esyslog") == 0 ||
-		    strcmp(applet, "elog") == 0) {
-			p = strchr(argv[0], '.');
-			if (!p ||
-			    (level = syslog_decode(p + 1, prioritynames)) == -1)
-				eerrorx("%s: invalid log level `%s'", applet, argv[0]);
-
-			if (argc < 3)
-				eerrorx("%s: not enough arguments", applet);
-
-			unsetenv("EINFO_LOG");
-			setenv("EINFO_LOG", argv[1], 1);
-
-			argc -= 2;
-			argv += 2;
-		}
-	}
-
-	if (strcmp(applet, "ewaitfile") == 0) {
-		if (errno)
-			eerrorx("%s: invalid timeout", applet);
-		if (argc == 0)
-			eerrorx("%s: not enough arguments", applet);
-
-		gettimeofday(&stop, NULL);
-		/* retval stores the timeout */
-		stop.tv_sec += retval;
-		ts.tv_sec = 0;
-		ts.tv_nsec = WAIT_INTERVAL;
-		for (i = 0; i < argc; i++) {
-			ebeginv("Waiting for %s", argv[i]);
-			for (;;) {
-				if (exists(argv[i]))
-					break;
-				if (nanosleep(&ts, NULL) == -1)
-					return EXIT_FAILURE;
-				gettimeofday(&now, NULL);
-				if (retval <= 0)
-					continue;
-				if (timercmp(&now, &stop, <))
-					continue;
-				eendv(EXIT_FAILURE,
-				    "timed out waiting for %s", argv[i]);
-				return EXIT_FAILURE;
-			}
-			eendv(EXIT_SUCCESS, NULL);
-		}
-		return EXIT_SUCCESS;
-	}
-
-	if (argc > 0) {
-		for (i = 0; i < argc; i++)
-			l += strlen(argv[i]) + 1;
-
-		message = xmalloc(l);
-		p = message;
-
-		for (i = 0; i < argc; i++) {
-			if (i > 0)
-				*p++ = ' ';
-			l = strlen(argv[i]);
-			memcpy(p, argv[i], l);
-			p += l;
-		}
-		*p = 0;
-	}
-
-	if (strcmp(applet, "einfo") == 0)
-		e = einfo;
-	else if (strcmp(applet, "einfon") == 0)
-		e = einfon;
-	else if (strcmp(applet, "ewarn") == 0)
-		e = ewarn;
-	else if (strcmp(applet, "ewarnn") == 0)
-		e = ewarnn;
-	else if (strcmp(applet, "eerror") == 0) {
-		e = eerror;
-		retval = 1;
-	} else if (strcmp(applet, "eerrorn") == 0) {
-		e = eerrorn;
-		retval = 1;
-	} else if (strcmp(applet, "ebegin") == 0)
-		e = ebegin;
-	else if (strcmp(applet, "eend") == 0)
-		ee = eend;
-	else if (strcmp(applet, "ewend") == 0)
-		ee = ewend;
-	else if (strcmp(applet, "esyslog") == 0) {
-		elog(retval, "%s", message);
-		retval = 0;
-	} else if (strcmp(applet, "veinfo") == 0)
-		e = einfov;
-	else if (strcmp(applet, "veinfon") == 0)
-		e = einfovn;
-	else if (strcmp(applet, "vewarn") == 0)
-		e = ewarnv;
-	else if (strcmp(applet, "vewarnn") == 0)
-		e = ewarnvn;
-	else if (strcmp(applet, "vebegin") == 0)
-		e = ebeginv;
-	else if (strcmp(applet, "veend") == 0)
-		ee = eendv;
-	else if (strcmp(applet, "vewend") == 0)
-		ee = ewendv;
-	else if (strcmp(applet, "eindent") == 0)
-		eindent();
-	else if (strcmp(applet, "eoutdent") == 0)
-		eoutdent();
-	else if (strcmp(applet, "veindent") == 0)
-		eindentv();
-	else if (strcmp(applet, "veoutdent") == 0)
-		eoutdentv();
-	else {
-		eerror("%s: unknown applet", applet);
-		retval = EXIT_FAILURE;
-	}
-
-	if (message) {
-		if (e)
-			e("%s", message);
-		else if (ee)
-			ee(retval, "%s", message);
-	} else {
-		if (e)
-			e(NULL);
-		else if (ee)
-			ee(retval, NULL);
-	}
-
-	free(message);
-	return retval;
-}
-
-static const struct {
-	const char * const name;
-	RC_SERVICE bit;
-} service_bits[] = {
-	{ "service_started",     RC_SERVICE_STARTED,     },
-	{ "service_stopped",     RC_SERVICE_STOPPED,     },
-	{ "service_inactive",    RC_SERVICE_INACTIVE,    },
-	{ "service_starting",    RC_SERVICE_STARTING,    },
-	{ "service_stopping",    RC_SERVICE_STOPPING,    },
-	{ "service_hotplugged",  RC_SERVICE_HOTPLUGGED,  },
-	{ "service_wasinactive", RC_SERVICE_WASINACTIVE, },
-	{ "service_failed",      RC_SERVICE_FAILED,      },
-};
-
-static RC_SERVICE
-lookup_service_state(const char *service)
-{
-	size_t i;
-	for (i = 0; i < ARRAY_SIZE(service_bits); ++i)
-		if (!strcmp(service, service_bits[i].name))
-			return service_bits[i].bit;
-	return 0;
-}
-
-static int
-do_service(int argc, char **argv)
-{
-	bool ok = false;
-	char *service;
-	char *exec;
-	int idx;
-	RC_SERVICE state, bit;
-
-	if (argc > 1)
-		service = argv[1];
-	else
-		service = getenv("RC_SVCNAME");
-
-	if (service == NULL || *service == '\0')
-		eerrorx("%s: no service specified", applet);
-
-	state = rc_service_state(service);
-	bit = lookup_service_state(applet);
-	if (bit) {
-		ok = (state & bit);
-	} else if (strcmp(applet, "service_started_daemon") == 0) {
-		service = getenv("RC_SVCNAME");
-		exec = argv[1];
-		if (argc > 3) {
-			service = argv[1];
-			exec = argv[2];
-			sscanf(argv[3], "%d", &idx);
-		} else if (argc == 3) {
-			if (sscanf(argv[2], "%d", &idx) != 1) {
-				service = argv[1];
-				exec = argv[2];
-			}
-		}
-		ok = rc_service_started_daemon(service, exec, NULL, idx);
-
-	} else if (strcmp(applet, "service_crashed") == 0) {
-		ok = (_rc_can_find_pids() &&
-		    rc_service_daemons_crashed(service) &&
-		    errno != EACCES);
-	} else
-		eerrorx("%s: unknown applet", applet);
-
-	return ok ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-static int
-do_mark_service(int argc, char **argv)
-{
-	bool ok = false;
-	char *svcname = getenv("RC_SVCNAME");
-	char *service = NULL;
-	char *runscript_pid;
-	/* char *mtime; */
-	pid_t pid;
-	RC_SERVICE bit;
-	/* size_t l; */
-
-	if (argc > 1)
-		service = argv[1];
-	else
-		service = svcname;
-
-	if (service == NULL || *service == '\0')
-		eerrorx("%s: no service specified", applet);
-
-	if (!strncmp(applet, "mark_", 5) &&
-	    (bit = lookup_service_state(applet + 5)))
-		ok = rc_service_mark(service, bit);
-	else
-		eerrorx("%s: unknown applet", applet);
-
-	/* If we're marking ourselves then we need to inform our parent
-	   runscript process so they do not mark us based on our exit code */
-	/*
-	 * FIXME: svcname and service are almost always equal except called from a
-	 * shell with just argv[1] - So that doesn't seem to do what Roy initially
-	 * expected.
-	 * See 20120424041423.GA23657@odin.qasl.de (Tue, 24 Apr 2012 06:14:23 +0200,
-	 * openrc@gentoo.org).
-	 */
-	if (ok && svcname && strcmp(svcname, service) == 0) {
-		runscript_pid = getenv("RC_RUNSCRIPT_PID");
-		if (runscript_pid && sscanf(runscript_pid, "%d", &pid) == 1)
-			if (kill(pid, SIGHUP) != 0)
-				eerror("%s: failed to signal parent %d: %s",
-				    applet, pid, strerror(errno));
-
-		/* Remove the exclusive time test. This ensures that it's not
-		   in control as well */
-		/*
-		l = strlen(RC_SVCDIR "/exclusive") + strlen(svcname) +
-		    strlen(runscript_pid) + 4;
-		mtime = xmalloc(l);
-		snprintf(mtime, l, RC_SVCDIR "/exclusive/%s.%s",
-		    svcname, runscript_pid);
-		if (exists(mtime) && unlink(mtime) != 0)
-			eerror("%s: unlink: %s", applet, strerror(errno));
-		free(mtime);
-		*/
-	}
-
-	return ok ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-static int
-do_value(int argc, char **argv)
-{
-	bool ok = false;
-	char *service = getenv("RC_SVCNAME");
-	char *option;
-
-	if (service == NULL)
-		eerrorx("%s: no service specified", applet);
-
-	if (argc < 2 || ! argv[1] || *argv[1] == '\0')
-		eerrorx("%s: no option specified", applet);
-
-	if (strcmp(applet, "service_get_value") == 0 ||
-	    strcmp(applet, "get_options") == 0)
-	{
-		option = rc_service_value_get(service, argv[1]);
-		if (option) {
-			printf("%s", option);
-			free(option);
-			ok = true;
-		}
-	} else if (strcmp(applet, "service_set_value") == 0 ||
-	    strcmp(applet, "save_options") == 0)
-		ok = rc_service_value_set(service, argv[1], argv[2]);
-	else
-		eerrorx("%s: unknown applet", applet);
-
-	return ok ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-static int
-shell_var(int argc, char **argv)
-{
-	int i;
-	char *p;
-	int c;
-
-	for (i = 1; i < argc; i++) {
-		p = argv[i];
-		if (i != 1)
-			putchar(' ');
-		while (*p) {
-			c = (unsigned char)*p++;
-			if (! isalnum(c))
-				c = '_';
-			putchar(c);
-		}
-	}
-	putchar('\n');
-	return EXIT_SUCCESS;
-}
-
-static int
-is_older_than(int argc, char **argv)
-{
-	int i;
-
-	if (argc < 3)
-		return EXIT_FAILURE;
-
-	/* This test is perverted - historically the baselayout function
-	 * returns 0 on *failure*, which is plain wrong */
-	for (i = 2; i < argc; ++i)
-		if (!rc_newer_than(argv[1], argv[i], NULL, NULL))
-			return EXIT_SUCCESS;
-
-	return EXIT_FAILURE;
-}
-
-static int
-is_newer_than(int argc, char **argv)
-{
-	int i;
-
-	if (argc < 3)
-		return EXIT_FAILURE;
-
-	/* This test is correct as it's not present in baselayout */
-	for (i = 2; i < argc; ++i)
-		if (!rc_newer_than(argv[1], argv[i], NULL, NULL))
-			return EXIT_FAILURE;
-
-	return EXIT_SUCCESS;
-}
-
-static int
-is_runlevel_start(_unused int argc, _unused char **argv)
-{
-	return rc_runlevel_starting() ? 0 : 1;
-}
-
-static int
-is_runlevel_stop(_unused int argc, _unused char **argv)
-{
-	return rc_runlevel_stopping() ? 0 : 1;
-}
-
-static int
-rc_abort(_unused int argc, _unused char **argv)
-{
-	const char *p = getenv("RC_PID");
-	int pid;
-
-	if (p && sscanf(p, "%d", &pid) == 1) {
-		if (kill(pid, SIGUSR1) != 0)
-			eerrorx("rc-abort: failed to signal parent %d: %s",
-			    pid, strerror(errno));
-		return EXIT_SUCCESS;
-	}
-
-	return EXIT_FAILURE;
-}
-
-static const struct {
-	const char * const name;
-	int (* const applet)(int argc, char **argv);
-} applets[] = {
-#define A(a) { #a, a }
-	A(fstabinfo),
-	A(mountinfo),
-	{ "openrc-run",           openrc_run,         },
-	{ "rc-depend",           rc_depend,         },
-	{ "rc-service",          rc_service,        },
-	{ "rc-status",           rc_status,         },
-	{ "rc-update",           rc_update,         },
-	{ "service",             rc_service,        },
-	{ "update-rc",           rc_update,         },
-	A(runscript),
-	{ "start-stop-daemon",   start_stop_daemon, },
-	A(checkpath),
-	A(swclock),
-	A(shell_var),
-	A(is_older_than),
-	A(is_newer_than),
-	A(is_runlevel_start),
-	A(is_runlevel_stop),
-	{ "rc-abort",            rc_abort,          },
-	/* These are purely for init scripts and do not make sense as
-	 * anything else */
-	{ "service_get_value",   do_value,          },
-	{ "service_set_value",   do_value,          },
-	{ "get_options",         do_value,          },
-	{ "save_options",        do_value,          },
-#undef A
-};
-
-void
-run_applets(int argc, char **argv)
-{
-	size_t i;
-
-	/*
-	 * The "rc" applet is deprecated and should be referred to as
-	 * "openrc", so output a warning.
-	 */
-	if (strcmp(applet, "rc") == 0)
-		ewarnv("The 'rc' applet is deprecated; please use 'openrc' instead.");
-	/* Bug 351712: We need an extra way to explicitly select an applet OTHER
-	 * than trusting argv[0], as argv[0] is not going to be the applet value if
-	 * we are doing SELinux context switching. For this, we allow calls such as
-	 * 'rc --applet APPLET', and shift ALL of argv down by two array items. */
-	if ((strcmp(applet, "rc") == 0 || strcmp(applet, "openrc") == 0) &&
-		argc >= 3 &&
-		(strcmp(argv[1],"--applet") == 0 || strcmp(argv[1], "-a") == 0)) {
-		applet = argv[2];
-		argv += 2;
-		argc -= 2;
-	}
-
-	for (i = 0; i < ARRAY_SIZE(applets); ++i)
-		if (!strcmp(applet, applets[i].name))
-			exit(applets[i].applet(argc, argv));
-
-	if (applet[0] == 'e' || (applet[0] == 'v' && applet[1] == 'e'))
-		exit(do_e(argc, argv));
-
-	if (strncmp(applet, "service_", strlen("service_")) == 0)
-		exit(do_service(argc, argv));
-
-	if (strncmp(applet, "mark_service_", strlen("mark_service_")) == 0)
-		exit(do_mark_service(argc, argv));
-
-	if (strcmp(applet, "rc") != 0 && strcmp(applet, "openrc") != 0)
-		eerrorx("%s: unknown applet", applet);
-}
diff --git a/src/rc/rc-depend.c b/src/rc/rc-depend.c
deleted file mode 100644
index 8e7e3883..00000000
--- a/src/rc/rc-depend.c
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
-  rc-depend
-  rc service dependency and ordering
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-#include <utime.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-extern const char *applet;
-
-RC_DEPTREE *
-_rc_deptree_load(int force, int *regen) {
-	int fd;
-	int retval;
-	int serrno = errno;
-	int merrno;
-	time_t t;
-	char file[PATH_MAX];
-	struct stat st;
-	struct utimbuf ut;
-	FILE *fp;
-
-	t = 0;
-	if (rc_deptree_update_needed(&t, file) || force != 0) {
-		/* Test if we have permission to update the deptree */
-		fd = open(RC_DEPTREE_CACHE, O_WRONLY);
-		merrno = errno;
-		errno = serrno;
-		if (fd == -1 && merrno == EACCES)
-			return rc_deptree_load();
-		close(fd);
-
-		if (regen)
-			*regen = 1;
-		ebegin("Caching service dependencies");
-		retval = rc_deptree_update() ? 0 : -1;
-		eend (retval, "Failed to update the dependency tree");
-
-		if (retval == 0) {
-			stat(RC_DEPTREE_CACHE, &st);
-			if (st.st_mtime < t) {
-				eerror("Clock skew detected with `%s'", file);
-				eerrorn("Adjusting mtime of `" RC_DEPTREE_CACHE
-				    "' to %s", ctime(&t));
-				fp = fopen(RC_DEPTREE_SKEWED, "w");
-				if (fp != NULL) {
-					fprintf(fp, "%s\n", file);
-					fclose(fp);
-				}
-				ut.actime = t;
-				ut.modtime = t;
-				utime(RC_DEPTREE_CACHE, &ut);
-			} else {
-				if (exists(RC_DEPTREE_SKEWED))
-					unlink(RC_DEPTREE_SKEWED);
-			}
-		}
-		if (force == -1 && regen != NULL)
-			*regen = retval;
-	}
-	return rc_deptree_load();
-}
-
-#include "_usage.h"
-#define getoptstring "aot:suTF:" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "starting", 0, NULL, 'a'},
-	{ "stopping", 0, NULL, 'o'},
-	{ "type",     1, NULL, 't'},
-	{ "notrace",  0, NULL, 'T'},
-	{ "strict",   0, NULL, 's'},
-	{ "update",   0, NULL, 'u'},
-	{ "deptree-file", 1, NULL, 'F'},
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"Order services as if runlevel is starting",
-	"Order services as if runlevel is stopping",
-	"Type(s) of dependency to list",
-	"Don't trace service dependencies",
-	"Only use what is in the runlevels",
-	"Force an update of the dependency tree",
-	"File to load cached deptree from",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-rc_depend(int argc, char **argv)
-{
-	RC_STRINGLIST *list;
-	RC_STRINGLIST *types;
-	RC_STRINGLIST *services;
-	RC_STRINGLIST *depends;
-	RC_STRING *s;
-	RC_DEPTREE *deptree = NULL;
-	int options = RC_DEP_TRACE, update = 0;
-	bool first = true;
-	char *runlevel = xstrdup(getenv("RC_RUNLEVEL"));
-	int opt;
-	char *token;
-	char *deptree_file = NULL;
-
-	types = rc_stringlist_new();
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 'a':
-			options |= RC_DEP_START;
-			break;
-		case 'o':
-			options |= RC_DEP_STOP;
-			break;
-		case 's':
-			options |= RC_DEP_STRICT;
-			break;
-		case 't':
-			while ((token = strsep(&optarg, ",")))
-				rc_stringlist_add(types, token);
-			break;
-		case 'u':
-			update = 1;
-			break;
-		case 'T':
-			options &= RC_DEP_TRACE;
-			break;
-		case 'F':
-			deptree_file = xstrdup(optarg);
-			break;
-
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	if (deptree_file) {
-		if (!(deptree = rc_deptree_load_file(deptree_file)))
-			eerrorx("failed to load deptree");
-	} else {
-		if (!(deptree = _rc_deptree_load(update, NULL)))
-			eerrorx("failed to load deptree");
-	}
-
-	if (!runlevel)
-		runlevel = rc_runlevel_get();
-
-	services = rc_stringlist_new();
-	while (optind < argc) {
-		list = rc_stringlist_new();
-		rc_stringlist_add(list, argv[optind]);
-		errno = 0;
-		depends = rc_deptree_depends(deptree, NULL, list, runlevel, 0);
-		if (!depends && errno == ENOENT)
-			eerror("no dependency info for service `%s'",
-			    argv[optind]);
-		else
-			rc_stringlist_add(services, argv[optind]);
-
-		rc_stringlist_free(depends);
-		rc_stringlist_free(list);
-		optind++;
-	}
-	if (!TAILQ_FIRST(services)) {
-		rc_stringlist_free(services);
-		rc_stringlist_free(types);
-		rc_deptree_free(deptree);
-		free(runlevel);
-		if (update)
-			return EXIT_SUCCESS;
-		eerrorx("no services specified");
-	}
-
-	/* If we don't have any types, then supply some defaults */
-	if (!TAILQ_FIRST(types)) {
-		rc_stringlist_add(types, "ineed");
-		rc_stringlist_add(types, "iuse");
-	}
-
-	depends = rc_deptree_depends(deptree, types, services,
-	    runlevel, options);
-
-	if (TAILQ_FIRST(depends)) {
-		TAILQ_FOREACH(s, depends, entries) {
-			if (first)
-				first = false;
-			else
-				printf (" ");
-			printf ("%s", s->value);
-
-		}
-		printf ("\n");
-	}
-
-	rc_stringlist_free(types);
-	rc_stringlist_free(services);
-	rc_stringlist_free(depends);
-	rc_deptree_free(deptree);
-	free(runlevel);
-	return EXIT_SUCCESS;
-}
diff --git a/src/rc/rc-logger.c b/src/rc/rc-logger.c
deleted file mode 100644
index e72f1818..00000000
--- a/src/rc/rc-logger.c
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
-  rc-logger.c
-  Spawns a logging daemon to capture stdout and stderr so we can log
-  them to a buffer and/or files.
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <sys/ioctl.h>
-#include <sys/wait.h>
-
-#include <ctype.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <termios.h>
-#include <time.h>
-#include <unistd.h>
-
-#if defined(__linux__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
-#  include <pty.h>
-#elif defined(__NetBSD__) || defined(__OpenBSD__)
-#  include <util.h>
-#else
-#  include <libutil.h>
-#endif
-
-#include "einfo.h"
-#include "rc-logger.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-#define TMPLOG RC_SVCDIR "/rc.log"
-#define DEFAULTLOG "/var/log/rc.log"
-
-static int signal_pipe[2] = { -1, -1 };
-static int fd_stdout = -1;
-static int fd_stderr = -1;
-static const char *runlevel = NULL;
-static bool in_escape = false;
-static bool in_term = false;
-
-static char *logbuf = NULL;
-static size_t logbuf_size = 0;
-static size_t logbuf_len = 0;
-
-pid_t rc_logger_pid = -1;
-int rc_logger_tty = -1;
-bool rc_in_logger = false;
-
-static void
-write_log(int logfd, const char *buffer, size_t bytes)
-{
-	const char *p = buffer;
-
-	while ((size_t)(p - buffer) < bytes) {
-		switch (*p) {
-		case '\r':
-			goto cont;
-		case '\033':
-			in_escape = true;
-			in_term = false;
-			goto cont;
-		case '\n':
-			in_escape = in_term = false;
-			break;
-		case '[':
-			if (in_escape)
-				in_term = true;
-			break;
-		}
-
-		if (!in_escape) {
-			if (write(logfd, p++, 1) == -1)
-				eerror("write: %s", strerror(errno));
-			continue;
-		}
-
-		if (! in_term || isalpha((unsigned char)*p))
-			in_escape = in_term = false;
-cont:
-		p++;
-	}
-}
-
-static void
-write_time(FILE *f, const char *s)
-{
-	time_t now = time(NULL);
-	struct tm *tm = localtime(&now);
-
-	fprintf(f, "\nrc %s logging %s at %s\n", runlevel, s, asctime(tm));
-	fflush(f);
-}
-
-void
-rc_logger_close(void)
-{
-	int sig = SIGTERM;
-
-	if (signal_pipe[1] > -1) {
-		if (write(signal_pipe[1], &sig, sizeof(sig)) == -1)
-			eerror("write: %s", strerror(errno));
-		close(signal_pipe[1]);
-		signal_pipe[1] = -1;
-	}
-
-	if (rc_logger_pid > 0)
-		waitpid(rc_logger_pid, 0, 0);
-
-	if (fd_stdout > -1)
-		dup2(fd_stdout, STDOUT_FILENO);
-	if (fd_stderr > -1)
-		dup2(fd_stderr, STDERR_FILENO);
-}
-
-void
-rc_logger_open(const char *level)
-{
-	int slave_tty;
-	struct termios tt;
-	struct winsize ws;
-	char buffer[BUFSIZ];
-	struct pollfd fd[2];
-	int s = 0;
-	size_t bytes;
-	int i;
-	FILE *log = NULL;
-	FILE *plog = NULL;
-	const char *logfile;
-	int log_error = 0;
-
-	if (!rc_conf_yesno("rc_logger"))
-		return;
-
-	if (pipe(signal_pipe) == -1)
-		eerrorx("pipe: %s", strerror(errno));
-	for (i = 0; i < 2; i++)
-		if ((s = fcntl (signal_pipe[i], F_GETFD, 0) == -1 ||
-			fcntl (signal_pipe[i], F_SETFD, s | FD_CLOEXEC) == -1))
-			eerrorx("fcntl: %s", strerror (errno));
-
-	if (isatty(STDOUT_FILENO)) {
-		tcgetattr(STDOUT_FILENO, &tt);
-		ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
-		if (openpty(&rc_logger_tty, &slave_tty, NULL, &tt, &ws))
-			return;
-	} else
-		if (openpty(&rc_logger_tty, &slave_tty, NULL, NULL, NULL))
-			return;
-
-	if ((s = fcntl(rc_logger_tty, F_GETFD, 0)) == 0)
-		fcntl(rc_logger_tty, F_SETFD, s | FD_CLOEXEC);
-
-	if ((s = fcntl(slave_tty, F_GETFD, 0)) == 0)
-		fcntl(slave_tty, F_SETFD, s | FD_CLOEXEC);
-
-	rc_logger_pid = fork();
-	switch (rc_logger_pid) {
-	case -1:
-		eerror("fork: %s", strerror(errno));
-		break;
-	case 0:
-		rc_in_logger = true;
-		close(signal_pipe[1]);
-		signal_pipe[1] = -1;
-
-		runlevel = level;
-		if ((log = fopen(TMPLOG, "ae")))
-			write_time(log, "started");
-		else {
-			free(logbuf);
-			logbuf_size = BUFSIZ * 10;
-			logbuf = xmalloc(sizeof (char) * logbuf_size);
-			logbuf_len = 0;
-		}
-
-		fd[0].fd = signal_pipe[0];
-		fd[0].events = fd[1].events = POLLIN;
-		fd[0].revents = fd[1].revents = 0;
-		if (rc_logger_tty >= 0)
-			fd[1].fd = rc_logger_tty;
-		for (;;) {
-			if ((s = poll(fd,
-				    rc_logger_tty >= 0 ? 2 : 1, -1)) == -1)
-			{
-				eerror("poll: %s", strerror(errno));
-				break;
-			} else if (s == 0)
-				continue;
-
-			if (fd[1].revents & (POLLIN | POLLHUP)) {
-				memset(buffer, 0, BUFSIZ);
-				bytes = read(rc_logger_tty, buffer, BUFSIZ);
-				if (write(STDOUT_FILENO, buffer, bytes) == -1)
-					eerror("write: %s", strerror(errno));
-
-				if (log)
-					write_log(fileno (log), buffer, bytes);
-				else {
-					if (logbuf_size - logbuf_len < bytes) {
-						logbuf_size += BUFSIZ * 10;
-						logbuf = xrealloc(logbuf,
-						    sizeof(char ) *
-						    logbuf_size);
-					}
-
-					memcpy(logbuf + logbuf_len,
-					    buffer, bytes);
-					logbuf_len += bytes;
-				}
-			}
-
-			/* Only SIGTERMS signals come down this pipe */
-			if (fd[0].revents & (POLLIN | POLLHUP))
-				break;
-		}
-		if (logbuf) {
-			if ((log = fopen(TMPLOG, "ae"))) {
-				write_time(log, "started");
-				write_log(fileno(log), logbuf, logbuf_len);
-			}
-			free(logbuf);
-		}
-		if (log) {
-			write_time(log, "stopped");
-			fclose(log);
-		}
-
-		/* Append the temporary log to the real log */
-		logfile = rc_conf_value("rc_log_path");
-		if (logfile == NULL)
-			logfile = DEFAULTLOG;
-
-		if ((plog = fopen(logfile, "ae"))) {
-			if ((log = fopen(TMPLOG, "re"))) {
-				while ((bytes = fread(buffer, sizeof(*buffer), BUFSIZ, log)) > 0) {
-					if (fwrite(buffer, sizeof(*buffer), bytes, plog) < bytes) {
-						log_error = 1;
-						eerror("Error: write(%s) failed: %s", logfile, strerror(errno));
-						break;
-					}
-				}
-			} else {
-				log_error = 1;
-				eerror("Error: fopen(%s) failed: %s", TMPLOG, strerror(errno));
-			}
-
-			fclose(log);
-			fclose(plog);
-		} else {
-			/*
-			 * logfile or its basedir may be read-only during sysinit and
-			 * shutdown so skip the error in this case
-			 */
-			if (errno != EROFS && ((strcmp(level, RC_LEVEL_SHUTDOWN) != 0) && (strcmp(level, RC_LEVEL_SYSINIT) != 0))) {
-				log_error = 1;
-				eerror("Error: fopen(%s) failed: %s", logfile, strerror(errno));
-			}
-		}
-
-		/* Try to keep the temporary log in case of errors */
-		if (!log_error) {
-			if (errno != EROFS && ((strcmp(level, RC_LEVEL_SHUTDOWN) != 0) && (strcmp(level, RC_LEVEL_SYSINIT) != 0)))
-				if (unlink(TMPLOG) == -1)
-					eerror("Error: unlink(%s) failed: %s", TMPLOG, strerror(errno));
-		} else if (exists(TMPLOG))
-			eerrorx("Warning: temporary logfile left behind: %s", TMPLOG);
-
-		exit(0);
-		/* NOTREACHED */
-
-	default:
-		setpgid(rc_logger_pid, 0);
-		fd_stdout = dup(STDOUT_FILENO);
-		fd_stderr = dup(STDERR_FILENO);
-		if ((s = fcntl(fd_stdout, F_GETFD, 0)) == 0)
-			fcntl(fd_stdout, F_SETFD, s | FD_CLOEXEC);
-
-		if ((s = fcntl(fd_stderr, F_GETFD, 0)) == 0)
-			fcntl(fd_stderr, F_SETFD, s | FD_CLOEXEC);
-		dup2(slave_tty, STDOUT_FILENO);
-		dup2(slave_tty, STDERR_FILENO);
-		if (slave_tty != STDIN_FILENO &&
-		    slave_tty != STDOUT_FILENO &&
-		    slave_tty != STDERR_FILENO)
-			close(slave_tty);
-		close(signal_pipe[0]);
-		signal_pipe[0] = -1;
-		break;
-	}
-}
diff --git a/src/rc/rc-logger.h b/src/rc/rc-logger.h
deleted file mode 100644
index 8c0cc2a8..00000000
--- a/src/rc/rc-logger.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef RC_LOGGER_H
-#define RC_LOGGER_H
-
-pid_t rc_logger_pid;
-int rc_logger_tty;
-extern bool rc_in_logger;
-
-void rc_logger_open(const char *runlevel);
-void rc_logger_close(void);
-
-#endif
diff --git a/src/rc/rc-misc.c b/src/rc/rc-misc.c
deleted file mode 100644
index f187158a..00000000
--- a/src/rc/rc-misc.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
-  librc-misc.c
-  rc misc functions
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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/file.h>
-#include <sys/types.h>
-#include <sys/utsname.h>
-
-#ifdef __linux__
-#  include <sys/sysinfo.h>
-#  include <regex.h>
-#endif
-
-#include <ctype.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-#include "version.h"
-
-extern char **environ;
-
-bool
-rc_conf_yesno(const char *setting)
-{
-	return rc_yesno(rc_conf_value (setting));
-}
-
-static const char *const env_whitelist[] = {
-	"CONSOLE", "PATH", "SHELL", "USER", "HOME", "TERM",
-	"LANG", "LC_CTYPE", "LC_NUMERIC", "LC_TIME", "LC_COLLATE",
-	"LC_MONETARY", "LC_MESSAGES", "LC_PAPER", "LC_NAME", "LC_ADDRESS",
-	"LC_TELEPHONE", "LC_MEASUREMENT", "LC_IDENTIFICATION", "LC_ALL",
-	"IN_HOTPLUG", "IN_BACKGROUND", "RC_INTERFACE_KEEP_CONFIG",
-	NULL
-};
-
-void
-env_filter(void)
-{
-	RC_STRINGLIST *env_allow;
-	RC_STRINGLIST *profile;
-	RC_STRINGLIST *env_list;
-	RC_STRING *env;
-	char *e;
-	size_t i = 0;
-
-	/* Add the user defined list of vars */
-	env_allow = rc_stringlist_split(rc_conf_value("rc_env_allow"), " ");
-	profile = rc_config_load(RC_PROFILE_ENV);
-
-	/* Copy the env and work from this so we can manipulate it safely */
-	env_list = rc_stringlist_new();
-	while (environ && environ[i]) {
-		env = rc_stringlist_add(env_list, environ[i++]);
-		e = strchr(env->value, '=');
-		if (e)
-			*e = '\0';
-	}
-
-	TAILQ_FOREACH(env, env_list, entries) {
-		/* Check the whitelist */
-		for (i = 0; env_whitelist[i]; i++) {
-			if (strcmp(env_whitelist[i], env->value) == 0)
-				break;
-		}
-		if (env_whitelist[i])
-			continue;
-
-		/* Check our user defined list */
-		if (rc_stringlist_find(env_allow, env->value))
-			continue;
-
-		/* OK, not allowed! */
-		unsetenv(env->value);
-	}
-
-	/* Now add anything missing from the profile */
-	TAILQ_FOREACH(env, profile, entries) {
-		e = strchr(env->value, '=');
-		*e = '\0';
-		if (!getenv(env->value))
-			setenv(env->value, e + 1, 1);
-	}
-
-#ifdef DEBUG_MEMORY
-	rc_stringlist_free(env_list);
-	rc_stringlist_free(env_allow);
-	rc_stringlist_free(profile);
-#endif
-}
-
-void
-env_config(void)
-{
-	size_t pplen = strlen(RC_PATH_PREFIX);
-	char *path;
-	char *p;
-	char *e;
-	size_t l;
-	struct utsname uts;
-	FILE *fp;
-	char *token;
-	char *np;
-	char *npp;
-	char *tok;
-	const char *sys = rc_sys();
-	char buffer[PATH_MAX];
-
-	/* Ensure our PATH is prefixed with the system locations first
-	   for a little extra security */
-	path = getenv("PATH");
-	if (! path)
-		setenv("PATH", RC_PATH_PREFIX, 1);
-	else if (strncmp (RC_PATH_PREFIX, path, pplen) != 0) {
-		l = strlen(path) + pplen + 3;
-		e = p = xmalloc(sizeof(char) * l);
-		p += snprintf(p, l, "%s", RC_PATH_PREFIX);
-
-		/* Now go through the env var and only add bits not in our
-		 * PREFIX */
-		while ((token = strsep(&path, ":"))) {
-			np = npp = xstrdup(RC_PATH_PREFIX);
-			while ((tok = strsep(&npp, ":")))
-				if (strcmp(tok, token) == 0)
-					break;
-			if (! tok)
-				p += snprintf(p, l - (p - e), ":%s", token);
-			free (np);
-		}
-		*p++ = '\0';
-		unsetenv("PATH");
-		setenv("PATH", e, 1);
-		free(e);
-	}
-
-	setenv("RC_VERSION", VERSION, 1);
-	setenv("RC_LIBEXECDIR", RC_LIBEXECDIR, 1);
-	setenv("RC_SVCDIR", RC_SVCDIR, 1);
-	setenv("RC_TMPDIR", RC_SVCDIR "/tmp", 1);
-	setenv("RC_BOOTLEVEL", RC_LEVEL_BOOT, 1);
-	e = rc_runlevel_get();
-	setenv("RC_RUNLEVEL", e, 1);
-	free(e);
-
-	if ((fp = fopen(RC_KRUNLEVEL, "r"))) {
-		memset(buffer, 0, sizeof (buffer));
-		if (fgets(buffer, sizeof (buffer), fp)) {
-			l = strlen (buffer) - 1;
-			if (buffer[l] == '\n')
-				buffer[l] = 0;
-			setenv("RC_DEFAULTLEVEL", buffer, 1);
-		}
-		fclose(fp);
-	} else
-		setenv("RC_DEFAULTLEVEL", RC_LEVEL_DEFAULT, 1);
-
-	if (sys)
-		setenv("RC_SYS", sys, 1);
-
-#ifdef PREFIX
-	setenv("RC_PREFIX", RC_PREFIX, 1);
-#endif
-
-	/* Some scripts may need to take a different code path if
-	   Linux/FreeBSD, etc
-	   To save on calling uname, we store it in an environment variable */
-	if (uname(&uts) == 0)
-		setenv("RC_UNAME", uts.sysname, 1);
-
-	/* Be quiet or verbose as necessary */
-	if (rc_conf_yesno("rc_quiet"))
-		setenv("EINFO_QUIET", "YES", 1);
-	if (rc_conf_yesno("rc_verbose"))
-		setenv("EINFO_VERBOSE", "YES", 1);
-
-	errno = 0;
-	if ((! rc_conf_yesno("rc_color") && errno == 0) ||
-	    rc_conf_yesno("rc_nocolor"))
-		setenv("EINFO_COLOR", "NO", 1);
-}
-
-int
-signal_setup(int sig, void (*handler)(int))
-{
-	struct sigaction sa;
-
-	memset(&sa, 0, sizeof (sa));
-	sigemptyset(&sa.sa_mask);
-	sa.sa_handler = handler;
-	return sigaction(sig, &sa, NULL);
-}
-
-int
-svc_lock(const char *applet)
-{
-	char file[PATH_MAX];
-	int fd;
-
-	snprintf(file, sizeof(file), RC_SVCDIR "/exclusive/%s", applet);
-	fd = open(file, O_WRONLY | O_CREAT | O_NONBLOCK, 0664);
-	if (fd == -1)
-		return -1;
-	if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
-		close(fd);
-		return -1;
-	}
-	return fd;
-}
-
-int
-svc_unlock(const char *applet, int fd)
-{
-	char file[PATH_MAX];
-
-	snprintf(file, sizeof(file), RC_SVCDIR "/exclusive/%s", applet);
-	close(fd);
-	unlink(file);
-	return -1;
-}
-
-pid_t
-exec_service(const char *service, const char *arg)
-{
-	char *file, sfd[32];
-	int fd;
-	pid_t pid = -1;
-	sigset_t full;
-	sigset_t old;
-	struct sigaction sa;
-
-	fd = svc_lock(basename_c(service));
-	if (fd == -1)
-		return -1;
-
-	file = rc_service_resolve(service);
-	if (!exists(file)) {
-		rc_service_mark(service, RC_SERVICE_STOPPED);
-		svc_unlock(basename_c(service), fd);
-		free(file);
-		return 0;
-	}
-	snprintf(sfd, sizeof(sfd), "%d", fd);
-
-	/* We need to block signals until we have forked */
-	memset(&sa, 0, sizeof (sa));
-	sa.sa_handler = SIG_DFL;
-	sigemptyset(&sa.sa_mask);
-	sigfillset(&full);
-	sigprocmask(SIG_SETMASK, &full, &old);
-
-	if ((pid = fork()) == 0) {
-		/* Restore default handlers */
-		sigaction(SIGCHLD, &sa, NULL);
-		sigaction(SIGHUP, &sa, NULL);
-		sigaction(SIGINT, &sa, NULL);
-		sigaction(SIGQUIT, &sa, NULL);
-		sigaction(SIGTERM, &sa, NULL);
-		sigaction(SIGUSR1, &sa, NULL);
-		sigaction(SIGWINCH, &sa, NULL);
-
-		/* Unmask signals */
-		sigprocmask(SIG_SETMASK, &old, NULL);
-
-		/* Safe to run now */
-		execl(file, file, "--lockfd", sfd, arg, (char *) NULL);
-		fprintf(stderr, "unable to exec `%s': %s\n",
-		    file, strerror(errno));
-		svc_unlock(basename_c(service), fd);
-		_exit(EXIT_FAILURE);
-	}
-
-	if (pid == -1) {
-		fprintf(stderr, "fork: %s\n",strerror (errno));
-		svc_unlock(basename_c(service), fd);
-	} else
-		fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
-
-	sigprocmask(SIG_SETMASK, &old, NULL);
-	free(file);
-	return pid;
-}
-
-int
-parse_mode(mode_t *mode, char *text)
-{
-	char *p;
-	unsigned long l;
-
-	/* Check for a numeric mode */
-	if ((*text - '0') < 8) {
-		l = strtoul(text, &p, 8);
-		if (*p || l > 07777U) {
-			errno = EINVAL;
-			return -1;
-		}
-		*mode = (mode_t) l;
-		return 0;
-	}
-
-	/* We currently don't check g+w type stuff */
-	errno = EINVAL;
-	return -1;
-}
-
-int
-is_writable(const char *path)
-{
-	if (access(path, W_OK) == 0)
-		return 1;
-
-	return 0;
-}
diff --git a/src/rc/rc-plugin.c b/src/rc/rc-plugin.c
deleted file mode 100644
index d981afd8..00000000
--- a/src/rc/rc-plugin.c
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
-  librc-plugin.c
-  Simple plugin handler
-*/
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <sys/wait.h>
-
-#include <dirent.h>
-#include <dlfcn.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-#include "rc-plugin.h"
-
-#define RC_PLUGIN_HOOK "rc_plugin_hook"
-
-bool rc_in_plugin = false;
-
-typedef struct plugin
-{
-	char *name;
-	void *handle;
-	int (*hook)(RC_HOOK, const char *);
-	TAILQ_ENTRY(plugin) entries;
-} PLUGIN;
-TAILQ_HEAD(, plugin) plugins;
-
-#ifndef __FreeBSD__
-dlfunc_t
-dlfunc(void * __restrict handle, const char * __restrict symbol)
-{
-	union {
-		void *d;
-		dlfunc_t f;
-	} rv;
-
-	rv.d = dlsym(handle, symbol);
-	return rv.f;
-}
-#endif
-
-void
-rc_plugin_load(void)
-{
-	DIR *dp;
-	struct dirent *d;
-	PLUGIN *plugin;
-	char file[PATH_MAX];
-	void *h;
-	int (*fptr)(RC_HOOK, const char *);
-
-	/* Don't load plugins if we're in one */
-	if (rc_in_plugin)
-		return;
-
-	TAILQ_INIT(&plugins);
-
-	if (!(dp = opendir(RC_PLUGINDIR)))
-		return;
-
-	while ((d = readdir(dp))) {
-		if (d->d_name[0] == '.')
-			continue;
-
-		snprintf(file, sizeof(file), RC_PLUGINDIR "/%s",  d->d_name);
-		h = dlopen(file, RTLD_LAZY);
-		if (h == NULL) {
-			eerror("dlopen: %s", dlerror());
-			continue;
-		}
-
-		fptr = (int (*)(RC_HOOK, const char *))
-		    dlfunc(h, RC_PLUGIN_HOOK);
-		if (fptr == NULL) {
-			eerror("%s: cannot find symbol `%s'",
-			    d->d_name, RC_PLUGIN_HOOK);
-			dlclose(h);
-		} else {
-			plugin = xmalloc(sizeof(*plugin));
-			plugin->name = xstrdup(d->d_name);
-			plugin->handle = h;
-			plugin->hook = fptr;
-			TAILQ_INSERT_TAIL(&plugins, plugin, entries);
-		}
-	}
-	closedir(dp);
-}
-
-int
-rc_waitpid(pid_t pid)
-{
-	int status;
-
-	while (waitpid(pid, &status, 0) == -1) {
-		if (errno != EINTR) {
-			status = -1;
-			break;
-		}
-	}
-	return status;
-}
-
-void
-rc_plugin_run(RC_HOOK hook, const char *value)
-{
-	PLUGIN *plugin;
-	struct sigaction sa;
-	sigset_t empty;
-	sigset_t full;
-	sigset_t old;
-	int i;
-	int flags;
-	int pfd[2];
-	pid_t pid;
-	char *buffer;
-	char *token;
-	char *p;
-	ssize_t nr;
-	int retval;
-
-	/* Don't run plugins if we're in one */
-	if (rc_in_plugin)
-		return;
-
-	/* We need to block signals until we have forked */
-	memset(&sa, 0, sizeof(sa));
-	sa.sa_handler = SIG_DFL;
-	sigemptyset(&sa.sa_mask);
-	sigemptyset(&empty);
-	sigfillset(&full);
-
-	TAILQ_FOREACH(plugin, &plugins, entries) {
-		/* We create a pipe so that plugins can affect our environment
-		 * vars, which in turn influence our scripts. */
-		if (pipe(pfd) == -1) {
-			eerror("pipe: %s", strerror(errno));
-			return;
-		}
-
-		/* Stop any scripts from inheriting us.
-		 * This is actually quite important as without this, the splash
-		 * plugin will probably hang when running in silent mode. */
-		for (i = 0; i < 2; i++)
-			if ((flags = fcntl (pfd[i], F_GETFD, 0)) < 0 ||
-			    fcntl (pfd[i], F_SETFD, flags | FD_CLOEXEC) < 0)
-				eerror("fcntl: %s", strerror(errno));
-
-		sigprocmask(SIG_SETMASK, &full, &old);
-
-		/* We run the plugin in a new process so we never crash
-		 * or otherwise affected by it */
-		if ((pid = fork()) == -1) {
-			eerror("fork: %s", strerror(errno));
-			break;
-		}
-
-		if (pid == 0) {
-			/* Restore default handlers */
-			sigaction(SIGCHLD, &sa, NULL);
-			sigaction(SIGHUP,  &sa, NULL);
-			sigaction(SIGINT,  &sa, NULL);
-			sigaction(SIGQUIT, &sa, NULL);
-			sigaction(SIGTERM, &sa, NULL);
-			sigaction(SIGUSR1, &sa, NULL);
-			sigaction(SIGWINCH, &sa, NULL);
-			sigprocmask(SIG_SETMASK, &old, NULL);
-
-			rc_in_plugin = true;
-			close(pfd[0]);
-			rc_environ_fd = fdopen(pfd[1], "w");
-			retval = plugin->hook(hook, value);
-			fclose(rc_environ_fd);
-			rc_environ_fd = NULL;
-
-			/* Just in case the plugin sets this to false */
-			rc_in_plugin = true;
-			exit(retval);
-		}
-
-		sigprocmask(SIG_SETMASK, &old, NULL);
-		close(pfd[1]);
-		buffer = xmalloc(sizeof(char) * BUFSIZ);
-		memset(buffer, 0, BUFSIZ);
-
-		while ((nr = read(pfd[0], buffer, BUFSIZ)) > 0) {
-			p = buffer;
-			while (*p && p - buffer < nr) {
-				token = strsep(&p, "=");
-				if (token) {
-					unsetenv(token);
-					if (*p) {
-						setenv(token, p, 1);
-						p += strlen(p) + 1;
-					} else
-						p++;
-				}
-			}
-		}
-
-		free(buffer);
-		close(pfd[0]);
-
-		rc_waitpid(pid);
-	}
-}
-
-void
-rc_plugin_unload(void)
-{
-	PLUGIN *plugin = TAILQ_FIRST(&plugins);
-	PLUGIN *next;
-
-	while (plugin) {
-		next = TAILQ_NEXT(plugin, entries);
-		dlclose(plugin->handle);
-		free(plugin->name);
-		free(plugin);
-		plugin = next;
-	}
-	TAILQ_INIT(&plugins);
-}
diff --git a/src/rc/rc-plugin.h b/src/rc/rc-plugin.h
deleted file mode 100644
index b4e40ab4..00000000
--- a/src/rc/rc-plugin.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-   librc-plugin.h
-   Private instructions to use plugins
-   */
-
-/*
- * Copyright (c) 2007-2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef __LIBRC_PLUGIN_H__
-#define __LIBRC_PLUGIN_H__
-
-/* A simple flag to say if we're in a plugin proccess or not.
- * Mainly used in atexit code. */
-extern bool rc_in_plugin;
-
-int rc_waitpid(pid_t pid);
-void rc_plugin_load(void);
-void rc_plugin_unload(void);
-void rc_plugin_run(RC_HOOK, const char *value);
-
-/* dlfunc defines needed to avoid ISO errors. FreeBSD has this right :) */
-#if !defined(__FreeBSD__) && !defined(__DragonFly__)
-struct __dlfunc_arg {
-	int	__dlfunc_dummy;
-};
-
-typedef	void (*dlfunc_t)(struct __dlfunc_arg);
-
-dlfunc_t dlfunc (void * __restrict handle, const char * __restrict symbol);
-#endif
-
-#endif
diff --git a/src/rc/rc-selinux.c b/src/rc/rc-selinux.c
deleted file mode 100644
index 7124e83e..00000000
--- a/src/rc/rc-selinux.c
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- * rc-selinux.c
- * SELinux helpers to get and set contexts.
- */
-
-/*
- * Copyright (c) 2014 Jason Zaman <jason@perfinion.com>
- *
- * 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 AUTHOR 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 AUTHOR 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 <stddef.h>
-#include <errno.h>
-#include <dlfcn.h>
-#include <ctype.h>
-#include <limits.h>
-#include <pwd.h>
-#include <unistd.h>
-
-#include <selinux/selinux.h>
-#include <selinux/label.h>
-#include <selinux/get_default_type.h>
-#include <selinux/context.h>
-
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-#include "rc-plugin.h"
-#include "rc-selinux.h"
-
-/* the context files for selinux */
-#define RUN_INIT_FILE "run_init_type"
-#define INITRC_FILE "initrc_context"
-
-#ifdef HAVE_AUDIT
-#include <libaudit.h>
-#endif
-
-/* PAM or shadow for authentication */
-#ifdef HAVE_PAM
-#    define PAM_SERVICE_NAME "run_init" /* the name of this program for PAM */
-#    include <security/pam_appl.h>
-#    include <security/pam_misc.h>
-#else
-#    define PASSWORD_PROMPT "Password:"
-#    include <crypt.h>
-#    include <shadow.h>
-#    include <string.h>
-#endif
-
-
-/* The handle for the fcontext lookups */
-static struct selabel_handle *hnd = NULL;
-
-int selinux_util_label(const char *path)
-{
-	int retval = 0;
-	int enforce;
-	struct stat st;
-	security_context_t con;
-
-	enforce = security_getenforce();
-	if (retval < 0)
-		return retval;
-
-	if (!hnd)
-		return (enforce) ? -1 : 0;
-
-	retval = lstat(path, &st);
-	if (retval < 0) {
-		if (errno == ENOENT)
-			return 0;
-		return (enforce) ? -1 : 0;
-	}
-
-	/* lookup the context */
-	retval = selabel_lookup_raw(hnd, &con, path, st.st_mode);
-	if (retval < 0) {
-		if (errno == ENOENT)
-			return 0;
-		return (enforce) ? -1 : 0;
-	}
-
-	/* apply the context */
-	retval = lsetfilecon(path, con);
-	freecon(con);
-	if (retval < 0) {
-		if (errno == ENOENT)
-			return 0;
-		if (errno == ENOTSUP)
-			return 0;
-		return (enforce) ? -1 : 0;
-	}
-
-	return 0;
-}
-
-/*
- * Open the label handle
- * returns 1 on success, 0 if no selinux, negative on error
- */
-int selinux_util_open(void)
-{
-	int retval = 0;
-
-	retval = is_selinux_enabled();
-	if (retval <= 0)
-		return retval;
-
-	hnd = selabel_open(SELABEL_CTX_FILE, NULL, 0);
-	if (!hnd)
-		return -2;
-
-	return 1;
-}
-
-/*
- * Close the label handle
- * returns 1 on success, 0 if no selinux, negative on error
- */
-int selinux_util_close(void)
-{
-	int retval = 0;
-
-	retval = is_selinux_enabled();
-	if (retval <= 0)
-		return retval;
-
-	if (hnd) {
-		selabel_close(hnd);
-		hnd = NULL;
-	}
-
-	return 0;
-}
-
-/*
- * This will check the users password and return 0 on success or -1 on fail
- *
- * We ask for the password to make sure it is intended vs run by malicious software.
- * Actual authorization is covered by the policy itself.
- */
-static int check_password(char *username)
-{
-	int ret = 1;
-#ifdef HAVE_PAM
-	pam_handle_t *pamh;
-	int pam_err = 0;
-	const struct pam_conv pconv = {
-		misc_conv,
-		NULL
-	};
-
-	pam_err = pam_start(PAM_SERVICE_NAME, username, &pconv, &pamh);
-	if (pam_err != PAM_SUCCESS) {
-		ret = -1;
-		goto outpam;
-	}
-
-	pam_err = pam_authenticate(pamh, PAM_DISALLOW_NULL_AUTHTOK);
-	if (pam_err != PAM_SUCCESS) {
-		ret = -1;
-		goto outpam;
-	}
-
-	ret = 0;
-outpam:
-	pam_end(pamh, pam_err);
-	pamh = NULL;
-
-#else /* authenticating via /etc/shadow instead */
-	struct spwd *spw;
-	char *password;
-	char *attempt;
-
-	spw = getspnam(username);
-	if (!spw) {
-		eerror("Failed to read shadow entry");
-		ret = -1;
-		goto outshadow;
-	}
-
-	attempt = getpass(PASSWORD_PROMPT);
-	if (!attempt) {
-		ret = -1;
-		goto outshadow;
-	}
-
-	if (*spw->sp_pwdp == '\0' && *attempt == '\0') {
-		ret = -1;
-		goto outshadow;
-	}
-
-	/* salt must be at least two characters long */
-	if (!(spw->sp_pwdp[0] && spw->sp_pwdp[1])) {
-		ret = -1;
-		goto outshadow;
-	}
-
-	/* encrypt the password attempt */
-	password = crypt(attempt, spw->sp_pwdp);
-
-	if (password && strcmp(password, spw->sp_pwdp) == 0)
-		ret = 0;
-	else
-		ret = -1;
-outshadow:
-#endif
-	return ret;
-}
-
-/* Authenticates the user, returns 0 on success, 1 on fail */
-static int check_auth()
-{
-	struct passwd *pw;
-	uid_t uid;
-
-#ifdef HAVE_AUDIT
-	uid = audit_getloginuid();
-	if (uid == (uid_t) -1)
-		uid = getuid();
-#else
-	uid = getuid();
-#endif
-
-	pw = getpwuid(uid);
-	if (!pw) {
-		eerror("cannot find your entry in the passwd file.");
-		return (-1);
-	}
-
-	printf("Authenticating %s.\n", pw->pw_name);
-
-	/* do the actual check */
-	if (check_password(pw->pw_name) == 0) {
-		return 0;
-	}
-
-	eerrorx("Authentication failed for %s", pw->pw_name);
-	return 1;
-}
-
-/*
- * Read the context from the given context file. context must be free'd by the user.
- */
-static int read_context_file(const char *filename, char **context)
-{
-	int ret = -1;
-	FILE *fp;
-	char filepath[PATH_MAX];
-	char *line = NULL;
-	char *p;
-	char *p2;
-	size_t len = 0;
-	ssize_t read;
-
-	memset(filepath, '\0', PATH_MAX);
-	snprintf(filepath, PATH_MAX - 1, "%s/%s", selinux_contexts_path(), filename);
-
-	fp = fopen(filepath, "r");
-	if (fp == NULL) {
-		eerror("Failed to open context file: %s", filename);
-		return -1;
-	}
-
-	while ((read = getline(&line, &len, fp)) != -1) {
-		/* cut off spaces before the string */
-		p = line;
-		while (isspace(*p) && *p != '\0')
-			p++;
-
-		/* empty string, skip */
-		if (*p == '\0')
-			continue;
-
-		/* cut off spaces after the string */
-		p2 = p;
-		while (!isspace(*p2) && *p2 != '\0')
-			p2++;
-		*p2 = '\0';
-
-		*context = xstrdup(p);
-		ret = 0;
-		break;
-	}
-
-	free(line);
-	fclose(fp);
-	return ret;
-}
-
-void selinux_setup(char **argv)
-{
-	char *new_context = NULL;
-	char *curr_context = NULL;
-	context_t curr_con;
-	char *curr_t = NULL;
-	char *run_init_t = NULL;
-
-	/* Return, if selinux is disabled. */
-	if (is_selinux_enabled() < 1) {
-		return;
-	}
-
-	if (read_context_file(RUN_INIT_FILE, &run_init_t) != 0) {
-		/* assume a reasonable default, rather than bailing out */
-		run_init_t = xstrdup("run_init_t");
-		ewarn("Assuming SELinux run_init type is %s", run_init_t);
-	}
-
-	/* Get our current context. */
-	if (getcon(&curr_context) < 0) {
-		if (errno == ENOENT) {
-			/* should only hit this if proc is not mounted.  this
-			 * happens on Gentoo right after init starts, when
-			 * the init script processing starts.
-			 */
-			goto out;
-		} else {
-			perror("getcon");
-			exit(1);
-		}
-	}
-
-	/* extract the type from the context */
-	curr_con = context_new(curr_context);
-	curr_t = xstrdup(context_type_get(curr_con));
-	/* dont need them anymore so free() now */
-	context_free(curr_con);
-	free(curr_context);
-
-	/* if we are not in the run_init domain, we should not do anything */
-	if (strncmp(run_init_t, curr_t, strlen(run_init_t)) != 0) {
-		goto out;
-	}
-
-	free(curr_t);
-	free(run_init_t);
-
-	if (check_auth() != 0) {
-		eerrorx("Authentication failed.");
-	}
-
-	/* Get the context for the script to be run in. */
-	if (read_context_file(INITRC_FILE, &new_context) != 0) {
-		/* assume a reasonable default, rather than bailing out */
-		new_context = xstrdup("system_u:system_r:initrc_t");
-		ewarn("Assuming SELinux initrc context is %s", new_context);
-	}
-
-	/* Set the new context */
-	if (setexeccon(new_context) < 0) {
-		eerrorx("Could not set SELinux exec context to %s.", new_context);
-	}
-
-	free(new_context);
-
-	/*
-	 * exec will recycle ptys so try and use open_init_pty if it exists
-	 * which will open the pty with initrc_devpts_t, if it doesnt exist,
-	 * fall back to plain exec
-	 */
-	if (access("/usr/sbin/open_init_pty", X_OK)) {
-		if (execvp("/usr/sbin/open_init_pty", argv)) {
-			perror("execvp");
-			exit(-1);
-		}
-	} else if (execvp(argv[1], argv + 1)) {
-		perror("execvp");
-		exit(-1);
-	}
-
-out:
-	free(run_init_t);
-	free(curr_t);
-}
diff --git a/src/rc/rc-selinux.h b/src/rc/rc-selinux.h
deleted file mode 100644
index e28f3339..00000000
--- a/src/rc/rc-selinux.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2014 Jason Zaman <jason@perfinion.com>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-#ifndef RC_SELINUX_UTIL_H
-#define RC_SELINUX_UTIL_H
-
-int selinux_util_open(void);
-int selinux_util_label(const char *path);
-int selinux_util_close(void);
-
-void selinux_setup(char **argv);
-
-#endif
diff --git a/src/rc/rc-service.c b/src/rc/rc-service.c
deleted file mode 100644
index ff725cd8..00000000
--- a/src/rc/rc-service.c
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  rc-service.c
-  Finds all OpenRC services
-*/
-
-/*
- * Copyright (c) 2008 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <getopt.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-extern char *applet;
-
-#include "_usage.h"
-#define usagestring ""							\
-	"Usage: rc-service [options] [-i] <service> <cmd>...\n"		\
-	"   or: rc-service [options] -e <service>\n"			\
-	"   or: rc-service [options] -l\n"				\
-	"   or: rc-service [options] -r <service>"
-#define getoptstring "e:ilr:" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "exists",   1, NULL, 'e' },
-	{ "ifexists", 0, NULL, 'i' },
-	{ "list",     0, NULL, 'l' },
-	{ "resolve",  1, NULL, 'r' },
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"tests if the service exists or not",
-	"if the service exists then run the command",
-	"list all available services",
-	"resolve the service name to an init script",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-rc_service(int argc, char **argv)
-{
-	int opt;
-	char *service;
-	RC_STRINGLIST *list;
-	RC_STRING *s;
-	bool if_exists = false;
-
-	/* Ensure that we are only quiet when explicitly told to be */
-	unsetenv("EINFO_QUIET");
-
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 'e':
-			service = rc_service_resolve(optarg);
-			opt = service ? EXIT_SUCCESS : EXIT_FAILURE;
-#ifdef DEBUG_MEMORY
-			free(service);
-#endif
-			return opt;
-			/* NOTREACHED */
-		case 'i':
-			if_exists = true;
-			break;
-		case 'l':
-			list = rc_services_in_runlevel(NULL);
-			if (TAILQ_FIRST(list) == NULL)
-				return EXIT_FAILURE;
-			rc_stringlist_sort(&list);
-			TAILQ_FOREACH(s, list, entries)
-			    printf("%s\n", s->value);
-#ifdef DEBUG_MEMORY
-			rc_stringlist_free(list);
-#endif
-			return EXIT_SUCCESS;
-			/* NOTREACHED */
-		case 'r':
-			service = rc_service_resolve(optarg);
-			if (service == NULL)
-				return EXIT_FAILURE;
-			printf("%s\n", service);
-#ifdef DEBUG_MEMORY
-			free(service);
-#endif
-			return EXIT_SUCCESS;
-			/* NOTREACHED */
-
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	argc -= optind;
-	argv += optind;
-	if (*argv == NULL)
-		eerrorx("%s: you need to specify a service", applet);
-	if ((service = rc_service_resolve(*argv)) == NULL) {
-		if (if_exists)
-			return 0;
-		eerrorx("%s: service `%s' does not exist", applet, *argv);
-	}
-	*argv = service;
-	execv(*argv, argv);
-	eerrorx("%s: %s", applet, strerror(errno));
-	/* NOTREACHED */
-}
diff --git a/src/rc/rc-status.c b/src/rc/rc-status.c
deleted file mode 100644
index 1f67b756..00000000
--- a/src/rc/rc-status.c
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
-   rc-status
-   Display the status of the services in runlevels
-   */
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <getopt.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-extern const char *applet;
-static bool test_crashed = false;
-static RC_DEPTREE *deptree;
-static RC_STRINGLIST *types;
-
-static RC_STRINGLIST *levels, *services, *tmp, *alist;
-static RC_STRINGLIST *sservices, *nservices, *needsme;
-
-bool
-_rc_can_find_pids(void)
-{
-	RC_PIDLIST *pids;
-	RC_PID *pid;
-	RC_PID *pid2;
-	bool retval = false;
-
-	if (geteuid() == 0)
-		return true;
-
-	/* If we cannot see process 1, then we don't test to see if
-	 * services crashed or not */
-	pids = rc_find_pids(NULL, NULL, 0, 1);
-	if (pids) {
-		pid = LIST_FIRST(pids);
-		if (pid) {
-			retval = true;
-			while (pid) {
-				pid2 = LIST_NEXT(pid, entries);
-				free(pid);
-				pid = pid2;
-			}
-		}
-		free(pids);
-	}
-	return retval;
-}
-
-static void
-print_level(const char *prefix, const char *level)
-{
-	if (prefix)
-		printf("%s ", prefix);
-	printf ("Runlevel: ");
-	if (isatty(fileno(stdout)))
-		printf("%s%s%s\n",
-		       ecolor(ECOLOR_HILITE),
-		       level,
-		       ecolor(ECOLOR_NORMAL));
-	else
-		printf("%s\n", level);
-}
-
-static void
-print_service(const char *service)
-{
-	char status[10];
-	int cols =  printf(" %s", service);
-	const char *c = ecolor(ECOLOR_GOOD);
-	RC_SERVICE state = rc_service_state(service);
-	ECOLOR color = ECOLOR_BAD;
-
-	if (state & RC_SERVICE_STOPPING)
-		snprintf(status, sizeof(status), "stopping ");
-	else if (state & RC_SERVICE_STARTING) {
-		snprintf(status, sizeof(status), "starting ");
-		color = ECOLOR_WARN;
-	} else if (state & RC_SERVICE_INACTIVE) {
-		snprintf(status, sizeof(status), "inactive ");
-		color = ECOLOR_WARN;
-	} else if (state & RC_SERVICE_STARTED) {
-		errno = 0;
-		if (test_crashed &&
-		    rc_service_daemons_crashed(service) &&
-		    errno != EACCES)
-		{
-			snprintf(status, sizeof(status), " crashed ");
-		} else {
-			snprintf(status, sizeof(status), " started ");
-			color = ECOLOR_GOOD;
-		}
-	} else if (state & RC_SERVICE_SCHEDULED) {
-		snprintf(status, sizeof(status), "scheduled");
-		color = ECOLOR_WARN;
-	} else
-		snprintf(status, sizeof(status), " stopped ");
-
-	errno = 0;
-	if (c && *c && isatty(fileno(stdout)))
-		printf("\n");
-	ebracket(cols, color, status);
-}
-
-static void
-print_services(const char *runlevel, RC_STRINGLIST *svcs)
-{
-	RC_STRINGLIST *l = NULL;
-	RC_STRING *s;
-	char *r = NULL;
-
-	if (!svcs)
-		return;
-	if (!deptree)
-		deptree = _rc_deptree_load(0, NULL);
-	if (!deptree) {
-		TAILQ_FOREACH(s, svcs, entries)
-			if (!runlevel ||
-			    rc_service_in_runlevel(s->value, runlevel))
-				print_service(s->value);
-		return;
-	}
-	if (!types) {
-		types = rc_stringlist_new();
-		rc_stringlist_add(types, "ineed");
-		rc_stringlist_add(types, "iuse");
-		rc_stringlist_add(types, "iafter");
-	}
-	if (!runlevel)
-		r = rc_runlevel_get();
-	l = rc_deptree_depends(deptree, types, svcs, r ? r : runlevel,
-			       RC_DEP_STRICT | RC_DEP_TRACE | RC_DEP_START);
-	free(r);
-	if (!l)
-		return;
-	TAILQ_FOREACH(s, l, entries) {
-		if (!rc_stringlist_find(svcs, s->value))
-			continue;
-		if (!runlevel || rc_service_in_runlevel(s->value, runlevel))
-			print_service(s->value);
-	}
-	rc_stringlist_free(l);
-}
-
-static void
-print_stacked_services(const char *runlevel)
-{
-	RC_STRINGLIST *stackedlevels, *servicelist;
-	RC_STRING *stackedlevel;
-
-	stackedlevels = rc_runlevel_stacks(runlevel);
-	TAILQ_FOREACH(stackedlevel, stackedlevels, entries) {
-		if (rc_stringlist_find(levels, stackedlevel->value) != NULL)
-			continue;
-		print_level("Stacked", stackedlevel->value);
-		servicelist = rc_services_in_runlevel(stackedlevel->value);
-		print_services(stackedlevel->value, servicelist);
-		rc_stringlist_free(servicelist);
-	}
-	rc_stringlist_free(stackedlevels);
-	stackedlevels = NULL;
-}
-
-#include "_usage.h"
-#define usagestring ""						\
-	"Usage: rc-status [options] <runlevel>...\n"		\
-	"   or: rc-status [options] [-a | -c | -l | -r | -s | -u]"
-#define getoptstring "aclrsu" getoptstring_COMMON
-static const struct option longopts[] = {
-	{"all",         0, NULL, 'a'},
-	{"crashed",     0, NULL, 'c'},
-	{"list",        0, NULL, 'l'},
-	{"runlevel",    0, NULL, 'r'},
-	{"servicelist", 0, NULL, 's'},
-	{"unused",      0, NULL, 'u'},
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"Show services from all run levels",
-	"Show crashed services",
-	"Show list of run levels",
-	"Show the name of the current runlevel",
-	"Show service list",
-	"Show services not assigned to any runlevel",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-rc_status(int argc, char **argv)
-{
-    RC_STRING *s, *l, *t, *level;
-
-	char *p, *runlevel = NULL;
-	int opt, aflag = 0, retval = 0;
-
-	test_crashed = _rc_can_find_pids();
-
-	while ((opt = getopt_long(argc, argv, getoptstring, longopts,
-				  (int *) 0)) != -1)
-		switch (opt) {
-		case 'a':
-			aflag++;
-			levels = rc_runlevel_list();
-			break;
-		case 'c':
-			services = rc_services_in_state(RC_SERVICE_STARTED);
-			retval = 1;
-			TAILQ_FOREACH(s, services, entries)
-				if (rc_service_daemons_crashed(s->value)) {
-					printf("%s\n", s->value);
-					retval = 0;
-				}
-			goto exit;
-			/* NOTREACHED */
-		case 'l':
-			levels = rc_runlevel_list();
-			TAILQ_FOREACH(l, levels, entries)
-				printf("%s\n", l->value);
-			goto exit;
-		case 'r':
-			runlevel = rc_runlevel_get();
-			printf("%s\n", runlevel);
-			goto exit;
-			/* NOTREACHED */
-		case 's':
-			services = rc_services_in_runlevel(NULL);
-			print_services(NULL, services);
-			goto exit;
-			/* NOTREACHED */
-		case 'u':
-			services = rc_services_in_runlevel(NULL);
-			levels = rc_runlevel_list();
-			TAILQ_FOREACH_SAFE(s, services, entries, t) {
-				TAILQ_FOREACH(l, levels, entries)
-					if (rc_service_in_runlevel(s->value, l->value)) {
-						TAILQ_REMOVE(services, s, entries);
-						free(s->value);
-						free(s);
-						break;
-					}
-			}
-			print_services(NULL, services);
-			goto exit;
-			/* NOTREACHED */
-
-		case_RC_COMMON_GETOPT
-		}
-
-	if (!levels)
-		levels = rc_stringlist_new();
-	opt = (optind < argc) ? 0 : 1;
-	while (optind < argc) {
-		if (rc_runlevel_exists(argv[optind])) {
-			rc_stringlist_add(levels, argv[optind++]);
-			opt++;
-		} else
-			eerror("runlevel `%s' does not exist", argv[optind++]);
-	}
-	if (opt == 0)
-		exit(EXIT_FAILURE);
-	if (!TAILQ_FIRST(levels)) {
-		runlevel = rc_runlevel_get();
-		rc_stringlist_add(levels, runlevel);
-	}
-
-	/* Output the services in the order in which they would start */
-	deptree = _rc_deptree_load(0, NULL);
-
-	TAILQ_FOREACH(l, levels, entries) {
-		print_level(NULL, l->value);
-		services = rc_services_in_runlevel(l->value);
-		print_services(l->value, services);
-		print_stacked_services(l->value);
-		rc_stringlist_free(nservices);
-		nservices = NULL;
-		rc_stringlist_free(services);
-		services = NULL;
-	}
-
-	if (aflag || argc < 2) {
-		/* Show hotplugged services */
-		print_level("Dynamic", "hotplugged");
-		services = rc_services_in_state(RC_SERVICE_HOTPLUGGED);
-		print_services(NULL, services);
-		rc_stringlist_free(services);
-		services = NULL;
-
-		/* Show manually started and unassigned depended services */
-		if (aflag) {
-			rc_stringlist_free(levels);
-			levels = rc_stringlist_new();
-			if (!runlevel)
-				runlevel = rc_runlevel_get();
-			rc_stringlist_add(levels, runlevel);
-		}
-		rc_stringlist_add(levels, RC_LEVEL_SYSINIT);
-		rc_stringlist_add(levels, RC_LEVEL_BOOT);
-		services = rc_services_in_runlevel(NULL);
-		sservices = rc_stringlist_new();
-		TAILQ_FOREACH(l, levels, entries) {
-			nservices = rc_services_in_runlevel_stacked(l->value);
-			TAILQ_CONCAT(sservices, nservices, entries);
-			free(nservices);
-		}
-		TAILQ_FOREACH_SAFE(s, services, entries, t) {
-			if ((rc_stringlist_find(sservices, s->value) ||
-			    (rc_service_state(s->value) & ( RC_SERVICE_STOPPED | RC_SERVICE_HOTPLUGGED)))) {
-				TAILQ_REMOVE(services, s, entries);
-				free(s->value);
-				free(s);
-			}
-		}
-		needsme = rc_stringlist_new();
-		rc_stringlist_add(needsme, "needsme");
-		nservices = rc_stringlist_new();
-		alist = rc_stringlist_new();
-		l = rc_stringlist_add(alist, "");
-		p = l->value;
-		TAILQ_FOREACH(level, levels, entries) {
-			TAILQ_FOREACH_SAFE(s, services, entries, t) {
-				l->value = s->value;
-				setenv("RC_SVCNAME", l->value, 1);
-				tmp = rc_deptree_depends(deptree, needsme, alist, level->value, RC_DEP_TRACE);
-				if (TAILQ_FIRST(tmp)) {
-					TAILQ_REMOVE(services, s, entries);
-					TAILQ_INSERT_TAIL(nservices, s, entries);
-				}
-				rc_stringlist_free(tmp);
-			}
-		}
-		l->value = p;
-		/*
-		 * we are unsetting RC_SVCNAME because last loaded service will not
-		 * be added to the list
-		 */
-		unsetenv("RC_SVCNAME");
-		print_level("Dynamic", "needed");
-		print_services(NULL, nservices);
-		print_level("Dynamic", "manual");
-		print_services(NULL, services);
-	}
-
-exit:
-	free(runlevel);
-#ifdef DEBUG_MEMORY
-	rc_stringlist_free(alist);
-	rc_stringlist_free(needsme);
-	rc_stringlist_free(sservices);
-	rc_stringlist_free(nservices);
-	rc_stringlist_free(services);
-	rc_stringlist_free(types);
-	rc_stringlist_free(levels);
-	rc_deptree_free(deptree);
-#endif
-
-	return retval;
-}
diff --git a/src/rc/rc-update.c b/src/rc/rc-update.c
deleted file mode 100644
index 48bb4dc7..00000000
--- a/src/rc/rc-update.c
+++ /dev/null
@@ -1,366 +0,0 @@
-/*
-  rc-update
-  Manage init scripts and runlevels
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <errno.h>
-#include <getopt.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-extern const char *applet;
-
-/* Return the number of changes made:
- *  -1 = no changes (error)
- *   0 = no changes (nothing to do)
- *  1+ = number of runlevels updated
- */
-static int
-add(const char *runlevel, const char *service)
-{
-	int retval = -1;
-
-	if (!rc_service_exists(service)) {
-		if (errno == ENOEXEC)
-			eerror("%s: service `%s' is not executeable",
-			    applet, service);
-		else
-			eerror("%s: service `%s' does not exist",
-			    applet, service);
-	} else if (rc_service_in_runlevel(service, runlevel)) {
-		einfo("%s: %s already installed in runlevel `%s'; skipping",
-		    applet, service, runlevel);
-		retval = 0;
-	} else if (rc_service_add(runlevel, service)) {
-		einfo("service %s added to runlevel %s", service, runlevel);
-		retval = 1;
-	} else
-		eerror("%s: failed to add service `%s' to runlevel `%s': %s",
-		    applet, service, runlevel, strerror (errno));
-
-	return retval;
-}
-
-static int
-delete(const char *runlevel, const char *service)
-{
-	int retval = -1;
-
-	errno = 0;
-	if (rc_service_delete(runlevel, service)) {
-		einfo("service %s removed from runlevel %s",
-		    service, runlevel);
-		return 1;
-	}
-
-	if (errno == ENOENT)
-		eerror("%s: service `%s' is not in the runlevel `%s'",
-		    applet, service, runlevel);
-	else
-		eerror("%s: failed to remove service `%s' from runlevel `%s': %s",
-		    applet, service, runlevel, strerror (errno));
-
-	return retval;
-}
-
-static int
-addstack(const char *runlevel, const char *stack)
-{
-	if (!rc_runlevel_exists(runlevel)) {
-		eerror("%s: runlevel `%s' does not exist", applet, runlevel);
-		return -1;
-	}
-	if (!rc_runlevel_exists(stack)) {
-		eerror("%s: runlevel `%s' does not exist", applet, stack);
-		return -1;
-	}
-	if (strcmp(runlevel, stack) == 0) {
-		eerror("%s: cannot stack `%s' onto itself", applet, stack);
-		return -1;
-	}
-	if (strcmp(runlevel, RC_LEVEL_SYSINIT) == 0 ||
-	    strcmp(stack, RC_LEVEL_SYSINIT) == 0 ||
-	    strcmp(runlevel, RC_LEVEL_BOOT) == 0 ||
-	    strcmp(stack, RC_LEVEL_BOOT) == 0 ||
-	    strcmp(runlevel, RC_LEVEL_SINGLE) == 0 ||
-	    strcmp(stack, RC_LEVEL_SINGLE) == 0 ||
-	    strcmp(runlevel, RC_LEVEL_SHUTDOWN) == 0 ||
-	    strcmp(stack, RC_LEVEL_SHUTDOWN) == 0)
-	{
-		eerror("%s: cannot stack the %s runlevel",
-		    applet, RC_LEVEL_SYSINIT);
-		return -1;
-	}
-	if (!rc_runlevel_stack(runlevel, stack)) {
-		eerror("%s: failed to stack `%s' to `%s': %s",
-		    applet, stack, runlevel, strerror(errno));
-		return -1;
-	}
-	einfo("runlevel %s added to runlevel %s", stack, runlevel);
-	return 1;
-}
-
-static int
-delstack(const char *runlevel, const char *stack)
-{
-	if (rc_runlevel_unstack(runlevel, stack)) {
-		einfo("runlevel %s removed from runlevel %s", stack, runlevel);
-		return 1;
-	}
-
-	if (errno == ENOENT)
-		eerror("%s: runlevel `%s' is not in the runlevel `%s'",
-		    applet, stack, runlevel);
-	else
-		eerror("%s: failed to remove runlevel `%s' from runlevel `%s': %s",
-		    applet, stack, runlevel, strerror (errno));
-
-	return -1;
-}
-
-static void
-show(RC_STRINGLIST *runlevels, bool verbose)
-{
-	RC_STRINGLIST *services = rc_services_in_runlevel(NULL);
-	RC_STRING *service;
-	RC_STRING *runlevel;
-	RC_STRINGLIST *in;
-	bool inone;
-	char buffer[PATH_MAX];
-	size_t l;
-
-	rc_stringlist_sort(&services);
-	TAILQ_FOREACH(service, services, entries) {
-		in = rc_stringlist_new();
-		inone = false;
-
-		TAILQ_FOREACH(runlevel, runlevels, entries) {
-			if (rc_service_in_runlevel(service->value,
-				runlevel->value))
-			{
-				rc_stringlist_add(in, runlevel->value);
-				inone = true;
-			} else {
-				l = strlen(runlevel->value);
-				memset (buffer, ' ', l);
-				buffer[l] = 0;
-				rc_stringlist_add (in, buffer);
-			}
-		}
-
-		if (inone || verbose) {
-			printf(" %20s |", service->value);
-			TAILQ_FOREACH(runlevel, in, entries)
-			    printf (" %s", runlevel->value);
-			printf ("\n");
-		}
-		rc_stringlist_free(in);
-	}
-
-	rc_stringlist_free (services);
-}
-
-#include "_usage.h"
-#define usagestring ""							\
-	"Usage: rc-update [options] add <service> [<runlevel>...]\n"	\
-	"   or: rc-update [options] del <service> [<runlevel>...]\n"	\
-	"   or: rc-update [options] [show [<runlevel>...]]"
-#define getoptstring "asu" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "all",             0, NULL, 'a' },
-	{ "stack",           0, NULL, 's' },
-	{ "update",          0, NULL, 'u' },
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"Process all runlevels",
-	"Stack a runlevel instead of a service",
-	"Force an update of the dependency tree",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-#define DOADD    (1 << 1)
-#define DODELETE (1 << 2)
-#define DOSHOW   (1 << 3)
-
-int
-rc_update(int argc, char **argv)
-{
-	RC_DEPTREE *deptree;
-	RC_STRINGLIST *runlevels;
-	RC_STRING *runlevel;
-	char *service = NULL;
-	char *p;
-	int action = 0;
-	bool verbose = false, stack = false, all_runlevels = false;
-	int opt;
-	int retval = EXIT_FAILURE;
-	int num_updated = 0;
-	int (*actfunc)(const char *, const char *);
-	int ret;
-
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *)0)) != -1)
-		switch (opt) {
-		case 'a':
-		    all_runlevels = true;
-		break;
-		case 's':
-		    stack = true;
-		break;
-		case 'u':
-			deptree = _rc_deptree_load(-1, &ret);
-			if (deptree)
-				rc_deptree_free(deptree);
-			return ret;
-		case_RC_COMMON_GETOPT
-		}
-
-	verbose = rc_yesno(getenv ("EINFO_VERBOSE"));
-
-	if ((action & DOSHOW   && action != DOSHOW) ||
-	    (action & DOADD    && action != DOADD) ||
-	    (action & DODELETE && action != DODELETE))
-		eerrorx("%s: cannot mix commands", applet);
-
-	/* We need to be backwards compatible */
-	if (optind < argc) {
-		if (strcmp(argv[optind], "add") == 0)
-			action = DOADD;
-		else if (strcmp(argv[optind], "delete") == 0 ||
-		    strcmp(argv[optind], "del") == 0)
-			action = DODELETE;
-		else if (strcmp(argv[optind], "show") == 0)
-			action = DOSHOW;
-		if (action)
-			optind++;
-		else
-			eerrorx("%s: invalid command `%s'",
-			    applet, argv[optind]);
-	}
-	if (!action)
-		action = DOSHOW;
-
-	runlevels = rc_stringlist_new();
-
-	if (optind >= argc) {
-		if (!(action & DOSHOW))
-			eerrorx("%s: no service specified", applet);
-	} else {
-		service = argv[optind];
-		optind++;
-
-		while (optind < argc)
-			if (rc_runlevel_exists(argv[optind]))
-				rc_stringlist_add(runlevels, argv[optind++]);
-			else {
-				rc_stringlist_free(runlevels);
-				eerrorx ("%s: `%s' is not a valid runlevel",
-				    applet, argv[optind]);
-			}
-	}
-
-	retval = EXIT_SUCCESS;
-	if (action & DOSHOW) {
-		if (service)
-			rc_stringlist_add(runlevels, service);
-		if (!TAILQ_FIRST(runlevels)) {
-			free(runlevels);
-			runlevels = rc_runlevel_list();
-		}
-
-		rc_stringlist_sort(&runlevels);
-		show (runlevels, verbose);
-	} else {
-		if (!service)
-			eerror ("%s: no service specified", applet);
-		else {
-			if (action & DOADD) {
-				if (all_runlevels) {
-					rc_stringlist_free(runlevels);
-					eerrorx("%s: the -a option is invalid with add", applet);
-				}
-				actfunc = stack ? addstack : add;
-			} else if (action & DODELETE) {
-				actfunc = stack ? delstack : delete;
-			} else {
-				rc_stringlist_free(runlevels);
-				eerrorx("%s: invalid action", applet);
-			}
-
-			if (!TAILQ_FIRST(runlevels)) {
-				if (all_runlevels) {
-					free(runlevels);
-					runlevels = rc_runlevel_list();
-				} else {
-					p = rc_runlevel_get();
-					rc_stringlist_add(runlevels, p);
-					free(p);
-				}
-			}
-
-			if (!TAILQ_FIRST(runlevels)) {
-				free(runlevels);
-				eerrorx("%s: no runlevels found", applet);
-			}
-
-			TAILQ_FOREACH(runlevel, runlevels, entries) {
-				if (!rc_runlevel_exists(runlevel->value)) {
-					eerror ("%s: runlevel `%s' does not exist",
-					    applet, runlevel->value);
-					continue;
-				}
-
-				ret = actfunc(runlevel->value, service);
-				if (ret < 0)
-					retval = EXIT_FAILURE;
-				num_updated += ret;
-			}
-
-			if (retval == EXIT_SUCCESS &&
-			    num_updated == 0 && action & DODELETE)
-				ewarnx("%s: service `%s' not found in any"
-				    " of the specified runlevels",
-				    applet, service);
-		}
-	}
-
-	rc_stringlist_free(runlevels);
-	return retval;
-}
diff --git a/src/rc/rc.c b/src/rc/rc.c
deleted file mode 100644
index e3301c6c..00000000
--- a/src/rc/rc.c
+++ /dev/null
@@ -1,1150 +0,0 @@
-/*
- * rc.c
- * rc - manager for init scripts which control the startup, shutdown
- * and the running of daemons.
- *
- * Also a multicall binary for various commands that can be used in shell
- * scripts to query service state, mark service state and provide the
- * einfo family of informational functions.
- */
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-const char rc_copyright[] = "Copyright (c) 2007-2008 Roy Marples";
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-
-#include <errno.h>
-#include <dirent.h>
-#include <ctype.h>
-#include <getopt.h>
-#include <libgen.h>
-#include <limits.h>
-#include <pwd.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <string.h>
-#include <strings.h>
-#include <termios.h>
-#include <unistd.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-logger.h"
-#include "rc-misc.h"
-#include "rc-plugin.h"
-
-#include "version.h"
-
-#define INITSH                  RC_LIBEXECDIR "/sh/init.sh"
-#define INITEARLYSH             RC_LIBEXECDIR "/sh/init-early.sh"
-
-#define SHUTDOWN                "/sbin/shutdown"
-#define SULOGIN                 "/sbin/sulogin"
-
-#define INTERACTIVE             RC_SVCDIR "/interactive"
-
-#define DEVBOOT			"/dev/.rcboot"
-
-const char *applet = NULL;
-static char *runlevel;
-static RC_HOOK hook_out;
-
-struct termios *termios_orig = NULL;
-
-RC_PIDLIST service_pids;
-
-static void
-clean_failed(void)
-{
-	DIR *dp;
-	struct dirent *d;
-	size_t l;
-	char *path;
-
-	/* Clean the failed services state dir now */
-	if ((dp = opendir(RC_SVCDIR "/failed"))) {
-		while ((d = readdir(dp))) {
-			if (d->d_name[0] == '.' &&
-			    (d->d_name[1] == '\0' ||
-				(d->d_name[1] == '.' && d->d_name[2] == '\0')))
-				continue;
-
-			l = strlen(RC_SVCDIR "/failed/") +
-			    strlen(d->d_name) + 1;
-			path = xmalloc(sizeof(char) * l);
-			snprintf(path, l, RC_SVCDIR "/failed/%s", d->d_name);
-			if (path) {
-				if (unlink(path))
-					eerror("%s: unlink `%s': %s",
-					    applet, path, strerror(errno));
-				free(path);
-			}
-		}
-		closedir(dp);
-	}
-}
-
-static void
-cleanup(void)
-{
-#ifdef DEBUG_MEMORY
-	RC_PID *p1 = LIST_FIRST(&service_pids);
-	RC_PID *p2;
-#endif
-
-	if (!rc_in_logger && !rc_in_plugin &&
-	    applet && (strcmp(applet, "rc") == 0 || strcmp(applet, "openrc") == 0))
-	{
-		if (hook_out)
-			rc_plugin_run(hook_out, runlevel);
-
-		rc_plugin_unload();
-
-		if (termios_orig) {
-			tcsetattr(STDIN_FILENO, TCSANOW, termios_orig);
-			free(termios_orig);
-		}
-
-		/* Clean runlevel start, stop markers */
-		rmdir(RC_STARTING);
-		rmdir(RC_STOPPING);
-		clean_failed();
-		rc_logger_close();
-	}
-
-#ifdef DEBUG_MEMORY
-	while (p1) {
-		p2 = LIST_NEXT(p1, entries);
-		free(p1);
-		p1 = p2;
-	}
-
-	rc_stringlist_free(hotplugged_services);
-	rc_stringlist_free(stop_services);
-	rc_stringlist_free(start_services);
-	rc_stringlist_free(types_n);
-	rc_stringlist_free(types_nua);
-	rc_deptree_free(deptree);
-	free(runlevel);
-#endif
-}
-
-static char
-read_key(bool block)
-{
-	struct termios termios;
-	char c = 0;
-	int fd = STDIN_FILENO;
-
-	if (!isatty(fd))
-		return false;
-
-	/* Now save our terminal settings. We need to restore them at exit as
-	   we will be changing it for non-blocking reads for Interactive */
-	if (!termios_orig) {
-		termios_orig = xmalloc(sizeof(*termios_orig));
-		tcgetattr(fd, termios_orig);
-	}
-
-	tcgetattr(fd, &termios);
-	termios.c_lflag &= ~(ICANON | ECHO);
-	if (block)
-		termios.c_cc[VMIN] = 1;
-	else {
-		termios.c_cc[VMIN] = 0;
-		termios.c_cc[VTIME] = 0;
-	}
-	tcsetattr(fd, TCSANOW, &termios);
-	if (read(fd, &c, 1) == -1)
-		eerror("read: %s", strerror(errno));
-	tcsetattr(fd, TCSANOW, termios_orig);
-	return c;
-}
-
-static bool
-want_interactive(void)
-{
-	char c;
-	static bool gotinteractive;
-	static bool interactive;
-
-	if (rc_yesno(getenv("EINFO_QUIET")))
-		return false;
-	if (!gotinteractive) {
-		gotinteractive = true;
-		interactive = rc_conf_yesno("rc_interactive");
-	}
-	if (!interactive)
-		return false;
-	c = read_key(false);
-	return (c == 'I' || c == 'i') ? true : false;
-}
-
-static void
-mark_interactive(void)
-{
-	FILE *fp = fopen(INTERACTIVE, "w");
-	if (fp)
-		fclose(fp);
-}
-
-static void
-run_program(const char *prog)
-{
-	struct sigaction sa;
-	sigset_t full;
-	sigset_t old;
-	pid_t pid;
-
-	/* We need to block signals until we have forked */
-	memset(&sa, 0, sizeof(sa));
-	sa.sa_handler = SIG_DFL;
-	sigemptyset(&sa.sa_mask);
-	sigfillset(&full);
-	sigprocmask(SIG_SETMASK, &full, &old);
-	pid = fork();
-
-	if (pid == -1)
-		eerrorx("%s: fork: %s", applet, strerror(errno));
-	if (pid == 0) {
-		/* Restore default handlers */
-		sigaction(SIGCHLD, &sa, NULL);
-		sigaction(SIGHUP, &sa, NULL);
-		sigaction(SIGINT, &sa, NULL);
-		sigaction(SIGQUIT, &sa, NULL);
-		sigaction(SIGTERM, &sa, NULL);
-		sigaction(SIGUSR1, &sa, NULL);
-		sigaction(SIGWINCH, &sa, NULL);
-
-		/* Unmask signals */
-		sigprocmask(SIG_SETMASK, &old, NULL);
-
-		if (termios_orig)
-			tcsetattr(STDIN_FILENO, TCSANOW, termios_orig);
-
-		execl(prog, prog, (char *)NULL);
-		eerror("%s: unable to exec `%s': %s", applet, prog,
-		    strerror(errno));
-		_exit(EXIT_FAILURE);
-	}
-
-	/* Unmask signals and wait for child */
-	sigprocmask(SIG_SETMASK, &old, NULL);
-	if (rc_waitpid(pid) == -1)
-		eerrorx("%s: failed to exec `%s'", applet, prog);
-}
-
-static void
-open_shell(void)
-{
-	const char *shell;
-	struct passwd *pw;
-
-#ifdef __linux__
-	const char *sys = rc_sys();
-
-	/* VSERVER and OPENVZ systems cannot really drop to shells */
-	if (sys &&
-	    (strcmp(sys, "VSERVER") == 0 || strcmp(sys, "OPENVZ") == 0))
-	{
-		execl("/sbin/halt", "/sbin/halt", "-f", (char *) NULL);
-		eerrorx("%s: unable to exec `/sbin/halt': %s",
-		    applet, strerror(errno));
-	}
-#endif
-
-	shell = rc_conf_value("rc_shell");
-	/* No shell set, so obey env, then passwd, then default to /bin/sh */
-	if (shell == NULL) {
-		shell = getenv("SHELL");
-		if (shell == NULL) {
-			pw = getpwuid(getuid());
-			if (pw)
-				shell = pw->pw_shell;
-			if (shell == NULL)
-				shell = "/bin/sh";
-		}
-	}
-	run_program(shell);
-}
-
-static bool
-set_krunlevel(const char *level)
-{
-	FILE *fp;
-
-	if (!level ||
-	    strcmp(level, getenv ("RC_BOOTLEVEL")) == 0 ||
-	    strcmp(level, RC_LEVEL_SINGLE) == 0 ||
-	    strcmp(level, RC_LEVEL_SYSINIT) == 0)
-	{
-		if (exists(RC_KRUNLEVEL) &&
-		    unlink(RC_KRUNLEVEL) != 0)
-			eerror("unlink `%s': %s", RC_KRUNLEVEL,
-			    strerror(errno));
-		return false;
-	}
-
-	if (!(fp = fopen(RC_KRUNLEVEL, "w"))) {
-		eerror("fopen `%s': %s", RC_KRUNLEVEL, strerror(errno));
-		return false;
-	}
-
-	fprintf(fp, "%s", level);
-	fclose(fp);
-	return true;
-}
-
-static size_t
-get_krunlevel(char *buffer, int buffer_len)
-{
-	FILE *fp;
-	size_t i = 0;
-
-	if (!exists(RC_KRUNLEVEL))
-		return 0;
-	if (!(fp = fopen(RC_KRUNLEVEL, "r"))) {
-		eerror("fopen `%s': %s", RC_KRUNLEVEL, strerror(errno));
-		return 0;
-	}
-
-	if (fgets(buffer, buffer_len, fp)) {
-		i = strlen(buffer);
-		if (buffer[i - 1] == '\n')
-			buffer[i - 1] = 0;
-	}
-	fclose(fp);
-	return i;
-}
-
-static void
-add_pid(pid_t pid)
-{
-	RC_PID *p = xmalloc(sizeof(*p));
-	p->pid = pid;
-	LIST_INSERT_HEAD(&service_pids, p, entries);
-}
-
-static void
-remove_pid(pid_t pid)
-{
-	RC_PID *p;
-
-	LIST_FOREACH(p, &service_pids, entries)
-	    if (p->pid == pid) {
-		    LIST_REMOVE(p, entries);
-		    free(p);
-		    return;
-	    }
-}
-
-static void
-wait_for_services(void)
-{
-	for (;;) {
-		while (waitpid(0, 0, 0) != -1)
-			;
-		if (errno != EINTR)
-			break;
-	}
-}
-
-static void
-handle_signal(int sig)
-{
-	int serrno = errno;
-	char signame[10] = { '\0' };
-	pid_t pid;
-	RC_PID *pi;
-	int status = 0;
-	struct winsize ws;
-	sigset_t sset;
-
-	switch (sig) {
-	case SIGCHLD:
-		do {
-			pid = waitpid(-1, &status, WNOHANG);
-			if (pid < 0) {
-				if (errno != ECHILD)
-					eerror("waitpid: %s", strerror(errno));
-				return;
-			}
-		} while (!WIFEXITED(status) && !WIFSIGNALED(status));
-
-		/* Remove that pid from our list */
-		if (pid > 0)
-			remove_pid(pid);
-		break;
-
-	case SIGWINCH:
-		if (rc_logger_tty >= 0) {
-			ioctl(STDIN_FILENO, TIOCGWINSZ, &ws);
-			ioctl(rc_logger_tty, TIOCSWINSZ, &ws);
-		}
-		break;
-
-	case SIGINT:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGINT");
-		/* FALLTHROUGH */
-	case SIGTERM:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGTERM");
-		/* FALLTHROUGH */
-	case SIGQUIT:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGQUIT");
-		eerrorx("%s: caught %s, aborting", applet, signame);
-		/* NOTREACHED */
-	case SIGUSR1:
-		eerror("rc: Aborting!");
-
-		/* Block child signals */
-		sigemptyset(&sset);
-		sigaddset(&sset, SIGCHLD);
-		sigprocmask(SIG_BLOCK, &sset, NULL);
-
-		/* Kill any running services we have started */
-		LIST_FOREACH(pi, &service_pids, entries)
-		    kill(pi->pid, SIGTERM);
-
-		/* Notify plugins we are aborting */
-		rc_plugin_run(RC_HOOK_ABORT, NULL);
-
-		exit(EXIT_FAILURE);
-		/* NOTREACHED */
-
-	default:
-		eerror("%s: caught unknown signal %d", applet, sig);
-	}
-
-	/* Restore errno */
-	errno = serrno;
-}
-
-static void
-do_sysinit()
-{
-	struct utsname uts;
-	const char *sys;
-
-	/* exec init-early.sh if it exists
-	 * This should just setup the console to use the correct
-	 * font. Maybe it should setup the keyboard too? */
-	if (exists(INITEARLYSH))
-		run_program(INITEARLYSH);
-
-	uname(&uts);
-	printf("\n   %sOpenRC %s" VERSION "%s is starting up %s",
-	    ecolor(ECOLOR_GOOD), ecolor(ECOLOR_HILITE),
-	    ecolor(ECOLOR_NORMAL), ecolor(ECOLOR_BRACKET));
-#ifdef BRANDING
-	printf(BRANDING " (%s)", uts.machine);
-#else
-	printf("%s %s (%s)",
-	    uts.sysname,
-	    uts.release,
-	    uts.machine);
-#endif
-
-	if ((sys = rc_sys()))
-		printf(" [%s]", sys);
-
-	printf("%s\n\n", ecolor(ECOLOR_NORMAL));
-
-	if (!rc_yesno(getenv ("EINFO_QUIET")) &&
-	    rc_conf_yesno("rc_interactive"))
-		printf("Press %sI%s to enter interactive boot mode\n\n",
-		    ecolor(ECOLOR_GOOD), ecolor(ECOLOR_NORMAL));
-
-	setenv("RC_RUNLEVEL", RC_LEVEL_SYSINIT, 1);
-	run_program(INITSH);
-
-	/* init may have mounted /proc so we can now detect or real
-	 * sys */
-	if ((sys = rc_sys()))
-		setenv("RC_SYS", sys, 1);
-}
-
-static bool
-runlevel_config(const char *service, const char *level)
-{
-	char *init = rc_service_resolve(service);
-	char *conf, *dir;
-	size_t l;
-	bool retval;
-
-	dir = dirname(init);
-	dir = dirname(init);
-	l = strlen(dir) + strlen(level) + strlen(service) + 10;
-	conf = xmalloc(sizeof(char) * l);
-	snprintf(conf, l, "%s/conf.d/%s.%s", dir, service, level);
-	retval = exists(conf);
-	free(conf);
-	free(init);
-	return retval;
-}
-
-static void
-do_stop_services(const RC_STRINGLIST *types_n, const RC_STRINGLIST *start_services,
-				 const RC_STRINGLIST *stop_services, const RC_DEPTREE *deptree,
-				 const char *newlevel, bool parallel, bool going_down)
-{
-	pid_t pid;
-	RC_STRING *service, *svc1, *svc2;
-	RC_STRINGLIST *deporder, *tmplist, *kwords;
-	RC_SERVICE state;
-	RC_STRINGLIST *nostop;
-	bool crashed, nstop;
-
-	if (!types_n) {
-		types_n = rc_stringlist_new();
-		rc_stringlist_add(types_n, "needsme");
-	}
-
-	crashed = rc_conf_yesno("rc_crashed_stop");
-
-	nostop = rc_stringlist_split(rc_conf_value("rc_nostop"), " ");
-	TAILQ_FOREACH_REVERSE(service, stop_services, rc_stringlist, entries)
-	{
-		state = rc_service_state(service->value);
-		if (state & RC_SERVICE_STOPPED || state & RC_SERVICE_FAILED)
-			continue;
-
-		/* Sometimes we don't ever want to stop a service. */
-		if (rc_stringlist_find(nostop, service->value)) {
-			rc_service_mark(service->value, RC_SERVICE_FAILED);
-			continue;
-		}
-		kwords = rc_deptree_depend(deptree, service->value, "keyword");
-		if (rc_stringlist_find(kwords, "-stop") ||
-		    rc_stringlist_find(kwords, "nostop") ||
-		    (going_down &&
-			(rc_stringlist_find(kwords, "-shutdown") ||
-			    rc_stringlist_find(kwords, "noshutdown"))))
-			nstop = true;
-		else
-			nstop = false;
-		rc_stringlist_free(kwords);
-		if (nstop) {
-			rc_service_mark(service->value, RC_SERVICE_FAILED);
-			continue;
-		}
-
-		/* If the service has crashed, skip futher checks and just stop
-		   it */
-		if (crashed &&
-		    rc_service_daemons_crashed(service->value))
-			goto stop;
-
-		/* If we're in the start list then don't bother stopping us */
-		svc1 = rc_stringlist_find(start_services, service->value);
-		if (svc1) {
-			if (newlevel && strcmp(runlevel, newlevel) != 0) {
-				/* So we're in the start list. But we should
-				 * be stopped if we have a runlevel
-				 * configuration file for either the current
-				 * or next so we use the correct one. */
-				if (!runlevel_config(service->value,runlevel) &&
-				    !runlevel_config(service->value,newlevel))
-					continue;
-			}
-			else
-				continue;
-		}
-
-		/* We got this far. Last check is to see if any any service
-		 * that going to be started depends on us */
-		if (!svc1) {
-			tmplist = rc_stringlist_new();
-			rc_stringlist_add(tmplist, service->value);
-			deporder = rc_deptree_depends(deptree, types_n,
-			    tmplist, newlevel ? newlevel : runlevel,
-			    RC_DEP_STRICT | RC_DEP_TRACE);
-			rc_stringlist_free(tmplist);
-			svc2 = NULL;
-			TAILQ_FOREACH(svc1, deporder, entries) {
-				svc2 = rc_stringlist_find(start_services,
-				    svc1->value);
-				if (svc2)
-					break;
-			}
-			rc_stringlist_free(deporder);
-
-			if (svc2)
-				continue;
-		}
-
-stop:
-		/* After all that we can finally stop the blighter! */
-		pid = service_stop(service->value);
-		if (pid > 0) {
-			add_pid(pid);
-			if (!parallel) {
-				rc_waitpid(pid);
-				remove_pid(pid);
-			}
-		}
-	}
-
-	rc_stringlist_free(nostop);
-}
-
-static void
-do_start_services(const RC_STRINGLIST *start_services, bool parallel)
-{
-	RC_STRING *service;
-	pid_t pid;
-	bool interactive = false;
-	RC_SERVICE state;
-	bool crashed = false;
-
-	if (!rc_yesno(getenv("EINFO_QUIET")))
-		interactive = exists(INTERACTIVE);
-	errno = 0;
-	crashed = rc_conf_yesno("rc_crashed_start");
-	if (errno == ENOENT)
-		crashed = true;
-
-	TAILQ_FOREACH(service, start_services, entries) {
-		state = rc_service_state(service->value);
-		if (state & RC_SERVICE_FAILED)
-			continue;
-		if (!(state & RC_SERVICE_STOPPED)) {
-			if (crashed &&
-			    rc_service_daemons_crashed(service->value))
-				rc_service_mark(service->value,
-				    RC_SERVICE_STOPPED);
-			else
-			    continue;
-		}
-		if (!interactive)
-			interactive = want_interactive();
-
-		if (interactive) {
-			parallel = false;
-	interactive_retry:
-			printf("\n");
-			einfo("About to start the service %s",
-			    service->value);
-			eindent();
-			einfo("1) Start the service\t\t2) Skip the service");
-			einfo("3) Continue boot process\t\t4) Exit to shell");
-			eoutdent();
-	interactive_option:
-			switch (read_key(true)) {
-			case '1': break;
-			case '2': continue;
-			case '3': interactive = false; break;
-			case '4': open_shell(); goto interactive_retry;
-			default: goto interactive_option;
-			}
-		}
-
-		pid = service_start(service->value);
-		/* Remember the pid if we're running in parallel */
-		if (pid > 0) {
-			add_pid(pid);
-			if (!parallel) {
-				rc_waitpid(pid);
-				remove_pid(pid);
-			}
-		}
-	}
-
-	/* Store our interactive status for boot */
-	if (interactive &&
-	    (strcmp(runlevel, RC_LEVEL_SYSINIT) == 0 ||
-		strcmp(runlevel, getenv("RC_BOOTLEVEL")) == 0))
-		mark_interactive();
-	else {
-		if (exists(INTERACTIVE))
-			unlink(INTERACTIVE);
-	}
-
-}
-
-#ifdef RC_DEBUG
-static void
-handle_bad_signal(int sig)
-{
-	char pid[10];
-	int status;
-	pid_t crashed_pid = getpid();
-
-	switch (fork()) {
-	case -1:
-		_exit(sig);
-		/* NOTREACHED */
-	case 0:
-		sprintf(pid, "%i", crashed_pid);
-		printf("\nAuto launching gdb!\n\n");
-		_exit(execlp("gdb", "gdb", "--quiet", "--pid", pid,
-			"-ex", "bt full", NULL));
-		/* NOTREACHED */
-	default:
-		wait(&status);
-	}
-	_exit(1);
-	/* NOTREACHED */
-}
-#endif
-
-#include "_usage.h"
-#define usagestring ""					\
-    "Usage: openrc [options] [<runlevel>]"
-#define getoptstring "a:no:s:S" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "applet",   1, NULL, 'a' },
-	{ "no-stop", 0, NULL, 'n' },
-	{ "override",    1, NULL, 'o' },
-	{ "service",     1, NULL, 's' },
-	{ "sys",         0, NULL, 'S' },
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"runs the applet specified by the next argument",
-	"do not stop any services",
-	"override the next runlevel to change into\n"
-	"when leaving single user or boot runlevels",
-	"runs the service specified with the rest\nof the arguments",
-	"output the RC system type, if any",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-main(int argc, char **argv)
-{
-	const char *bootlevel = NULL;
-	char *newlevel = NULL;
-	static RC_STRINGLIST *hotplugged_services;
-	static RC_STRINGLIST *stop_services;
-	static RC_STRINGLIST *start_services;
-	static RC_STRINGLIST *types_n;
-	static RC_STRINGLIST *types_nua;
-	static RC_DEPTREE *deptree;
-	RC_STRINGLIST *deporder = NULL;
-	RC_STRINGLIST *tmplist;
-	RC_STRING *service;
-	bool going_down = false;
-	int depoptions = RC_DEP_STRICT | RC_DEP_TRACE;
-	char krunlevel [PATH_MAX];
-	char pidstr[10];
-	int opt;
-	bool parallel;
-	int regen = 0;
-	bool nostop = false;
-#ifdef __linux__
-	char *proc;
-	char *p;
-	char *token;
-#endif
-
-#ifdef RC_DEBUG
-	signal_setup(SIGBUS, handle_bad_signal);
-	signal_setup(SIGILL, handle_bad_signal);
-	signal_setup(SIGSEGV, handle_bad_signal);
-#endif
-
-	applet = basename_c(argv[0]);
-	LIST_INIT(&service_pids);
-	atexit(cleanup);
-	if (!applet)
-		eerrorx("arguments required");
-
-	/* Run our built in applets. If we ran one, we don't return. */
-	run_applets(argc, argv);
-
-	argc--;
-	argv++;
-
-	/* Change dir to / to ensure all scripts don't use stuff in pwd */
-	if (chdir("/") == -1)
-		eerror("chdir: %s", strerror(errno));
-
-	/* Ensure our environment is pure
-	 * Also, add our configuration to it */
-	env_filter();
-	env_config();
-
-	/* complain about old configuration settings if they exist */
-	if (exists(RC_CONF_OLD)) {
-		ewarn("%s still exists on your system and should be removed.",
-				RC_CONF_OLD);
-		ewarn("Please migrate to the appropriate settings in %s", RC_CONF);
-	}
-
-	argc++;
-	argv--;
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 'a':
-			/* Do nothing, actual logic in run_applets, this
-			 * is a placeholder */
-			break;
-		case 'n':
-			nostop = true;
-			break;
-		case 'o':
-			if (*optarg == '\0')
-				optarg = NULL;
-			if (!rc_runlevel_exists(optarg)) {
-				eerror("runlevel `%s' does not exist", optarg);
-				exit(EXIT_FAILURE);
-			}
-			if (!set_krunlevel(optarg))
-				exit(EXIT_FAILURE);
-			einfo("Overriding next runlevel to %s", optarg);
-			exit(EXIT_SUCCESS);
-			/* NOTREACHED */
-		case 's':
-			newlevel = rc_service_resolve(optarg);
-			if (!newlevel)
-				eerrorx("%s: service `%s' does not exist",
-				    applet, optarg);
-			argv += optind - 1;
-			*argv = newlevel;
-			execv(*argv, argv);
-			eerrorx("%s: %s", applet, strerror(errno));
-			/* NOTREACHED */
-		case 'S':
-			bootlevel = rc_sys();
-			if (bootlevel)
-				printf("%s\n", bootlevel);
-			exit(EXIT_SUCCESS);
-			/* NOTREACHED */
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	newlevel = argv[optind++];
-	/* To make life easier, we only have the shutdown runlevel as
-	 * nothing really needs to know that we're rebooting.
-	 * But for those that do, you can test against RC_REBOOT. */
-	if (newlevel) {
-		if (strcmp(newlevel, "reboot") == 0) {
-			newlevel = UNCONST(RC_LEVEL_SHUTDOWN);
-			setenv("RC_REBOOT", "YES", 1);
-		}
-	}
-
-	/* Enable logging */
-	setenv("EINFO_LOG", "openrc", 1);
-
-	/* Export our PID */
-	snprintf(pidstr, sizeof(pidstr), "%d", getpid());
-	setenv("RC_PID", pidstr, 1);
-
-	/* Create a list of all services which should be started for the new or
-	* current runlevel including those in boot, sysinit and hotplugged
-	* runlevels.  Clearly, some of these will already be started so we
-	* won't actually be starting them all.
-	*/
-	bootlevel = getenv("RC_BOOTLEVEL");
-	runlevel = rc_runlevel_get();
-
-	rc_logger_open(newlevel ? newlevel : runlevel);
-
-	/* Setup a signal handler */
-	signal_setup(SIGINT, handle_signal);
-	signal_setup(SIGQUIT, handle_signal);
-	signal_setup(SIGTERM, handle_signal);
-	signal_setup(SIGUSR1, handle_signal);
-	signal_setup(SIGWINCH, handle_signal);
-
-	/* Run any special sysinit foo */
-	if (newlevel && strcmp(newlevel, RC_LEVEL_SYSINIT) == 0) {
-		do_sysinit();
-		free(runlevel);
-		runlevel = rc_runlevel_get();
-	}
-
-	rc_plugin_load();
-
-	/* Now we start handling our children */
-	signal_setup(SIGCHLD, handle_signal);
-
-	if (newlevel &&
-	    (strcmp(newlevel, RC_LEVEL_SHUTDOWN) == 0 ||
-		strcmp(newlevel, RC_LEVEL_SINGLE) == 0))
-	{
-		going_down = true;
-		if (!exists(RC_KRUNLEVEL))
-			set_krunlevel(runlevel);
-		rc_runlevel_set(newlevel);
-		setenv("RC_RUNLEVEL", newlevel, 1);
-		setenv("RC_GOINGDOWN", "YES", 1);
-	} else {
-		/* We should not use krunevel in sysinit or boot runlevels */
-		if (!newlevel ||
-		    (strcmp(newlevel, RC_LEVEL_SYSINIT) != 0 &&
-			strcmp(newlevel, getenv("RC_BOOTLEVEL")) != 0))
-		{
-			if (get_krunlevel(krunlevel, sizeof(krunlevel))) {
-				newlevel = krunlevel;
-				set_krunlevel(NULL);
-			}
-		}
-
-		if (newlevel) {
-			if (strcmp(runlevel, newlevel) != 0 &&
-			    !rc_runlevel_exists(newlevel))
-				eerrorx("%s: not a valid runlevel", newlevel);
-
-#ifdef __linux__
-			if (strcmp(newlevel, RC_LEVEL_SYSINIT) == 0) {
-				/* If we requested a runlevel, save it now */
-				p = rc_proc_getent("rc_runlevel");
-				if (p == NULL)
-					p = rc_proc_getent("softlevel");
-				if (p != NULL) {
-					set_krunlevel(p);
-					free(p);
-				}
-			}
-#endif
-		}
-	}
-
-	if (going_down) {
-#ifdef __FreeBSD__
-		/* FIXME: we shouldn't have todo this */
-		/* For some reason, wait_for_services waits for the logger
-		 * proccess to finish as well, but only on FreeBSD.
-		 * We cannot allow this so we stop logging now. */
-		rc_logger_close();
-#endif
-
-		rc_plugin_run(RC_HOOK_RUNLEVEL_STOP_IN, newlevel);
-	} else {
-		rc_plugin_run(RC_HOOK_RUNLEVEL_STOP_IN, runlevel);
-	}
-	hook_out = RC_HOOK_RUNLEVEL_STOP_OUT;
-
-	/* Check if runlevel is valid if we're changing */
-	if (newlevel && strcmp(runlevel, newlevel) != 0 && !going_down) {
-		if (!rc_runlevel_exists(newlevel))
-			eerrorx("%s: is not a valid runlevel", newlevel);
-	}
-
-	/* Load our deptree */
-	if ((deptree = _rc_deptree_load(0, &regen)) == NULL)
-		eerrorx("failed to load deptree");
-	if (exists(RC_DEPTREE_SKEWED))
-		ewarn("WARNING: clock skew detected!");
-
-	/* Clean the failed services state dir */
-	clean_failed();
-
-	if (mkdir(RC_STOPPING, 0755) != 0) {
-		if (errno == EACCES)
-			eerrorx("%s: superuser access required", applet);
-		eerrorx("%s: failed to create stopping dir `%s': %s",
-		    applet, RC_STOPPING, strerror(errno));
-	}
-
-	/* Create a list of all services which we could stop (assuming
-	* they won't be active in the new or current runlevel) including
-	* all those services which have been started, are inactive or
-	* are currently starting.  Clearly, some of these will be listed
-	* in the new or current runlevel so we won't actually be stopping
-	* them all.
-	*/
-	stop_services = rc_services_in_state(RC_SERVICE_STARTED);
-	tmplist = rc_services_in_state(RC_SERVICE_INACTIVE);
-	TAILQ_CONCAT(stop_services, tmplist, entries);
-	free(tmplist);
-	tmplist = rc_services_in_state(RC_SERVICE_STARTING);
-	TAILQ_CONCAT(stop_services, tmplist, entries);
-	free(tmplist);
-	if (stop_services)
-		rc_stringlist_sort(&stop_services);
-
-	types_nua = rc_stringlist_new();
-	rc_stringlist_add(types_nua, "ineed");
-	rc_stringlist_add(types_nua, "iuse");
-	rc_stringlist_add(types_nua, "iafter");
-
-	if (stop_services) {
-		tmplist = rc_deptree_depends(deptree, types_nua, stop_services,
-		    runlevel, depoptions | RC_DEP_STOP);
-		rc_stringlist_free(stop_services);
-		stop_services = tmplist;
-	}
-
-	/* Create a list of all services which should be started for the new or
-	 * current runlevel including those in boot, sysinit and hotplugged
-	 * runlevels.  Clearly, some of these will already be started so we
-	 * won't actually be starting them all.
-	 */
-	hotplugged_services = rc_services_in_state(RC_SERVICE_HOTPLUGGED);
-	start_services = rc_services_in_runlevel_stacked(newlevel ?
-	    newlevel : runlevel);
-	if (strcmp(newlevel ? newlevel : runlevel, RC_LEVEL_SHUTDOWN) != 0 &&
-	    strcmp(newlevel ? newlevel : runlevel, RC_LEVEL_SYSINIT) != 0)
-	{
-		tmplist = rc_services_in_runlevel(RC_LEVEL_SYSINIT);
-		TAILQ_CONCAT(start_services, tmplist, entries);
-		free(tmplist);
-		/* If we are NOT headed for the single-user runlevel... */
-		if (strcmp(newlevel ? newlevel : runlevel,
-			RC_LEVEL_SINGLE) != 0)
-		{
-			/* If we are NOT headed for the boot runlevel... */
-			if (strcmp(newlevel ? newlevel : runlevel,
-				bootlevel) != 0)
-			{
-				tmplist = rc_services_in_runlevel(bootlevel);
-				TAILQ_CONCAT(start_services, tmplist, entries);
-				free(tmplist);
-			}
-			if (hotplugged_services) {
-				TAILQ_FOREACH(service, hotplugged_services,
-				    entries)
-				    rc_stringlist_addu(start_services,
-					service->value);
-			}
-		}
-	}
-
-	parallel = rc_conf_yesno("rc_parallel");
-
-	/* Now stop the services that shouldn't be running */
-	if (stop_services && !nostop)
-		do_stop_services(types_n, start_services, stop_services, deptree, newlevel, parallel, going_down);
-
-	/* Wait for our services to finish */
-	wait_for_services();
-
-	/* Notify the plugins we have finished */
-	rc_plugin_run(RC_HOOK_RUNLEVEL_STOP_OUT,
-	    going_down ? newlevel : runlevel);
-	hook_out = 0;
-
-	rmdir(RC_STOPPING);
-
-	/* Store the new runlevel */
-	if (newlevel) {
-		rc_runlevel_set(newlevel);
-		free(runlevel);
-		runlevel = xstrdup(newlevel);
-		setenv("RC_RUNLEVEL", runlevel, 1);
-	}
-
-#ifdef __linux__
-	/* We can't log beyond this point as the shutdown runlevel
-	 * will mount / readonly. */
-	if (strcmp(runlevel, RC_LEVEL_SHUTDOWN) == 0)
-		rc_logger_close();
-#endif
-
-	mkdir(RC_STARTING, 0755);
-	rc_plugin_run(RC_HOOK_RUNLEVEL_START_IN, runlevel);
-	hook_out = RC_HOOK_RUNLEVEL_START_OUT;
-
-	/* Re-add our hotplugged services if they stopped */
-	if (hotplugged_services)
-		TAILQ_FOREACH(service, hotplugged_services, entries)
-		    rc_service_mark(service->value, RC_SERVICE_HOTPLUGGED);
-
-#ifdef __linux__
-	/* If the "noinit" parameter was passed on the kernel command line then
-	 * mark the specified services as started so they will not be started
-	 * by us. */
-	proc = p = rc_proc_getent("noinit");
-	if (proc) {
-		while ((token = strsep(&p, ",")))
-			rc_service_mark(token, RC_SERVICE_STARTED);
-		free(proc);
-	}
-#endif
-
-	/* If we have a list of services to start then... */
-	if (start_services) {
-		/* Get a list of the chained runlevels which compose the target runlevel */
-		RC_STRINGLIST *runlevel_chain = rc_runlevel_stacks(runlevel);
-
-		/* Loop through them in reverse order. */
-		RC_STRING *rlevel;
-		TAILQ_FOREACH_REVERSE(rlevel, runlevel_chain, rc_stringlist, entries)
-		{
-			/* Get a list of all the services in that runlevel */
-			RC_STRINGLIST *run_services = rc_services_in_runlevel(rlevel->value);
-
-			/* Start those services. */
-			rc_stringlist_sort(&run_services);
-			deporder = rc_deptree_depends(deptree, types_nua, run_services, rlevel->value, depoptions | RC_DEP_START);
-			rc_stringlist_free(run_services);
-			run_services = deporder;
-			do_start_services(run_services, parallel);
-
-			/* Wait for our services to finish */
-			wait_for_services();
-
-			/* Free the list of services, we're done with it. */
-			rc_stringlist_free(run_services);
-		}
-		rc_stringlist_free(runlevel_chain);
-	}
-
-#ifdef __linux__
-	/* If the "noinit" parameter was passed on the kernel command line then
-	 * mark the specified services as stopped so that our records reflect
-	 * reality.	 */
-	proc = p = rc_proc_getent("noinit");
-	if (proc) {
-		while ((token = strsep(&p, ",")))
-			rc_service_mark(token, RC_SERVICE_STOPPED);
-		free(proc);
-	}
-
-#endif
-
-	rc_plugin_run(RC_HOOK_RUNLEVEL_START_OUT, runlevel);
-	hook_out = 0;
-
-	/* If we're in the boot runlevel and we regenerated our dependencies
-	 * we need to delete them so that they are regenerated again in the
-	 * default runlevel as they may depend on things that are now
-	 * available */
-	if (regen && strcmp(runlevel, bootlevel) == 0)
-		unlink(RC_DEPTREE_CACHE);
-
-	return EXIT_SUCCESS;
-}
diff --git a/src/rc/runscript.c b/src/rc/runscript.c
deleted file mode 100644
index 0ac19661..00000000
--- a/src/rc/runscript.c
+++ /dev/null
@@ -1,1396 +0,0 @@
-/*
- * runscript.c
- * Handle launching of init scripts.
- */
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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 <sys/ioctl.h>
-#include <sys/file.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <fnmatch.h>
-#include <getopt.h>
-#include <libgen.h>
-#include <limits.h>
-#include <poll.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <termios.h>
-#include <time.h>
-#include <unistd.h>
-
-#if defined(__linux__) || (defined(__FreeBSD_kernel__) && \
-		defined(__GLIBC__))
-#  include <pty.h>
-#elif defined(__NetBSD__) || defined(__OpenBSD__)
-#  include <util.h>
-#else
-#  include <libutil.h>
-#endif
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-#include "rc-plugin.h"
-
-#ifdef HAVE_SELINUX
-#include "rc-selinux.h"
-#endif
-
-#define PREFIX_LOCK	RC_SVCDIR "/prefix.lock"
-
-#define WAIT_INTERVAL	20000000	/* usecs to poll the lock file */
-#define WAIT_TIMEOUT	60		/* seconds until we timeout */
-#define WARN_TIMEOUT	10		/* warn about this every N seconds */
-
-static const char *applet;
-static char *service, *runlevel, *ibsave, *prefix;
-static RC_DEPTREE *deptree;
-static RC_STRINGLIST *applet_list, *services, *tmplist;
-static RC_STRINGLIST *restart_services, *need_services, *use_services;
-static RC_HOOK hook_out;
-static int exclusive_fd = -1, master_tty = -1;
-static bool sighup, in_background, deps, dry_run;
-static pid_t service_pid;
-static int signal_pipe[2] = { -1, -1 };
-
-static RC_STRINGLIST *types_b, *types_n, *types_nu, *types_nua, *types_m;
-static RC_STRINGLIST *types_mua = NULL;
-
-static void
-handle_signal(int sig)
-{
-	int serrno = errno;
-	char signame[10] = { '\0' };
-	struct winsize ws;
-
-	switch (sig) {
-	case SIGHUP:
-		sighup = true;
-		break;
-
-	case SIGCHLD:
-		if (signal_pipe[1] > -1) {
-			if (write(signal_pipe[1], &sig, sizeof(sig)) == -1)
-				eerror("%s: send: %s",
-				    service, strerror(errno));
-		} else
-			rc_waitpid(-1);
-		break;
-
-	case SIGWINCH:
-		if (master_tty >= 0) {
-			ioctl(fileno(stdout), TIOCGWINSZ, &ws);
-			ioctl(master_tty, TIOCSWINSZ, &ws);
-		}
-		break;
-
-	case SIGINT:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGINT");
-		/* FALLTHROUGH */
-	case SIGTERM:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGTERM");
-		/* FALLTHROUGH */
-	case SIGQUIT:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGQUIT");
-		/* Send the signal to our children too */
-		if (service_pid > 0)
-			kill(service_pid, sig);
-		eerrorx("%s: caught %s, aborting", applet, signame);
-		/* NOTREACHED */
-
-	default:
-		eerror("%s: caught unknown signal %d", applet, sig);
-	}
-
-	/* Restore errno */
-	errno = serrno;
-}
-
-static void
-unhotplug()
-{
-	char file[PATH_MAX];
-
-	snprintf(file, sizeof(file), RC_SVCDIR "/hotplugged/%s", applet);
-	if (exists(file) && unlink(file) != 0)
-		eerror("%s: unlink `%s': %s", applet, file, strerror(errno));
-}
-
-static void
-start_services(RC_STRINGLIST *list)
-{
-	RC_STRING *svc;
-	RC_SERVICE state = rc_service_state (service);
-
-	if (!list)
-		return;
-
-	if (state & RC_SERVICE_INACTIVE ||
-	    state & RC_SERVICE_WASINACTIVE ||
-	    state & RC_SERVICE_STARTING ||
-	    state & RC_SERVICE_STARTED)
-	{
-		TAILQ_FOREACH(svc, list, entries) {
-			if (!(rc_service_state(svc->value) &
-				RC_SERVICE_STOPPED))
-				continue;
-			if (state & RC_SERVICE_INACTIVE ||
-			    state & RC_SERVICE_WASINACTIVE)
-			{
-				rc_service_schedule_start(service,
-				    svc->value);
-				ewarn("WARNING: %s will start when %s has started",
-				    svc->value, applet);
-			} else
-				service_start(svc->value);
-		}
-	}
-}
-
-static void
-restore_state(void)
-{
-	RC_SERVICE state;
-
-	if (rc_in_plugin || exclusive_fd == -1)
-		return;
-	state = rc_service_state(applet);
-	if (state & RC_SERVICE_STOPPING) {
-		if (state & RC_SERVICE_WASINACTIVE)
-			rc_service_mark(applet, RC_SERVICE_INACTIVE);
-		else
-			rc_service_mark(applet, RC_SERVICE_STARTED);
-		if (rc_runlevel_stopping())
-			rc_service_mark(applet, RC_SERVICE_FAILED);
-	} else if (state & RC_SERVICE_STARTING) {
-		if (state & RC_SERVICE_WASINACTIVE)
-			rc_service_mark(applet, RC_SERVICE_INACTIVE);
-		else
-			rc_service_mark(applet, RC_SERVICE_STOPPED);
-		if (rc_runlevel_starting())
-			rc_service_mark(applet, RC_SERVICE_FAILED);
-	}
-	exclusive_fd = svc_unlock(applet, exclusive_fd);
-}
-
-static void
-cleanup(void)
-{
-	restore_state();
-
-	if (!rc_in_plugin) {
-		if (hook_out) {
-			rc_plugin_run(hook_out, applet);
-			if (hook_out == RC_HOOK_SERVICE_START_DONE)
-				rc_plugin_run(RC_HOOK_SERVICE_START_OUT,
-				    applet);
-			else if (hook_out == RC_HOOK_SERVICE_STOP_DONE)
-				rc_plugin_run(RC_HOOK_SERVICE_STOP_OUT,
-				    applet);
-		}
-
-		if (restart_services)
-			start_services(restart_services);
-	}
-
-	rc_plugin_unload();
-
-#ifdef DEBUG_MEMORY
-	rc_stringlist_free(types_b);
-	rc_stringlist_free(types_n);
-	rc_stringlist_free(types_nu);
-	rc_stringlist_free(types_nua);
-	rc_stringlist_free(types_m);
-	rc_stringlist_free(types_mua);
-	rc_deptree_free(deptree);
-	rc_stringlist_free(restart_services);
-	rc_stringlist_free(need_services);
-	rc_stringlist_free(use_services);
-	rc_stringlist_free(services);
-	rc_stringlist_free(applet_list);
-	rc_stringlist_free(tmplist);
-	free(ibsave);
-	free(service);
-	free(prefix);
-	free(runlevel);
-#endif
-}
-
-/* Buffer and lock all output messages so that we get readable content */
-/* FIXME: Use a dynamic lock file that contains the tty/pts as well.
- * For example openrc-pts8.lock or openrc-tty1.lock.
- * Using a static lock file makes no sense, esp. in multi-user environments.
- * Why don't we use (f)printf, as it is thread-safe through POSIX already?
- * Bug: 360013
- */
-static int
-write_prefix(const char *buffer, size_t bytes, bool *prefixed)
-{
-	size_t i, j;
-	const char *ec = ecolor(ECOLOR_HILITE);
-	const char *ec_normal = ecolor(ECOLOR_NORMAL);
-	ssize_t ret = 0;
-	int fd = fileno(stdout), lock_fd = -1;
-
-	/*
-	 * Lock the prefix.
-	 * open() may fail here when running as user, as RC_SVCDIR may not be writable.
-	 */
-	lock_fd = open(PREFIX_LOCK, O_WRONLY | O_CREAT, 0664);
-
-	if (lock_fd != -1) {
-		while (flock(lock_fd, LOCK_EX) != 0) {
-			if (errno != EINTR) {
-				ewarnv("flock() failed: %s", strerror(errno));
-				break;
-			}
-		}
-	}
-	else
-		ewarnv("Couldn't open the prefix lock, please make sure you have enough permissions");
-
-	for (i = 0; i < bytes; i++) {
-		/* We don't prefix eend calls (cursor up) */
-		if (buffer[i] == '\033' && !*prefixed) {
-			for (j = i + 1; j < bytes; j++) {
-				if (buffer[j] == 'A')
-					*prefixed = true;
-				if (isalpha((unsigned int)buffer[j]))
-					break;
-			}
-		}
-
-		if (!*prefixed) {
-			ret += write(fd, ec, strlen(ec));
-			ret += write(fd, prefix, strlen(prefix));
-			ret += write(fd, ec_normal, strlen(ec_normal));
-			ret += write(fd, "|", 1);
-			*prefixed = true;
-		}
-
-		if (buffer[i] == '\n')
-			*prefixed = false;
-		ret += write(fd, buffer + i, 1);
-	}
-
-	/* Release the lock */
-	close(lock_fd);
-
-	return ret;
-}
-
-static int
-svc_exec(const char *arg1, const char *arg2)
-{
-	int ret, fdout = fileno(stdout);
-	struct termios tt;
-	struct winsize ws;
-	int i;
-	int flags = 0;
-	struct pollfd fd[2];
-	int s;
-	char *buffer;
-	size_t bytes;
-	bool prefixed = false;
-	int slave_tty;
-	sigset_t sigchldmask;
-	sigset_t oldmask;
-
-	/* Setup our signal pipe */
-	if (pipe(signal_pipe) == -1)
-		eerrorx("%s: pipe: %s", service, applet);
-	for (i = 0; i < 2; i++)
-		if ((flags = fcntl(signal_pipe[i], F_GETFD, 0) == -1 ||
-			fcntl(signal_pipe[i], F_SETFD, flags | FD_CLOEXEC) == -1))
-			eerrorx("%s: fcntl: %s", service, strerror(errno));
-
-	/* Open a pty for our prefixed output
-	 * We do this instead of mapping pipes to stdout, stderr so that
-	 * programs can tell if they're attached to a tty or not.
-	 * The only loss is that we can no longer tell the difference
-	 * between the childs stdout or stderr */
-	master_tty = slave_tty = -1;
-	if (prefix && isatty(fdout)) {
-		tcgetattr(fdout, &tt);
-		ioctl(fdout, TIOCGWINSZ, &ws);
-
-		/* If the below call fails due to not enough ptys then we don't
-		 * prefix the output, but we still work */
-		openpty(&master_tty, &slave_tty, NULL, &tt, &ws);
-		if (master_tty >= 0 &&
-		    (flags = fcntl(master_tty, F_GETFD, 0)) == 0)
-			fcntl(master_tty, F_SETFD, flags | FD_CLOEXEC);
-
-		if (slave_tty >=0 &&
-		    (flags = fcntl(slave_tty, F_GETFD, 0)) == 0)
-			fcntl(slave_tty, F_SETFD, flags | FD_CLOEXEC);
-	}
-
-	service_pid = fork();
-	if (service_pid == -1)
-		eerrorx("%s: fork: %s", service, strerror(errno));
-	if (service_pid == 0) {
-		if (slave_tty >= 0) {
-			dup2(slave_tty, STDOUT_FILENO);
-			dup2(slave_tty, STDERR_FILENO);
-		}
-
-		if (exists(RC_SVCDIR "/runscript.sh")) {
-			execl(RC_SVCDIR "/runscript.sh",
-			    RC_SVCDIR "/runscript.sh",
-			    service, arg1, arg2, (char *) NULL);
-			eerror("%s: exec `" RC_SVCDIR "/runscript.sh': %s",
-			    service, strerror(errno));
-			_exit(EXIT_FAILURE);
-		} else {
-			execl(RC_LIBEXECDIR "/sh/runscript.sh",
-			    RC_LIBEXECDIR "/sh/runscript.sh",
-			    service, arg1, arg2, (char *) NULL);
-			eerror("%s: exec `" RC_LIBEXECDIR "/sh/runscript.sh': %s",
-			    service, strerror(errno));
-			_exit(EXIT_FAILURE);
-		}
-	}
-
-	buffer = xmalloc(sizeof(char) * BUFSIZ);
-	fd[0].fd = signal_pipe[0];
-	fd[0].events = fd[1].events = POLLIN;
-	fd[0].revents = fd[1].revents = 0;
-	if (master_tty >= 0) {
-		fd[1].fd = master_tty;
-		fd[1].events = POLLIN;
-		fd[1].revents = 0;
-	}
-
-	for (;;) {
-		if ((s = poll(fd, master_tty >= 0 ? 2 : 1, -1)) == -1) {
-			if (errno != EINTR) {
-				eerror("%s: poll: %s",
-				    service, strerror(errno));
-				break;
-			}
-		}
-
-		if (s > 0) {
-			if (fd[1].revents & (POLLIN | POLLHUP)) {
-				bytes = read(master_tty, buffer, BUFSIZ);
-				write_prefix(buffer, bytes, &prefixed);
-			}
-
-			/* Only SIGCHLD signals come down this pipe */
-			if (fd[0].revents & (POLLIN | POLLHUP))
-				break;
-		}
-	}
-
-	free(buffer);
-
-	sigemptyset (&sigchldmask);
-	sigaddset (&sigchldmask, SIGCHLD);
-	sigprocmask (SIG_BLOCK, &sigchldmask, &oldmask);
-
-	close(signal_pipe[0]);
-	close(signal_pipe[1]);
-	signal_pipe[0] = signal_pipe[1] = -1;
-
-	sigprocmask (SIG_SETMASK, &oldmask, NULL);
-
-	if (master_tty >= 0) {
-		/* Why did we do this? */
-		/* signal (SIGWINCH, SIG_IGN); */
-		close(master_tty);
-		master_tty = -1;
-	}
-
-	ret = rc_waitpid(service_pid);
-	ret = WEXITSTATUS(ret);
-	if (ret != 0 && errno == ECHILD)
-		/* killall5 -9 could cause this */
-		ret = 0;
-	service_pid = 0;
-
-	return ret;
-}
-
-static bool
-svc_wait(const char *svc)
-{
-	char file[PATH_MAX];
-	int fd;
-	bool forever = false;
-	RC_STRINGLIST *keywords;
-	struct timespec interval, timeout, warn;
-
-	/* Some services don't have a timeout, like fsck */
-	keywords = rc_deptree_depend(deptree, svc, "keyword");
-	if (rc_stringlist_find(keywords, "-timeout") ||
-	    rc_stringlist_find(keywords, "notimeout"))
-		forever = true;
-	rc_stringlist_free(keywords);
-
-	snprintf(file, sizeof(file), RC_SVCDIR "/exclusive/%s",
-	    basename_c(svc));
-
-	interval.tv_sec = 0;
-	interval.tv_nsec = WAIT_INTERVAL;
-	timeout.tv_sec = WAIT_TIMEOUT;
-	timeout.tv_nsec = 0;
-	warn.tv_sec = WARN_TIMEOUT;
-	warn.tv_nsec = 0;
-	for (;;) {
-		fd = open(file, O_RDONLY | O_NONBLOCK);
-		if (fd != -1) {
-			if (flock(fd, LOCK_SH | LOCK_NB) == 0) {
-				close(fd);
-				return true;
-			}
-			close(fd);
-		}
-		if (errno == ENOENT)
-			return true;
-		if (errno != EWOULDBLOCK)
-			eerrorx("%s: open `%s': %s", applet, file,
-			    strerror(errno));
-		if (nanosleep(&interval, NULL) == -1) {
-			if (errno != EINTR)
-				return false;
-		}
-		if (!forever) {
-			timespecsub(&timeout, &interval, &timeout);
-			if (timeout.tv_sec <= 0)
-				return false;
-			timespecsub(&warn, &interval, &warn);
-			if (warn.tv_sec <= 0) {
-				ewarn("%s: waiting for %s (%d seconds)",
-				    applet, svc, (int)timeout.tv_sec);
-				warn.tv_sec = WARN_TIMEOUT;
-				warn.tv_nsec = 0;
-			}
-		}
-	}
-	return false;
-}
-
-static void
-get_started_services(void)
-{
-	RC_STRINGLIST *tmp = rc_services_in_state(RC_SERVICE_INACTIVE);
-
-	rc_stringlist_free(restart_services);
-	restart_services = rc_services_in_state(RC_SERVICE_STARTED);
-	TAILQ_CONCAT(restart_services, tmp, entries);
-	free(tmp);
-}
-
-static void
-setup_types(void)
-{
-	types_b = rc_stringlist_new();
-	rc_stringlist_add(types_b, "broken");
-
-	types_n = rc_stringlist_new();
-	rc_stringlist_add(types_n, "ineed");
-
-	types_nu = rc_stringlist_new();
-	rc_stringlist_add(types_nu, "ineed");
-	rc_stringlist_add(types_nu, "iuse");
-
-	types_nua = rc_stringlist_new();
-	rc_stringlist_add(types_nua, "ineed");
-	rc_stringlist_add(types_nua, "iuse");
-	rc_stringlist_add(types_nua, "iafter");
-
-	types_m = rc_stringlist_new();
-	rc_stringlist_add(types_m, "needsme");
-
-	types_mua = rc_stringlist_new();
-	rc_stringlist_add(types_mua, "needsme");
-	rc_stringlist_add(types_mua, "usesme");
-	rc_stringlist_add(types_mua, "beforeme");
-}
-
-static void
-svc_start_check(void)
-{
-	RC_SERVICE state;
-
-	state = rc_service_state(service);
-
-	if (in_background) {
-		if (!(state & (RC_SERVICE_INACTIVE | RC_SERVICE_STOPPED)))
-			exit(EXIT_FAILURE);
-		if (rc_yesno(getenv("IN_HOTPLUG")))
-			rc_service_mark(service, RC_SERVICE_HOTPLUGGED);
-		if (strcmp(runlevel, RC_LEVEL_SYSINIT) == 0)
-			ewarnx("WARNING: %s will be started in the"
-			    " next runlevel", applet);
-	}
-
-	if (exclusive_fd == -1)
-		exclusive_fd = svc_lock(applet);
-	if (exclusive_fd == -1) {
-		if (errno == EACCES)
-			eerrorx("%s: superuser access required", applet);
-		if (state & RC_SERVICE_STOPPING)
-			ewarnx("WARNING: %s is stopping", applet);
-		else
-			ewarnx("WARNING: %s is already starting", applet);
-	}
-	fcntl(exclusive_fd, F_SETFD,
-	    fcntl(exclusive_fd, F_GETFD, 0) | FD_CLOEXEC);
-
-	if (state & RC_SERVICE_STARTED) {
-		ewarn("WARNING: %s has already been started", applet);
-		exit(EXIT_SUCCESS);
-	}
-	else if (state & RC_SERVICE_INACTIVE && !in_background)
-		ewarnx("WARNING: %s has already started, but is inactive",
-		    applet);
-
-	rc_service_mark(service, RC_SERVICE_STARTING);
-	hook_out = RC_HOOK_SERVICE_START_OUT;
-	rc_plugin_run(RC_HOOK_SERVICE_START_IN, applet);
-}
-
-static void
-svc_start_deps(void)
-{
-	bool first;
-	RC_STRING *svc, *svc2;
-	RC_SERVICE state;
-	int depoptions = RC_DEP_TRACE, n;
-	size_t len;
-	char *p, *tmp;
-	pid_t pid;
-
-	errno = 0;
-	if (rc_conf_yesno("rc_depend_strict") || errno == ENOENT)
-		depoptions |= RC_DEP_STRICT;
-
-	if (!deptree && ((deptree = _rc_deptree_load(0, NULL)) == NULL))
-		eerrorx("failed to load deptree");
-	if (!types_b)
-		setup_types();
-
-	services = rc_deptree_depends(deptree, types_b, applet_list,
-	    runlevel, 0);
-	if (TAILQ_FIRST(services)) {
-		eerrorn("ERROR: %s needs service(s) ", applet);
-		first = true;
-		TAILQ_FOREACH(svc, services, entries) {
-			if (first)
-				first = false;
-			else
-				fprintf(stderr, ", ");
-			fprintf(stderr, "%s", svc->value);
-		}
-		fprintf(stderr, "\n");
-		exit(EXIT_FAILURE);
-	}
-	rc_stringlist_free(services);
-	services = NULL;
-
-	need_services = rc_deptree_depends(deptree, types_n,
-	    applet_list, runlevel, depoptions);
-	use_services = rc_deptree_depends(deptree, types_nu,
-	    applet_list, runlevel, depoptions);
-
-	if (!rc_runlevel_starting()) {
-		TAILQ_FOREACH(svc, use_services, entries) {
-			state = rc_service_state(svc->value);
-			/* Don't stop failed services again.
-			 * If you remove this check, ensure that the
-			 * exclusive file isn't created. */
-			if (state & RC_SERVICE_FAILED &&
-			    rc_runlevel_starting())
-				continue;
-			if (state & RC_SERVICE_STOPPED) {
-				if (dry_run) {
-					printf(" %s", svc->value);
-					continue;
-				}
-				pid = service_start(svc->value);
-				if (!rc_conf_yesno("rc_parallel"))
-					rc_waitpid(pid);
-			}
-		}
-	}
-
-	if (dry_run)
-		return;
-
-	/* Now wait for them to start */
-	services = rc_deptree_depends(deptree, types_nua, applet_list,
-	    runlevel, depoptions);
-	/* We use tmplist to hold our scheduled by list */
-	tmplist = rc_stringlist_new();
-	TAILQ_FOREACH(svc, services, entries) {
-		state = rc_service_state(svc->value);
-		if (state & RC_SERVICE_STARTED)
-			continue;
-
-		/* Don't wait for services which went inactive but are
-		 * now in starting state which we are after */
-		if (state & RC_SERVICE_STARTING &&
-		    state & RC_SERVICE_WASINACTIVE)
-		{
-			if (!rc_stringlist_find(need_services, svc->value) &&
-			    !rc_stringlist_find(use_services, svc->value))
-				continue;
-		}
-
-		if (!svc_wait(svc->value))
-			eerror("%s: timed out waiting for %s",
-			    applet, svc->value);
-		state = rc_service_state(svc->value);
-		if (state & RC_SERVICE_STARTED)
-			continue;
-		if (rc_stringlist_find(need_services, svc->value)) {
-			if (state & RC_SERVICE_INACTIVE ||
-			    state & RC_SERVICE_WASINACTIVE)
-			{
-				rc_stringlist_add(tmplist, svc->value);
-			} else if (!TAILQ_FIRST(tmplist))
-				eerrorx("ERROR: cannot start %s as"
-				    " %s would not start",
-				    applet, svc->value);
-		}
-	}
-
-	if (TAILQ_FIRST(tmplist)) {
-		/* Set the state now, then unlink our exclusive so that
-		   our scheduled list is preserved */
-		rc_service_mark(service, RC_SERVICE_STOPPED);
-
-		rc_stringlist_free(use_services);
-		use_services = NULL;
-		len = 0;
-		n = 0;
-		TAILQ_FOREACH(svc, tmplist, entries) {
-			rc_service_schedule_start(svc->value, service);
-			use_services = rc_deptree_depend(deptree,
-			    "iprovide", svc->value);
-			TAILQ_FOREACH(svc2, use_services, entries)
-			    rc_service_schedule_start(svc2->value, service);
-			rc_stringlist_free(use_services);
-			use_services = NULL;
-			len += strlen(svc->value) + 2;
-			n++;
-		}
-
-		len += 5;
-		tmp = p = xmalloc(sizeof(char) * len);
-		TAILQ_FOREACH(svc, tmplist, entries) {
-			if (p != tmp)
-				p += snprintf(p, len, ", ");
-			p += snprintf(p, len - (p - tmp),
-			    "%s", svc->value);
-		}
-		rc_stringlist_free(tmplist);
-		tmplist = NULL;
-		ewarnx("WARNING: %s will start when %s has started", applet, tmp);
-		free(tmp);
-	}
-
-	rc_stringlist_free(tmplist);
-	tmplist = NULL;
-	rc_stringlist_free(services);
-	services = NULL;
-}
-
-static void svc_start_real()
-{
-	bool started;
-	RC_STRING *svc, *svc2;
-
-	if (ibsave)
-		setenv("IN_BACKGROUND", ibsave, 1);
-	hook_out = RC_HOOK_SERVICE_START_DONE;
-	rc_plugin_run(RC_HOOK_SERVICE_START_NOW, applet);
-	started = (svc_exec("start", NULL) == 0);
-	if (ibsave)
-		unsetenv("IN_BACKGROUND");
-
-	if (rc_service_state(service) & RC_SERVICE_INACTIVE)
-		ewarnx("WARNING: %s has started, but is inactive", applet);
-	else if (!started)
-		eerrorx("ERROR: %s failed to start", applet);
-
-	rc_service_mark(service, RC_SERVICE_STARTED);
-	exclusive_fd = svc_unlock(applet, exclusive_fd);
-	hook_out = RC_HOOK_SERVICE_START_OUT;
-	rc_plugin_run(RC_HOOK_SERVICE_START_DONE, applet);
-
-	/* Now start any scheduled services */
-	services = rc_services_scheduled(service);
-	TAILQ_FOREACH(svc, services, entries)
-	    if (rc_service_state(svc->value) & RC_SERVICE_STOPPED)
-		    service_start(svc->value);
-	rc_stringlist_free(services);
-	services = NULL;
-
-	/* Do the same for any services we provide */
-	if (deptree) {
-		tmplist = rc_deptree_depend(deptree, "iprovide", applet);
-		TAILQ_FOREACH(svc, tmplist, entries) {
-			services = rc_services_scheduled(svc->value);
-			TAILQ_FOREACH(svc2, services, entries)
-			    if (rc_service_state(svc2->value) &
-				RC_SERVICE_STOPPED)
-				    service_start(svc2->value);
-			rc_stringlist_free(services);
-			services = NULL;
-		}
-		rc_stringlist_free(tmplist);
-		tmplist = NULL;
-	}
-
-	hook_out = 0;
-	rc_plugin_run(RC_HOOK_SERVICE_START_OUT, applet);
-}
-
-static void
-svc_start(void)
-{
-	if (dry_run)
-		einfon("start:");
-	else
-		svc_start_check();
-	if (deps)
-		svc_start_deps();
-	if (dry_run)
-		printf(" %s\n", applet);
-	else
-		svc_start_real();
-}
-
-static int
-svc_stop_check(RC_SERVICE *state)
-{
-	*state = rc_service_state(service);
-
-	if (rc_runlevel_stopping() && *state & RC_SERVICE_FAILED)
-		exit(EXIT_FAILURE);
-
-	if (in_background &&
-	    !(*state & RC_SERVICE_STARTED) &&
-	    !(*state & RC_SERVICE_INACTIVE))
-		exit(EXIT_FAILURE);
-
-	if (exclusive_fd == -1)
-		exclusive_fd = svc_lock(applet);
-	if (exclusive_fd == -1) {
-		if (errno == EACCES)
-			eerrorx("%s: superuser access required", applet);
-		if (*state & RC_SERVICE_STOPPING)
-			ewarnx("WARNING: %s is already stopping", applet);
-		eerrorx("ERROR: %s stopped by something else", applet);
-	}
-	fcntl(exclusive_fd, F_SETFD,
-	    fcntl(exclusive_fd, F_GETFD, 0) | FD_CLOEXEC);
-
-	if (*state & RC_SERVICE_STOPPED) {
-		ewarn("WARNING: %s is already stopped", applet);
-		return 1;
-	}
-
-	rc_service_mark(service, RC_SERVICE_STOPPING);
-	hook_out = RC_HOOK_SERVICE_STOP_OUT;
-	rc_plugin_run(RC_HOOK_SERVICE_STOP_IN, applet);
-
-	if (!rc_runlevel_stopping()) {
-		if (rc_service_in_runlevel(service, RC_LEVEL_SYSINIT))
-			ewarn("WARNING: you are stopping a sysinit service");
-		else if (rc_service_in_runlevel(service, RC_LEVEL_BOOT))
-			ewarn("WARNING: you are stopping a boot service");
-	}
-
-	return 0;
-}
-
-static void
-svc_stop_deps(RC_SERVICE state)
-{
-	int depoptions = RC_DEP_TRACE;
-	RC_STRING *svc;
-	pid_t pid;
-
-	if (state & RC_SERVICE_WASINACTIVE)
-		return;
-
-	errno = 0;
-	if (rc_conf_yesno("rc_depend_strict") || errno == ENOENT)
-		depoptions |= RC_DEP_STRICT;
-
-	if (!deptree && ((deptree = _rc_deptree_load(0, NULL)) == NULL))
-		eerrorx("failed to load deptree");
-
-	if (!types_m)
-		setup_types();
-
-	services = rc_deptree_depends(deptree, types_m, applet_list,
-	    runlevel, depoptions);
-	tmplist = rc_stringlist_new();
-	TAILQ_FOREACH_REVERSE(svc, services, rc_stringlist, entries) {
-		state = rc_service_state(svc->value);
-		/* Don't stop failed services again.
-		 * If you remove this check, ensure that the
-		 * exclusive file isn't created. */
-		if (state & RC_SERVICE_FAILED &&
-		    rc_runlevel_stopping())
-			continue;
-		if (state & RC_SERVICE_STARTED ||
-		    state & RC_SERVICE_INACTIVE)
-		{
-			if (dry_run) {
-				printf(" %s", svc->value);
-				continue;
-			}
-			svc_wait(svc->value);
-			state = rc_service_state(svc->value);
-			if (state & RC_SERVICE_STARTED ||
-			    state & RC_SERVICE_INACTIVE)
-			{
-				pid = service_stop(svc->value);
-				if (!rc_conf_yesno("rc_parallel"))
-					rc_waitpid(pid);
-				rc_stringlist_add(tmplist, svc->value);
-			}
-		}
-	}
-	rc_stringlist_free(services);
-	services = NULL;
-	if (dry_run)
-		return;
-
-	TAILQ_FOREACH(svc, tmplist, entries) {
-		if (rc_service_state(svc->value) & RC_SERVICE_STOPPED)
-			continue;
-		svc_wait(svc->value);
-		if (rc_service_state(svc->value) & RC_SERVICE_STOPPED)
-			continue;
-		if (rc_runlevel_stopping()) {
-			/* If shutting down, we should stop even
-			 * if a dependant failed */
-			if (runlevel &&
-			    (strcmp(runlevel,
-				RC_LEVEL_SHUTDOWN) == 0 ||
-				strcmp(runlevel,
-				    RC_LEVEL_SINGLE) == 0))
-				continue;
-			rc_service_mark(service, RC_SERVICE_FAILED);
-		}
-		eerrorx("ERROR: cannot stop %s as %s "
-		    "is still up", applet, svc->value);
-	}
-	rc_stringlist_free(tmplist);
-	tmplist = NULL;
-
-	/* We now wait for other services that may use us and are
-	 * stopping. This is important when a runlevel stops */
-	services = rc_deptree_depends(deptree, types_mua, applet_list,
-	    runlevel, depoptions);
-	TAILQ_FOREACH(svc, services, entries) {
-		if (rc_service_state(svc->value) & RC_SERVICE_STOPPED)
-			continue;
-		svc_wait(svc->value);
-	}
-	rc_stringlist_free(services);
-	services = NULL;
-}
-
-static void
-svc_stop_real(void)
-{
-	bool stopped;
-
-	/* If we're stopping localmount, set LC_ALL=C so that
-	 * bash doesn't load anything blocking the unmounting of /usr */
-	if (strcmp(applet, "localmount") == 0)
-		setenv("LC_ALL", "C", 1);
-
-	if (ibsave)
-		setenv("IN_BACKGROUND", ibsave, 1);
-	hook_out = RC_HOOK_SERVICE_STOP_DONE;
-	rc_plugin_run(RC_HOOK_SERVICE_STOP_NOW, applet);
-	stopped = (svc_exec("stop", NULL) == 0);
-	if (ibsave)
-		unsetenv("IN_BACKGROUND");
-
-	if (!stopped)
-		eerrorx("ERROR: %s failed to stop", applet);
-
-	if (in_background)
-		rc_service_mark(service, RC_SERVICE_INACTIVE);
-	else
-		rc_service_mark(service, RC_SERVICE_STOPPED);
-
-	hook_out = RC_HOOK_SERVICE_STOP_OUT;
-	rc_plugin_run(RC_HOOK_SERVICE_STOP_DONE, applet);
-	hook_out = 0;
-	rc_plugin_run(RC_HOOK_SERVICE_STOP_OUT, applet);
-}
-
-static int
-svc_stop(void)
-{
-	RC_SERVICE state;
-
-	state = 0;
-	if (dry_run)
-		einfon("stop:");
-	else
-		if (svc_stop_check(&state) == 1)
-			return 1; /* Service has been stopped already */
-	if (deps)
-		svc_stop_deps(state);
-	if (dry_run)
-		printf(" %s\n", applet);
-	else
-		svc_stop_real();
-
-	return 0;
-}
-
-static void
-svc_restart(void)
-{
-	/* This is hairly and a better way needs to be found I think!
-	 * The issue is this - openvpn need net and dns. net can restart
-	 * dns via resolvconf, so you could have openvpn trying to restart
-	 * dnsmasq which in turn is waiting on net which in turn is waiting
-	 * on dnsmasq.
-	 * The work around is for resolvconf to restart its services with
-	 * --nodeps which means just that.
-	 * The downside is that there is a small window when our status is
-	 * invalid.
-	 * One workaround would be to introduce a new status,
-	 * or status locking. */
-	if (!deps) {
-		RC_SERVICE state = rc_service_state(service);
-		if (state & RC_SERVICE_STARTED || state & RC_SERVICE_INACTIVE)
-			svc_exec("stop", "start");
-		else
-			svc_exec("start", NULL);
-		return;
-	}
-
-	if (!(rc_service_state(service) & RC_SERVICE_STOPPED)) {
-		get_started_services();
-		svc_stop();
-		if (dry_run)
-			ewarn("Cannot calculate restart start dependencies"
-			    " on a dry-run");
-	}
-
-	svc_start();
-	start_services(restart_services);
-	rc_stringlist_free(restart_services);
-	restart_services = NULL;
-}
-
-static bool
-service_plugable(void)
-{
-	char *list, *p, *token;
-	bool allow = true, truefalse;
-	char *match = rc_conf_value("rc_hotplug");
-
-	if (!match)
-		match = rc_conf_value("rc_plug_services");
-	if (!match)
-		return false;
-
-	list = xstrdup(match);
-	p = list;
-	while ((token = strsep(&p, " "))) {
-		if (token[0] == '!') {
-			truefalse = false;
-			token++;
-		} else
-			truefalse = true;
-
-		if (fnmatch(token, applet, 0) == 0) {
-			allow = truefalse;
-			break;
-		}
-	}
-#ifdef DEBUG_MEMORY
-	free(list);
-#endif
-	return allow;
-}
-
-#include "_usage.h"
-#define getoptstring "dDsSvl:Z" getoptstring_COMMON
-#define extraopts "stop | start | restart | describe | zap"
-static const struct option longopts[] = {
-	{ "debug",      0, NULL, 'd'},
-	{ "dry-run",    0, NULL, 'Z'},
-	{ "ifstarted",  0, NULL, 's'},
-	{ "ifstopped",  0, NULL, 'S'},
-	{ "nodeps",     0, NULL, 'D'},
-	{ "lockfd",     1, NULL, 'l'},
-	longopts_COMMON
-};
-static const char *const longopts_help[] = {
-	"set xtrace when running the script",
-	"show what would be done",
-	"only run commands when started",
-	"only run commands when stopped",
-	"ignore dependencies",
-	"fd of the exclusive lock from rc",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-openrc_run(int argc, char **argv)
-{
-	bool doneone = false;
-	int retval, opt, depoptions = RC_DEP_TRACE;
-	RC_STRING *svc;
-	char path[PATH_MAX], lnk[PATH_MAX];
-	char *dir, *save = NULL, *saveLnk = NULL;
-	char pidstr[10];
-	size_t l = 0, ll;
- 	const char *file;
-	struct stat stbuf;
-
-	/* Show help if insufficient args */
-	if (argc < 2 || !exists(argv[1])) {
-		fprintf(stderr, "openrc-run should not be run directly\n");
-		exit(EXIT_FAILURE);
-	}
-
-	if (stat(argv[1], &stbuf) != 0) {
-		fprintf(stderr, "openrc-run `%s': %s\n",
-		    argv[1], strerror(errno));
-		exit(EXIT_FAILURE);
-	}
-
-	atexit(cleanup);
-
-	/* We need to work out the real full path to our service.
-	 * This works fine, provided that we ONLY allow multiplexed services
-	 * to exist in the same directory as the master link.
-	 * Also, the master link as to be a real file in the init dir. */
-	if (!realpath(argv[1], path)) {
-		fprintf(stderr, "realpath: %s\n", strerror(errno));
-		exit(EXIT_FAILURE);
-	}
-	memset(lnk, 0, sizeof(lnk));
-	if (readlink(argv[1], lnk, sizeof(lnk)-1)) {
-		dir = dirname(path);
-		if (strchr(lnk, '/')) {
-			save = xstrdup(dir);
-			saveLnk = xstrdup(lnk);
-			dir = dirname(saveLnk);
-			if (strcmp(dir, save) == 0)
-				file = basename_c(argv[1]);
-			else
-				file = basename_c(lnk);
-			dir = save;
-		} else
-			file = basename_c(argv[1]);
-		ll = strlen(dir) + strlen(file) + 2;
-		service = xmalloc(ll);
-		snprintf(service, ll, "%s/%s", dir, file);
-		if (stat(service, &stbuf) != 0) {
-			free(service);
-			service = xstrdup(lnk);
-		}
-		free(save);
-		free(saveLnk);
-	}
-	if (!service)
-		service = xstrdup(path);
-	applet = basename_c(service);
-
-	if (argc < 3)
-		usage(EXIT_FAILURE);
-
-	/* Change dir to / to ensure all init scripts don't use stuff in pwd */
-	if (chdir("/") == -1)
-		eerror("chdir: %s", strerror(errno));
-
-	if ((runlevel = xstrdup(getenv("RC_RUNLEVEL"))) == NULL) {
-		env_filter();
-		env_config();
-		runlevel = rc_runlevel_get();
-	}
-
-	setenv("EINFO_LOG", service, 1);
-	setenv("RC_SVCNAME", applet, 1);
-
-	/* Set an env var so that we always know our pid regardless of any
-	   subshells the init script may create so that our mark_service_*
-	   functions can always instruct us of this change */
-	snprintf(pidstr, sizeof(pidstr), "%d", (int) getpid());
-	setenv("RC_RUNSCRIPT_PID", pidstr, 1);
-
-	/* eprefix is kinda klunky, but it works for our purposes */
-	if (rc_conf_yesno("rc_parallel")) {
-		/* Get the longest service name */
-		services = rc_services_in_runlevel(NULL);
-		TAILQ_FOREACH(svc, services, entries) {
-			ll = strlen(svc->value);
-			if (ll > l)
-				l = ll;
-		}
-		rc_stringlist_free(services);
-		services = NULL;
-		ll = strlen(applet);
-		if (ll > l)
-			l = ll;
-
-		/* Make our prefix string */
-		prefix = xmalloc(sizeof(char) * l + 1);
-		ll = strlen(applet);
-		memcpy(prefix, applet, ll);
-		memset(prefix + ll, ' ', l - ll);
-		memset(prefix + l, 0, 1);
-		eprefix(prefix);
-	}
-
-#ifdef HAVE_SELINUX
-	/* Ok, we are ready to go, so setup selinux if applicable */
-	selinux_setup(argv);
-#endif
-
-	deps = true;
-
-	/* Punt the first arg as its our service name */
-	argc--;
-	argv++;
-
-	/* Right then, parse any options there may be */
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *)0)) != -1)
-		switch (opt) {
-		case 'd':
-			setenv("RC_DEBUG", "YES", 1);
-			break;
-		case 'l':
-			exclusive_fd = atoi(optarg);
-			fcntl(exclusive_fd, F_SETFD,
-			    fcntl(exclusive_fd, F_GETFD, 0) | FD_CLOEXEC);
-			break;
-		case 's':
-			if (!(rc_service_state(service) & RC_SERVICE_STARTED))
-				exit(EXIT_FAILURE);
-			break;
-		case 'S':
-			if (!(rc_service_state(service) & RC_SERVICE_STOPPED))
-				exit(EXIT_FAILURE);
-			break;
-		case 'D':
-			deps = false;
-			break;
-		case 'Z':
-			dry_run = true;
-			break;
-		case_RC_COMMON_GETOPT
-		}
-
-	/* If we're changing runlevels and not called by rc then we cannot
-	   work with any dependencies */
-	if (deps && getenv("RC_PID") == NULL &&
-	    (rc_runlevel_starting() || rc_runlevel_stopping()))
-		deps = false;
-
-	/* Save the IN_BACKGROUND env flag so it's ONLY passed to the service
-	   that is being called and not any dependents */
-	if (getenv("IN_BACKGROUND")) {
-		ibsave = xstrdup(getenv("IN_BACKGROUND"));
-		in_background = rc_yesno(ibsave);
-		unsetenv("IN_BACKGROUND");
-	}
-
-	if (rc_yesno(getenv("IN_HOTPLUG"))) {
-		if (!service_plugable())
-			eerrorx("%s: not allowed to be hotplugged", applet);
-		in_background = true;
-	}
-
-	/* Setup a signal handler */
-	signal_setup(SIGHUP, handle_signal);
-	signal_setup(SIGINT, handle_signal);
-	signal_setup(SIGQUIT, handle_signal);
-	signal_setup(SIGTERM, handle_signal);
-	signal_setup(SIGCHLD, handle_signal);
-
-	/* Load our plugins */
-	rc_plugin_load();
-
-	applet_list = rc_stringlist_new();
-	rc_stringlist_add(applet_list, applet);
-
-	/* Now run each option */
-	retval = EXIT_SUCCESS;
-	while (optind < argc) {
-		optarg = argv[optind++];
-
-		/* Abort on a sighup here */
-		if (sighup)
-			exit (EXIT_FAILURE);
-
-		/* Export the command we're running.
-		   This is important as we stamp on the restart function now but
-		   some start/stop routines still need to behave differently if
-		   restarting. */
-		unsetenv("RC_CMD");
-		setenv("RC_CMD", optarg, 1);
-
-		doneone = true;
-
-		if (strcmp(optarg, "describe") == 0 ||
-		    strcmp(optarg, "help") == 0 ||
-		    strcmp(optarg, "depend") == 0)
-		{
-			save = prefix;
-			eprefix(NULL);
-			prefix = NULL;
-			svc_exec(optarg, NULL);
-			eprefix(save);
-			prefix = save;
-		} else if (strcmp(optarg, "ineed") == 0 ||
-		    strcmp(optarg, "iuse") == 0 ||
-		    strcmp(optarg, "needsme") == 0 ||
-		    strcmp(optarg, "usesme") == 0 ||
-		    strcmp(optarg, "iafter") == 0 ||
-		    strcmp(optarg, "ibefore") == 0 ||
-		    strcmp(optarg, "iprovide") == 0)
-		{
-			errno = 0;
-			if (rc_conf_yesno("rc_depend_strict") ||
-			    errno == ENOENT)
-				depoptions |= RC_DEP_STRICT;
-
-			if (!deptree &&
-			    ((deptree = _rc_deptree_load(0, NULL)) == NULL))
-				eerrorx("failed to load deptree");
-
-			tmplist = rc_stringlist_new();
-			rc_stringlist_add(tmplist, optarg);
-			services = rc_deptree_depends(deptree, tmplist,
-			    applet_list,
-			    runlevel, depoptions);
-			rc_stringlist_free(tmplist);
-			TAILQ_FOREACH(svc, services, entries)
-			    printf("%s ", svc->value);
-			printf ("\n");
-			rc_stringlist_free(services);
-			services = NULL;
-		} else if (strcmp (optarg, "status") == 0) {
-			save = prefix;
-			eprefix(NULL);
-			prefix = NULL;
-			retval = svc_exec("status", NULL);
-		} else {
-			if (strcmp(optarg, "conditionalrestart") == 0 ||
-			    strcmp(optarg, "condrestart") == 0)
-			{
-				if (rc_service_state(service) &
-				    RC_SERVICE_STARTED)
-					svc_restart();
-			} else if (strcmp(optarg, "restart") == 0) {
-				svc_restart();
-			} else if (strcmp(optarg, "start") == 0) {
-				svc_start();
-			} else if (strcmp(optarg, "stop") == 0 || strcmp(optarg, "pause") == 0) {
-				if (strcmp(optarg, "pause") == 0) {
-					ewarn("WARNING: 'pause' is deprecated; please use '--nodeps stop'");
-					deps = false;
-				}
-				if (deps && in_background)
-					get_started_services();
-				if (svc_stop() == 1)
-					continue; /* Service has been stopped already */
-				if (deps) {
-					if (!in_background &&
-					    !rc_runlevel_stopping() &&
-					    rc_service_state(service) &
-					    RC_SERVICE_STOPPED)
-						unhotplug();
-
-					if (in_background &&
-					    rc_service_state(service) &
-					    RC_SERVICE_INACTIVE)
-					{
-						TAILQ_FOREACH(svc,
-						    restart_services,
-						    entries)
-						    if (rc_service_state(svc->value) &
-							RC_SERVICE_STOPPED)
-							    rc_service_schedule_start(service, svc->value);
-					}
-				}
-			} else if (strcmp(optarg, "zap") == 0) {
-				einfo("Manually resetting %s to stopped state",
-				    applet);
-				if (!rc_service_mark(applet,
-					RC_SERVICE_STOPPED))
-					eerrorx("rc_service_mark: %s",
-					    strerror(errno));
-				unhotplug();
-			} else
-				retval = svc_exec(optarg, NULL);
-
-			/* We should ensure this list is empty after
-			 * an action is done */
-			rc_stringlist_free(restart_services);
-			restart_services = NULL;
-		}
-
-		if (!doneone)
-			usage(EXIT_FAILURE);
-	}
-
-	return retval;
-}
-
-int
-runscript(int argc, char **argv)
-{
-	ewarnv("runscript is deprecated; please use openrc-run instead.");
-	return (openrc_run(argc, argv));
-}
diff --git a/src/rc/start-stop-daemon.c b/src/rc/start-stop-daemon.c
deleted file mode 100644
index 6229bbfd..00000000
--- a/src/rc/start-stop-daemon.c
+++ /dev/null
@@ -1,1361 +0,0 @@
-/*
-  start-stop-daemon
-  Starts, stops, tests and signals daemons
-
-  This is essentially a ground up re-write of Debians
-  start-stop-daemon for cleaner code and to integrate into our RC
-  system so we can monitor daemons a little.
-*/
-
-/*
- * Copyright (c) 2007-2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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.
- */
-
-/* nano seconds */
-#define POLL_INTERVAL   20000000
-#define WAIT_PIDFILE   500000000
-#define ONE_SECOND    1000000000
-#define ONE_MS           1000000
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <termios.h>
-#include <sys/time.h>
-#include <sys/wait.h>
-
-#ifdef __linux__
-#include <sys/syscall.h> /* For io priority */
-#endif
-
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <limits.h>
-#include <grp.h>
-#include <pwd.h>
-#include <signal.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-
-#ifdef HAVE_PAM
-#include <security/pam_appl.h>
-
-/* We are not supporting authentication conversations */
-static struct pam_conv conv = { NULL, NULL};
-#endif
-
-#include "builtins.h"
-#include "einfo.h"
-#include "queue.h"
-#include "rc.h"
-#include "rc-misc.h"
-
-typedef struct scheduleitem
-{
-	enum
-		{
-			SC_TIMEOUT,
-			SC_SIGNAL,
-			SC_GOTO,
-			SC_FOREVER
-		} type;
-	int value;
-	struct scheduleitem *gotoitem;
-	TAILQ_ENTRY(scheduleitem) entries;
-} SCHEDULEITEM;
-TAILQ_HEAD(, scheduleitem) schedule;
-static char **nav;
-
-extern const char *applet;
-static char *changeuser, *ch_root, *ch_dir;
-
-extern char **environ;
-
-#if !defined(SYS_ioprio_set) && defined(__NR_ioprio_set)
-# define SYS_ioprio_set __NR_ioprio_set
-#endif
-#if !defined(__DragonFly__)
-static inline int ioprio_set(int which, int who, int ioprio)
-{
-#ifdef SYS_ioprio_set
-	return syscall(SYS_ioprio_set, which, who, ioprio);
-#else
-	return 0;
-#endif
-}
-#endif
-
-static void
-free_schedulelist(void)
-{
-	SCHEDULEITEM *s1 = TAILQ_FIRST(&schedule);
-	SCHEDULEITEM *s2;
-
-	while (s1) {
-		s2 = TAILQ_NEXT(s1, entries);
-		free(s1);
-		s1 = s2;
-	}
-	TAILQ_INIT(&schedule);
-}
-
-#ifdef DEBUG_MEMORY
-static void
-cleanup(void)
-{
-	free(changeuser);
-	free(nav);
-	free_schedulelist();
-}
-#endif
-
-static int
-parse_signal(const char *sig)
-{
-	typedef struct signalpair
-	{
-		const char *name;
-		int signal;
-	} SIGNALPAIR;
-
-	static const SIGNALPAIR signallist[] = {
-		{ "ABRT",	SIGABRT	},
-		{ "ALRM",	SIGALRM	},
-		{ "FPE",	SIGFPE	},
-		{ "HUP",	SIGHUP	},
-		{ "ILL",	SIGILL	},
-		{ "INT",	SIGINT	},
-		{ "KILL",	SIGKILL	},
-		{ "PIPE",	SIGPIPE	},
-		{ "QUIT",	SIGQUIT	},
-		{ "SEGV",	SIGSEGV	},
-		{ "TERM",	SIGTERM	},
-		{ "USR1",	SIGUSR1	},
-		{ "USR2",	SIGUSR2	},
-		{ "CHLD",	SIGCHLD	},
-		{ "CONT",	SIGCONT	},
-		{ "STOP",	SIGSTOP	},
-		{ "TSTP",	SIGTSTP	},
-		{ "TTIN",	SIGTTIN	},
-		{ "TTOU",	SIGTTOU	},
-		{ "NULL",	0 },
-	};
-
-	unsigned int i = 0;
-	const char *s;
-
-	if (!sig || *sig == '\0')
-		return -1;
-
-	if (sscanf(sig, "%u", &i) == 1) {
-		if (i < NSIG)
-			return i;
-		eerrorx("%s: `%s' is not a valid signal", applet, sig);
-	}
-
-	if (strncmp(sig, "SIG", 3) == 0)
-		s = sig + 3;
-	else
-		s = NULL;
-
-	for (i = 0; i < ARRAY_SIZE(signallist); ++i)
-		if (strcmp(sig, signallist[i].name) == 0 ||
-		    (s && strcmp(s, signallist[i].name) == 0))
-			return signallist[i].signal;
-
-	eerrorx("%s: `%s' is not a valid signal", applet, sig);
-	/* NOTREACHED */
-}
-
-static SCHEDULEITEM *
-parse_schedule_item(const char *string)
-{
-	const char *after_hyph;
-	int sig;
-	SCHEDULEITEM *item = xmalloc(sizeof(*item));
-
-	item->value = 0;
-	item->gotoitem = NULL;
-	if (strcmp(string,"forever") == 0)
-		item->type = SC_FOREVER;
-	else if (isdigit((unsigned char)string[0])) {
-		item->type = SC_TIMEOUT;
-		errno = 0;
-		if (sscanf(string, "%d", &item->value) != 1)
-			eerrorx("%s: invalid timeout value in schedule `%s'",
-			    applet, string);
-	} else if ((after_hyph = string + (string[0] == '-')) &&
-	    ((sig = parse_signal(after_hyph)) != -1))
-	{
-		item->type = SC_SIGNAL;
-		item->value = (int)sig;
-	} else
-		eerrorx("%s: invalid schedule item `%s'", applet, string);
-
-	return item;
-}
-
-static void
-parse_schedule(const char *string, int timeout)
-{
-	char buffer[20];
-	const char *slash;
-	int count = 0;
-	SCHEDULEITEM *repeatat = NULL;
-	size_t len;
-	SCHEDULEITEM *item;
-
-	if (string)
-		for (slash = string; *slash; slash++)
-			if (*slash == '/')
-				count++;
-
-	free_schedulelist();
-
-	if (count == 0) {
-		item = xmalloc(sizeof(*item));
-		item->type = SC_SIGNAL;
-		item->value = timeout;
-		item->gotoitem = NULL;
-		TAILQ_INSERT_TAIL(&schedule, item, entries);
-
-		item = xmalloc(sizeof(*item));
-		item->type = SC_TIMEOUT;
-		item->gotoitem = NULL;
-		TAILQ_INSERT_TAIL(&schedule, item, entries);
-		if (string) {
-			if (sscanf(string, "%d", &item->value) != 1)
-				eerrorx("%s: invalid timeout in schedule",
-				    applet);
-		} else
-			item->value = 5;
-
-		return;
-	}
-
-	while (string != NULL) {
-		if ((slash = strchr(string, '/')))
-			len = slash - string;
-		else
-			len = strlen(string);
-
-		if (len >= (ptrdiff_t)sizeof(buffer))
-			eerrorx("%s: invalid schedule item, far too long",
-			    applet);
-
-		memcpy(buffer, string, len);
-		buffer[len] = 0;
-		string = slash ? slash + 1 : NULL;
-
-		item = parse_schedule_item(buffer);
-		TAILQ_INSERT_TAIL(&schedule, item, entries);
-		if (item->type == SC_FOREVER) {
-			if (repeatat)
-				eerrorx("%s: invalid schedule, `forever' "
-				    "appears more than once", applet);
-
-			repeatat = item;
-			continue;
-		}
-	}
-
-	if (repeatat) {
-		item = xmalloc(sizeof(*item));
-		item->type = SC_GOTO;
-		item->value = 0;
-		item->gotoitem = repeatat;
-		TAILQ_INSERT_TAIL(&schedule, item, entries);
-	}
-
-	return;
-}
-
-static pid_t
-get_pid(const char *pidfile)
-{
-	FILE *fp;
-	pid_t pid;
-
-	if (! pidfile)
-		return -1;
-
-	if ((fp = fopen(pidfile, "r")) == NULL) {
-		ewarnv("%s: fopen `%s': %s", applet, pidfile, strerror(errno));
-		return -1;
-	}
-
-	if (fscanf(fp, "%d", &pid) != 1) {
-		ewarnv("%s: no pid found in `%s'", applet, pidfile);
-		fclose(fp);
-		return -1;
-	}
-
-	fclose(fp);
-
-	return pid;
-}
-
-/* return number of processed killed, -1 on error */
-static int
-do_stop(const char *exec, const char *const *argv,
-    pid_t pid, uid_t uid,int sig, bool test)
-{
-	RC_PIDLIST *pids;
-	RC_PID *pi;
-	RC_PID *np;
-	bool killed;
-	int nkilled = 0;
-
-	if (pid)
-		pids = rc_find_pids(NULL, NULL, 0, pid);
-	else
-		pids = rc_find_pids(exec, argv, uid, pid);
-
-	if (!pids)
-		return 0;
-
-	LIST_FOREACH_SAFE(pi, pids, entries, np) {
-		if (test) {
-			einfo("Would send signal %d to PID %d", sig, pi->pid);
-			nkilled++;
-		} else {
-			ebeginv("Sending signal %d to PID %d", sig, pi->pid);
-			errno = 0;
-			killed = (kill(pi->pid, sig) == 0 ||
-			    errno == ESRCH ? true : false);
-			eendv(killed ? 0 : 1,
-				"%s: failed to send signal %d to PID %d: %s",
-				applet, sig, pi->pid, strerror(errno));
-			if (!killed) {
-				nkilled = -1;
-			} else {
-				if (nkilled != -1)
-					nkilled++;
-			}
-		}
-		free(pi);
-	}
-
-	free(pids);
-	return nkilled;
-}
-
-static int
-run_stop_schedule(const char *exec, const char *const *argv,
-    const char *pidfile, uid_t uid,
-    bool test, bool progress)
-{
-	SCHEDULEITEM *item = TAILQ_FIRST(&schedule);
-	int nkilled = 0;
-	int tkilled = 0;
-	int nrunning = 0;
-	long nloops, nsecs;
-	struct timespec ts;
-	pid_t pid = 0;
-	const char *const *p;
-	bool progressed = false;
-
-	if (exec)
-		einfov("Will stop %s", exec);
-	if (pidfile)
-		einfov("Will stop PID in pidfile `%s'", pidfile);
-	if (uid)
-		einfov("Will stop processes owned by UID %d", uid);
-	if (argv && *argv) {
-		einfovn("Will stop processes of `");
-		if (rc_yesno(getenv("EINFO_VERBOSE"))) {
-			for (p = argv; p && *p; p++) {
-				if (p != argv)
-					printf(" ");
-				printf("%s", *p);
-			}
-			printf("'\n");
-		}
-	}
-
-	if (pidfile) {
-		pid = get_pid(pidfile);
-		if (pid == -1)
-			return 0;
-	}
-
-	while (item) {
-		switch (item->type) {
-		case SC_GOTO:
-			item = item->gotoitem;
-			continue;
-
-		case SC_SIGNAL:
-			nrunning = 0;
-			nkilled = do_stop(exec, argv, pid, uid, item->value, test);
-			if (nkilled == 0) {
-				if (tkilled == 0) {
-					if (progressed)
-						printf("\n");
-						eerror("%s: no matching processes found", applet);
-				}
-				return tkilled;
-			}
-			else if (nkilled == -1)
-				return 0;
-
-			tkilled += nkilled;
-			break;
-		case SC_TIMEOUT:
-			if (item->value < 1) {
-				item = NULL;
-				break;
-			}
-
-			ts.tv_sec = 0;
-			ts.tv_nsec = POLL_INTERVAL;
-
-			for (nsecs = 0; nsecs < item->value; nsecs++) {
-				for (nloops = 0;
-				     nloops < ONE_SECOND / POLL_INTERVAL;
-				     nloops++)
-				{
-					if ((nrunning = do_stop(exec, argv,
-						    pid, uid, 0, test)) == 0)
-						return 0;
-
-
-					if (nanosleep(&ts, NULL) == -1) {
-						if (progressed) {
-							printf("\n");
-							progressed = false;
-						}
-						if (errno == EINTR)
-							eerror("%s: caught an"
-							    " interrupt", applet);
-						else {
-							eerror("%s: nanosleep: %s",
-							    applet, strerror(errno));
-							return 0;
-						}
-					}
-				}
-				if (progress) {
-					printf(".");
-					fflush(stdout);
-					progressed = true;
-				}
-			}
-			break;
-		default:
-			if (progressed) {
-				printf("\n");
-				progressed = false;
-			}
-			eerror("%s: invalid schedule item `%d'",
-			    applet, item->type);
-			return 0;
-		}
-
-		if (item)
-			item = TAILQ_NEXT(item, entries);
-	}
-
-	if (test || (tkilled > 0 && nrunning == 0))
-		return nkilled;
-
-	if (progressed)
-		printf("\n");
-	if (nrunning == 1)
-		eerror("%s: %d process refused to stop", applet, nrunning);
-	else
-		eerror("%s: %d process(es) refused to stop", applet, nrunning);
-
-	return -nrunning;
-}
-
-static void
-handle_signal(int sig)
-{
-	int status;
-	int serrno = errno;
-	char signame[10] = { '\0' };
-
-	switch (sig) {
-	case SIGINT:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGINT");
-		/* FALLTHROUGH */
-	case SIGTERM:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGTERM");
-		/* FALLTHROUGH */
-	case SIGQUIT:
-		if (!signame[0])
-			snprintf(signame, sizeof(signame), "SIGQUIT");
-		eerrorx("%s: caught %s, aborting", applet, signame);
-		/* NOTREACHED */
-
-	case SIGCHLD:
-		for (;;) {
-			if (waitpid(-1, &status, WNOHANG) < 0) {
-				if (errno != ECHILD)
-					eerror("%s: waitpid: %s",
-					    applet, strerror(errno));
-				break;
-			}
-		}
-		break;
-
-	default:
-		eerror("%s: caught unknown signal %d", applet, sig);
-	}
-
-	/* Restore errno */
-	errno = serrno;
-}
-
-static char *
-expand_home(const char *home, const char *path)
-{
-	char *opath, *ppath, *p, *nh;
-	size_t len;
-	struct passwd *pw;
-
-	if (!path || *path != '~')
-		return xstrdup(path);
-
-	opath = ppath = xstrdup(path);
-	if (ppath[1] != '/' && ppath[1] != '\0') {
-		p = strchr(ppath + 1, '/');
-		if (p)
-			*p = '\0';
-		pw = getpwnam(ppath + 1);
-		if (pw) {
-			home = pw->pw_dir;
-			ppath = p;
-			if (ppath)
-				*ppath = '/';
-		} else
-			home = NULL;
-	} else
-		ppath++;
-
-	if (!home) {
-	free(opath);
-		return xstrdup(path);
-	}
-	if (!ppath) {
-		free(opath);
-		return xstrdup(home);
-	}
-
-	len = strlen(ppath) + strlen(home) + 1;
-	nh = xmalloc(len);
-	snprintf(nh, len, "%s%s", home, ppath);
-	free(opath);
-	return nh;
-}
-
-#include "_usage.h"
-#define getoptstring "I:KN:PR:Sa:bc:d:e:g:ik:mn:op:s:tu:r:w:x:1:2:" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "ionice",       1, NULL, 'I'},
-	{ "stop",         0, NULL, 'K'},
-	{ "nicelevel",    1, NULL, 'N'},
-	{ "retry",        1, NULL, 'R'},
-	{ "start",        0, NULL, 'S'},
-	{ "startas",      1, NULL, 'a'},
-	{ "background",   0, NULL, 'b'},
-	{ "chuid",        1, NULL, 'c'},
-	{ "chdir",        1, NULL, 'd'},
-	{ "env",          1, NULL, 'e'},
-	{ "umask",        1, NULL, 'k'},
-	{ "group",        1, NULL, 'g'},
-	{ "interpreted",  0, NULL, 'i'},
-	{ "make-pidfile", 0, NULL, 'm'},
-	{ "name",         1, NULL, 'n'},
-	{ "oknodo",       0, NULL, 'o'},
-	{ "pidfile",      1, NULL, 'p'},
-	{ "signal",       1, NULL, 's'},
-	{ "test",         0, NULL, 't'},
-	{ "user",         1, NULL, 'u'},
-	{ "chroot",       1, NULL, 'r'},
-	{ "wait",         1, NULL, 'w'},
-	{ "exec",         1, NULL, 'x'},
-	{ "stdout",       1, NULL, '1'},
-	{ "stderr",       1, NULL, '2'},
-	{ "progress",     0, NULL, 'P'},
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"Set an ionice class:data when starting",
-	"Stop daemon",
-	"Set a nicelevel when starting",
-	"Retry schedule to use when stopping",
-	"Start daemon",
-	"deprecated, use --exec or --name",
-	"Force daemon to background",
-	"deprecated, use --user",
-	"Change the PWD",
-	"Set an environment string",
-	"Set the umask for the daemon",
-	"Change the process group",
-	"Match process name by interpreter",
-	"Create a pidfile",
-	"Match process name",
-	"deprecated",
-	"Match pid found in this file",
-	"Send a different signal",
-	"Test actions, don't do them",
-	"Change the process user",
-	"Chroot to this directory",
-	"Milliseconds to wait for daemon start",
-	"Binary to start/stop",
-	"Redirect stdout to file",
-	"Redirect stderr to file",
-	"Print dots each second while waiting",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-start_stop_daemon(int argc, char **argv)
-{
-	int devnull_fd = -1;
-#ifdef TIOCNOTTY
-	int tty_fd = -1;
-#endif
-
-#ifdef HAVE_PAM
-	pam_handle_t *pamh = NULL;
-	int pamr;
-	const char *const *pamenv = NULL;
-#endif
-
-	int opt;
-	bool start = false;
-	bool stop = false;
-	bool oknodo = false;
-	bool test = false;
-	char *exec = NULL;
-	char *startas = NULL;
-	char *name = NULL;
-	char *pidfile = NULL;
-	char *retry = NULL;
-	int sig = -1;
-	int nicelevel = 0, ionicec = -1, ioniced = 0;
-	bool background = false;
-	bool makepidfile = false;
-	bool interpreted = false;
-	bool progress = false;
-	uid_t uid = 0;
-	gid_t gid = 0;
-	char *home = NULL;
-	int tid = 0;
-	char *redirect_stderr = NULL;
-	char *redirect_stdout = NULL;
-	int stdout_fd;
-	int stderr_fd;
-	pid_t pid, spid;
-	int i;
-	char *svcname = getenv("RC_SVCNAME");
-	RC_STRINGLIST *env_list;
-	RC_STRING *env;
-	char *tmp, *newpath, *np;
-	char *p;
-	char *token;
-	char exec_file[PATH_MAX];
-	struct passwd *pw;
-	struct group *gr;
-	char line[130];
-	FILE *fp;
-	size_t len;
-	mode_t numask = 022;
-	char **margv;
-	unsigned int start_wait = 0;
-
-	TAILQ_INIT(&schedule);
-#ifdef DEBUG_MEMORY
-	atexit(cleanup);
-#endif
-
-	signal_setup(SIGINT, handle_signal);
-	signal_setup(SIGQUIT, handle_signal);
-	signal_setup(SIGTERM, handle_signal);
-
-	if ((tmp = getenv("SSD_NICELEVEL")))
-		if (sscanf(tmp, "%d", &nicelevel) != 1)
-			eerror("%s: invalid nice level `%s' (SSD_NICELEVEL)",
-			    applet, tmp);
-
-	/* Get our user name and initial dir */
-	p = getenv("USER");
-	home = getenv("HOME");
-	if (home == NULL || p == NULL) {
-		pw = getpwuid(getuid());
-		if (pw != NULL) {
-			if (p == NULL)
-				setenv("USER", pw->pw_name, 1);
-			if (home == NULL) {
-				setenv("HOME", pw->pw_dir, 1);
-				home = pw->pw_dir;
-			}
-		}
-	}
-
-	while ((opt = getopt_long(argc, argv, getoptstring, longopts,
-		    (int *) 0)) != -1)
-		switch (opt) {
-		case 'I': /* --ionice */
-			if (sscanf(optarg, "%d:%d", &ionicec, &ioniced) == 0)
-				eerrorx("%s: invalid ionice `%s'",
-				    applet, optarg);
-			if (ionicec == 0)
-				ioniced = 0;
-			else if (ionicec == 3)
-				ioniced = 7;
-			ionicec <<= 13; /* class shift */
-			break;
-
-		case 'K':  /* --stop */
-			stop = true;
-			break;
-
-		case 'N':  /* --nice */
-			if (sscanf(optarg, "%d", &nicelevel) != 1)
-				eerrorx("%s: invalid nice level `%s'",
-				    applet, optarg);
-			break;
-
-		case 'P':  /* --progress */
-			progress = true;
-			break;
-
-		case 'R':  /* --retry <schedule>|<timeout> */
-			retry = optarg;
-			break;
-
-		case 'S':  /* --start */
-			start = true;
-			break;
-
-		case 'b':  /* --background */
-			background = true;
-			break;
-
-		case 'c':  /* --chuid <username>|<uid> */
-			/* DEPRECATED */
-			ewarn("WARNING: -c/--chuid is deprecated and will be removed in the future, please use -u/--user instead");
-		case 'u':  /* --user <username>|<uid> */
-		{
-			p = optarg;
-			tmp = strsep(&p, ":");
-			changeuser = xstrdup(tmp);
-			if (sscanf(tmp, "%d", &tid) != 1)
-				pw = getpwnam(tmp);
-			else
-				pw = getpwuid((uid_t)tid);
-
-			if (pw == NULL)
-				eerrorx("%s: user `%s' not found",
-				    applet, tmp);
-			uid = pw->pw_uid;
-			home = pw->pw_dir;
-			unsetenv("HOME");
-			if (pw->pw_dir)
-				setenv("HOME", pw->pw_dir, 1);
-			unsetenv("USER");
-			if (pw->pw_name)
-				setenv("USER", pw->pw_name, 1);
-			if (gid == 0)
-				gid = pw->pw_gid;
-
-			if (p) {
-				tmp = strsep (&p, ":");
-				if (sscanf(tmp, "%d", &tid) != 1)
-					gr = getgrnam(tmp);
-				else
-					gr = getgrgid((gid_t) tid);
-
-				if (gr == NULL)
-					eerrorx("%s: group `%s'"
-					    " not found",
-					    applet, tmp);
-				gid = gr->gr_gid;
-			}
-		}
-		break;
-
-		case 'd':  /* --chdir /new/dir */
-			ch_dir = optarg;
-			break;
-
-		case 'e': /* --env */
-			putenv(optarg);
-			break;
-
-		case 'g':  /* --group <group>|<gid> */
-			if (sscanf(optarg, "%d", &tid) != 1)
-				gr = getgrnam(optarg);
-			else
-				gr = getgrgid((gid_t)tid);
-			if (gr == NULL)
-				eerrorx("%s: group `%s' not found",
-				    applet, optarg);
-			gid = gr->gr_gid;
-			break;
-
-		case 'i': /* --interpreted */
-			interpreted = true;
-			break;
-
-		case 'k':
-			if (parse_mode(&numask, optarg))
-				eerrorx("%s: invalid mode `%s'",
-				    applet, optarg);
-			break;
-
-		case 'm':  /* --make-pidfile */
-			makepidfile = true;
-			break;
-
-		case 'n':  /* --name <process-name> */
-			name = optarg;
-			break;
-
-		case 'o':  /* --oknodo */
-			/* DEPRECATED */
-			ewarn("WARNING: -o/--oknodo is deprecated and will be removed in the future");
-			oknodo = true;
-			break;
-
-		case 'p':  /* --pidfile <pid-file> */
-			pidfile = optarg;
-			break;
-
-		case 's':  /* --signal <signal> */
-			sig = parse_signal(optarg);
-			break;
-
-		case 't':  /* --test */
-			test = true;
-			break;
-
-		case 'r':  /* --chroot /new/root */
-			ch_root = optarg;
-			break;
-
-		case 'a': /* --startas <name> */
-			/* DEPRECATED */
-			ewarn("WARNING: -a/--startas is deprecated and will be removed in the future, please use -x/--exec or -n/--name instead");
-			startas = optarg;
-			break;
-		case 'w':
-			if (sscanf(optarg, "%d", &start_wait) != 1)
-				eerrorx("%s: `%s' not a number",
-				    applet, optarg);
-			break;
-		case 'x':  /* --exec <executable> */
-			exec = optarg;
-			break;
-
-		case '1':   /* --stdout /path/to/stdout.lgfile */
-			redirect_stdout = optarg;
-			break;
-
-		case '2':  /* --stderr /path/to/stderr.logfile */
-			redirect_stderr = optarg;
-			break;
-
-		case_RC_COMMON_GETOPT
-		}
-
-	endpwent();
-	argc -= optind;
-	argv += optind;
-
-	/* Allow start-stop-daemon --signal HUP --exec /usr/sbin/dnsmasq
-	 * instead of forcing --stop --oknodo as well */
-	if (!start &&
-	    !stop &&
-	    sig != SIGINT &&
-	    sig != SIGTERM &&
-	    sig != SIGQUIT &&
-	    sig != SIGKILL)
-		oknodo = true;
-
-	if (!exec)
-		exec = startas;
-	else if (!name)
-		name = startas;
-
-	if (!exec) {
-		exec = *argv;
-		if (!exec)
-			exec = name;
-		if (name && start)
-			*argv = name;
-	} else if (name)
-		*--argv = name;
-	else if (exec)
-		*--argv = exec;
-
-	if (stop || sig != -1) {
-		if (sig == -1)
-			sig = SIGTERM;
-		if (!*argv && !pidfile && !name && !uid)
-			eerrorx("%s: --stop needs --exec, --pidfile,"
-			    " --name or --user", applet);
-		if (background)
-			eerrorx("%s: --background is only relevant with"
-			    " --start", applet);
-		if (makepidfile)
-			eerrorx("%s: --make-pidfile is only relevant with"
-			    " --start", applet);
-		if (redirect_stdout || redirect_stderr)
-			eerrorx("%s: --stdout and --stderr are only relevant"
-			    " with --start", applet);
-	} else {
-		if (!exec)
-			eerrorx("%s: nothing to start", applet);
-		if (makepidfile && !pidfile)
-			eerrorx("%s: --make-pidfile is only relevant with"
-			    " --pidfile", applet);
-		if ((redirect_stdout || redirect_stderr) && !background)
-			eerrorx("%s: --stdout and --stderr are only relevant"
-			    " with --background", applet);
-	}
-
-	/* Expand ~ */
-	if (ch_dir && *ch_dir == '~')
-		ch_dir = expand_home(home, ch_dir);
-	if (ch_root && *ch_root == '~')
-		ch_root = expand_home(home, ch_root);
-	if (exec) {
-		if (*exec == '~')
-			exec = expand_home(home, exec);
-
-		/* Validate that the binary exists if we are starting */
-		if (*exec == '/' || *exec == '.') {
-			/* Full or relative path */
-			if (ch_root)
-				snprintf(exec_file, sizeof(exec_file),
-				    "%s/%s", ch_root, exec);
-			else
-				snprintf(exec_file, sizeof(exec_file),
-				    "%s", exec);
-		} else {
-			/* Something in $PATH */
-			p = tmp = xstrdup(getenv("PATH"));
-			*exec_file = '\0';
-			while ((token = strsep(&p, ":"))) {
-				if (ch_root)
-					snprintf(exec_file, sizeof(exec_file),
-					    "%s/%s/%s",
-					    ch_root, token, exec);
-				else
-					snprintf(exec_file, sizeof(exec_file),
-					    "%s/%s", token, exec);
-				if (exists(exec_file))
-					break;
-				*exec_file = '\0';
-			}
-			free(tmp);
-		}
-	}
-	if (start && !exists(exec_file)) {
-		eerror("%s: %s does not exist", applet,
-		    *exec_file ? exec_file : exec);
-		exit(EXIT_FAILURE);
-	}
-
-	/* If we don't have a pidfile we should check if it's interpreted
-	 * or not. If it we, we need to pass the interpreter through
-	 * to our daemon calls to find it correctly. */
-	if (interpreted && !pidfile) {
-		fp = fopen(exec_file, "r");
-		if (fp) {
-			p = fgets(line, sizeof(line), fp);
-			fclose(fp);
-			if (p != NULL && line[0] == '#' && line[1] == '!') {
-				p = line + 2;
-				/* Strip leading spaces */
-				while (*p == ' ' || *p == '\t')
-					p++;
-				/* Remove the trailing newline */
-				len = strlen(p) - 1;
-				if (p[len] == '\n')
-					p[len] = '\0';
-				token = strsep(&p, " ");
-				strncpy(exec_file, token, sizeof(exec_file));
-				opt = 0;
-				for (nav = argv; *nav; nav++)
-					opt++;
-				nav = xmalloc(sizeof(char *) * (opt + 3));
-				nav[0] = exec_file;
-				len = 1;
-				if (p)
-					nav[len++] = p;
-				for (i = 0; i < opt; i++)
-					nav[i + len] = argv[i];
-				nav[i + len] = '\0';
-			}
-		}
-	}
-	margv = nav ? nav : argv;
-
-	if (stop || sig != -1) {
-		if (sig == -1)
-			sig = SIGTERM;
-		if (!stop)
-			oknodo = true;
-		if (retry)
-			parse_schedule(retry, sig);
-		else if (test || oknodo)
-			parse_schedule("0", sig);
-		else
-			parse_schedule(NULL, sig);
-		i = run_stop_schedule(exec, (const char *const *)margv,
-		    pidfile, uid, test, progress);
-
-		if (i < 0)
-			/* We failed to stop something */
-			exit(EXIT_FAILURE);
-		if (test || oknodo)
-			return i > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
-
-		/* Even if we have not actually killed anything, we should
-		 * remove information about it as it may have unexpectedly
-		 * crashed out. We should also return success as the end
-		 * result would be the same. */
-		if (pidfile && exists(pidfile))
-			unlink(pidfile);
-		if (svcname)
-			rc_service_daemon_set(svcname, exec,
-			    (const char *const *)argv,
-			    pidfile, false);
-		exit(EXIT_SUCCESS);
-	}
-
-	if (pidfile)
-		pid = get_pid(pidfile);
-	else
-		pid = 0;
-
-	if (do_stop(exec, (const char * const *)margv, pid, uid,
-		0, test) > 0)
-		eerrorx("%s: %s is already running", applet, exec);
-
-	if (test) {
-		if (rc_yesno(getenv("EINFO_QUIET")))
-			exit (EXIT_SUCCESS);
-
-		einfon("Would start");
-		while (argc-- >= 0)
-			printf(" %s", *argv++);
-		printf("\n");
-		eindent();
-		if (uid != 0)
-			einfo("as user id %d", uid);
-		if (gid != 0)
-			einfo("as group id %d", gid);
-		if (ch_root)
-			einfo("in root `%s'", ch_root);
-		if (ch_dir)
-			einfo("in dir `%s'", ch_dir);
-		if (nicelevel != 0)
-			einfo("with a priority of %d", nicelevel);
-		if (name)
-			einfo ("with a process name of %s", name);
-		eoutdent();
-		exit(EXIT_SUCCESS);
-	}
-
-	ebeginv("Detaching to start `%s'", exec);
-	eindentv();
-
-	/* Remove existing pidfile */
-	if (pidfile)
-		unlink(pidfile);
-
-	if (background)
-		signal_setup(SIGCHLD, handle_signal);
-
-	if ((pid = fork()) == -1)
-		eerrorx("%s: fork: %s", applet, strerror(errno));
-
-	/* Child process - lets go! */
-	if (pid == 0) {
-		pid_t mypid = getpid();
-		umask(numask);
-
-#ifdef TIOCNOTTY
-		tty_fd = open("/dev/tty", O_RDWR);
-#endif
-
-		devnull_fd = open("/dev/null", O_RDWR);
-
-		if (nicelevel) {
-			if (setpriority(PRIO_PROCESS, mypid, nicelevel) == -1)
-				eerrorx("%s: setpritory %d: %s",
-				    applet, nicelevel,
-				    strerror(errno));
-		}
-
-		if (ionicec != -1 &&
-		    ioprio_set(1, mypid, ionicec | ioniced) == -1)
-			eerrorx("%s: ioprio_set %d %d: %s", applet,
-			    ionicec, ioniced, strerror(errno));
-
-		if (ch_root && chroot(ch_root) < 0)
-			eerrorx("%s: chroot `%s': %s",
-			    applet, ch_root, strerror(errno));
-
-		if (ch_dir && chdir(ch_dir) < 0)
-			eerrorx("%s: chdir `%s': %s",
-			    applet, ch_dir, strerror(errno));
-
-		if (makepidfile && pidfile) {
-			fp = fopen(pidfile, "w");
-			if (! fp)
-				eerrorx("%s: fopen `%s': %s", applet, pidfile,
-				    strerror(errno));
-			fprintf(fp, "%d\n", mypid);
-			fclose(fp);
-		}
-
-#ifdef HAVE_PAM
-		if (changeuser != NULL) {
-			pamr = pam_start("start-stop-daemon",
-			    changeuser, &conv, &pamh);
-
-			if (pamr == PAM_SUCCESS)
-				pamr = pam_acct_mgmt(pamh, PAM_SILENT);
-			if (pamr == PAM_SUCCESS)
-				pamr = pam_open_session(pamh, PAM_SILENT);
-			if (pamr != PAM_SUCCESS)
-				eerrorx("%s: pam error: %s",
-					applet, pam_strerror(pamh, pamr));
-		}
-#endif
-
-		if (gid && setgid(gid))
-			eerrorx("%s: unable to set groupid to %d",
-			    applet, gid);
-		if (changeuser && initgroups(changeuser, gid))
-			eerrorx("%s: initgroups (%s, %d)",
-			    applet, changeuser, gid);
-		if (uid && setuid(uid))
-			eerrorx ("%s: unable to set userid to %d",
-			    applet, uid);
-
-		/* Close any fd's to the passwd database */
-		endpwent();
-
-#ifdef TIOCNOTTY
-		ioctl(tty_fd, TIOCNOTTY, 0);
-		close(tty_fd);
-#endif
-
-		/* Clean the environment of any RC_ variables */
-		env_list = rc_stringlist_new();
-		i = 0;
-		while (environ[i])
-			rc_stringlist_add(env_list, environ[i++]);
-
-#ifdef HAVE_PAM
-		if (changeuser != NULL) {
-			pamenv = (const char *const *)pam_getenvlist(pamh);
-			if (pamenv) {
-				while (*pamenv) {
-					/* Don't add strings unless they set a var */
-					if (strchr(*pamenv, '='))
-						putenv(xstrdup(*pamenv));
-					else
-						unsetenv(*pamenv);
-					pamenv++;
-				}
-			}
-		}
-#endif
-
-		TAILQ_FOREACH(env, env_list, entries) {
-			if ((strncmp(env->value, "RC_", 3) == 0 &&
-				strncmp(env->value, "RC_SERVICE=", 10) != 0 &&
-				strncmp(env->value, "RC_SVCNAME=", 10) != 0) ||
-			    strncmp(env->value, "SSD_NICELEVEL=", 14) == 0)
-			{
-				p = strchr(env->value, '=');
-				*p = '\0';
-				unsetenv(env->value);
-				continue;
-			}
-		}
-		rc_stringlist_free(env_list);
-
-		/* For the path, remove the rcscript bin dir from it */
-		if ((token = getenv("PATH"))) {
-			len = strlen(token);
-			newpath = np = xmalloc(len + 1);
-			while (token && *token) {
-				p = strchr(token, ':');
-				if (p) {
-					*p++ = '\0';
-					while (*p == ':')
-						p++;
-				}
-				if (strcmp(token, RC_LIBEXECDIR "/bin") != 0 &&
-				    strcmp(token, RC_LIBEXECDIR "/sbin") != 0)
-				{
-					len = strlen(token);
-					if (np != newpath)
-						*np++ = ':';
-					memcpy(np, token, len);
-					np += len;
-				}
-				token = p;
-			}
-			*np = '\0';
-			unsetenv("PATH");
-			setenv("PATH", newpath, 1);
-		}
-
-		stdout_fd = devnull_fd;
-		stderr_fd = devnull_fd;
-		if (redirect_stdout) {
-			if ((stdout_fd = open(redirect_stdout,
-				    O_WRONLY | O_CREAT | O_APPEND,
-				    S_IRUSR | S_IWUSR)) == -1)
-				eerrorx("%s: unable to open the logfile"
-				    " for stdout `%s': %s",
-				    applet, redirect_stdout, strerror(errno));
-		}
-		if (redirect_stderr) {
-			if ((stderr_fd = open(redirect_stderr,
-				    O_WRONLY | O_CREAT | O_APPEND,
-				    S_IRUSR | S_IWUSR)) == -1)
-				eerrorx("%s: unable to open the logfile"
-				    " for stderr `%s': %s",
-				    applet, redirect_stderr, strerror(errno));
-		}
-
-		/* We don't redirect stdin as some daemons may need it */
-		if (background || redirect_stdout || rc_yesno(getenv("EINFO_QUIET")))
-			dup2(stdout_fd, STDOUT_FILENO);
-		if (background || redirect_stderr || rc_yesno(getenv("EINFO_QUIET")))
-			dup2(stderr_fd, STDERR_FILENO);
-
-		for (i = getdtablesize() - 1; i >= 3; --i)
-			close(i);
-
-		setsid();
-		execvp(exec, argv);
-#ifdef HAVE_PAM
-		if (changeuser != NULL && pamr == PAM_SUCCESS)
-			pam_close_session(pamh, PAM_SILENT);
-#endif
-		eerrorx("%s: failed to exec `%s': %s",
-		    applet, exec,strerror(errno));
-	}
-
-	/* Parent process */
-	if (!background) {
-		/* As we're not backgrounding the process, wait for our pid
-		 * to return */
-		i = 0;
-		spid = pid;
-
-		do {
-			pid = waitpid(spid, &i, 0);
-			if (pid < 1) {
-				eerror("waitpid %d: %s",
-				    spid, strerror(errno));
-				return -1;
-			}
-		} while (!WIFEXITED(i) && !WIFSIGNALED(i));
-		if (!WIFEXITED(i) || WEXITSTATUS(i) != 0) {
-			eerror("%s: failed to start `%s'", applet, exec);
-			exit(EXIT_FAILURE);
-		}
-		pid = spid;
-	}
-
-	/* Wait a little bit and check that process is still running
-	   We do this as some badly written daemons fork and then barf */
-	if (start_wait == 0 &&
-	    ((p = getenv("SSD_STARTWAIT")) ||
-		(p = rc_conf_value("rc_start_wait"))))
-	{
-		if (sscanf(p, "%u", &start_wait) != 1)
-			start_wait = 0;
-	}
-
-	if (start_wait > 0) {
-		struct timespec ts;
-		bool alive = false;
-
-		ts.tv_sec = start_wait / 1000;
-		ts.tv_nsec = (start_wait % 1000) * ONE_MS;
-		if (nanosleep(&ts, NULL) == -1) {
-			if (errno == EINTR)
-				eerror("%s: caught an interrupt", applet);
-			else {
-				eerror("%s: nanosleep: %s",
-				    applet, strerror(errno));
-				return 0;
-			}
-		}
-		if (background) {
-			if (kill(pid, 0) == 0)
-				alive = true;
-		} else {
-			if (pidfile) {
-				pid = get_pid(pidfile);
-				if (pid == -1) {
-					eerrorx("%s: did not "
-					    "create a valid"
-					    " pid in `%s'",
-					    applet, pidfile);
-				}
-			} else
-				pid = 0;
-			if (do_stop(exec, (const char *const *)margv,
-				pid, uid, 0, test) > 0)
-				alive = true;
-		}
-
-		if (!alive)
-			eerrorx("%s: %s died", applet, exec);
-	}
-
-	if (svcname)
-		rc_service_daemon_set(svcname, exec,
-		    (const char *const *)margv, pidfile, true);
-
-	exit(EXIT_SUCCESS);
-	/* NOTREACHED */
-}
diff --git a/src/rc/start-stop-daemon.pam b/src/rc/start-stop-daemon.pam
deleted file mode 100644
index a1bada22..00000000
--- a/src/rc/start-stop-daemon.pam
+++ /dev/null
@@ -1,6 +0,0 @@
-#%PAM-1.0
-
-auth            required        pam_permit.so
-account         required        pam_permit.so
-password        required        pam_deny.so
-session         optional        pam_limits.so
diff --git a/src/rc/swclock.c b/src/rc/swclock.c
deleted file mode 100644
index 0fb518b5..00000000
--- a/src/rc/swclock.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-  swclock.c
-  Sets the system time from the mtime of the given file.
-  This is useful for systems who do not have a working RTC and rely on ntp.
-  OpenRC relies on the correct system time for a lot of operations so this is needed
-  quite early.
-*/
-
-/*
- * Copyright (c) 2009 Roy Marples <roy@marples.name>
- *
- * 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 AUTHOR 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 AUTHOR 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/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <unistd.h>
-#include <utime.h>
-
-#include "builtins.h"
-#include "einfo.h"
-#include "rc-misc.h"
-
-#define RC_SHUTDOWNTIME    RC_SVCDIR "/shutdowntime"
-
-extern const char *applet;
-
-#include "_usage.h"
-#define extraopts "file"
-#define getoptstring "sw" getoptstring_COMMON
-static const struct option longopts[] = {
-	{ "save", 0, NULL, 's' },
-	{ "warn", 0, NULL, 'w' },
-	longopts_COMMON
-};
-static const char * const longopts_help[] = {
-	"saves the time",
-	"no error if no reference file",
-	longopts_help_COMMON
-};
-#include "_usage.c"
-
-int
-swclock(int argc, char **argv)
-{
-	int opt, sflag = 0, wflag = 0;
-	const char *file = RC_SHUTDOWNTIME;
-	struct stat sb;
-	struct timeval tv;
-
-	while ((opt = getopt_long(argc, argv, getoptstring,
-		    longopts, (int *) 0)) != -1)
-	{
-		switch (opt) {
-		case 's':
-			sflag = 1;
-			break;
-		case 'w':
-			wflag = 1;
-			break;
-		case_RC_COMMON_GETOPT
-		}
-	}
-
-	if (optind < argc)
-		file = argv[optind++];
-
-	if (sflag) {
-		if (stat(file, &sb) == -1) {
-			opt = open(file, O_WRONLY | O_CREAT, 0644);
-			if (opt == -1)
-				eerrorx("swclock: open: %s", strerror(errno));
-			close(opt);
-		} else
-			if (utime(file, NULL) == -1)
-				eerrorx("swclock: utime: %s", strerror(errno));
-		return 0;
-	}
-
-	if (stat(file, &sb) == -1) {
-		if (wflag != 0 && errno == ENOENT)
-			ewarn("swclock: `%s': %s", file, strerror(errno));
-		else
-			eerrorx("swclock: `%s': %s", file, strerror(errno));
-		return 0;
-	}
-
-	tv.tv_sec = sb.st_mtime;
-	tv.tv_usec = 0;
-
-	if (settimeofday(&tv, NULL) == -1)
-		eerrorx("swclock: settimeofday: %s", strerror(errno));
-
-	return 0;
-}
diff --git a/src/test/.gitignore b/src/test/.gitignore
deleted file mode 100644
index 1b79b9f9..00000000
--- a/src/test/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-einfo.data.out
-einfo.funcs.out
-librc.funcs.hidden.out
-librc.funcs.hidden.list
-rc.data.out
-rc.funcs.out
diff --git a/src/test/Makefile b/src/test/Makefile
deleted file mode 100644
index b57b8903..00000000
--- a/src/test/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-all:
-
-install:
-
-ignore:
-
-check test::
-	./runtests.sh
-
-verbose-test:
-	VERBOSE=yes ./runtests.sh
-
-clean:
-	rm -rf *.out tmp-*
diff --git a/src/test/einfo.data.list b/src/test/einfo.data.list
deleted file mode 100644
index c638b2f1..00000000
--- a/src/test/einfo.data.list
+++ /dev/null
@@ -1 +0,0 @@
-EINFO_1.0
diff --git a/src/test/einfo.funcs.list b/src/test/einfo.funcs.list
deleted file mode 100644
index 5dbbd96f..00000000
--- a/src/test/einfo.funcs.list
+++ /dev/null
@@ -1,52 +0,0 @@
-ebegin
-ebegin@@EINFO_1.0
-ebeginv
-ebeginv@@EINFO_1.0
-ebracket
-ebracket@@EINFO_1.0
-ecolor
-ecolor@@EINFO_1.0
-eend
-eend@@EINFO_1.0
-eendv
-eendv@@EINFO_1.0
-eerror
-eerror@@EINFO_1.0
-eerrorn
-eerrorn@@EINFO_1.0
-eerrorx
-eerrorx@@EINFO_1.0
-eindent
-eindent@@EINFO_1.0
-eindentv
-eindentv@@EINFO_1.0
-einfo
-einfo@@EINFO_1.0
-einfon
-einfon@@EINFO_1.0
-einfov
-einfov@@EINFO_1.0
-einfovn
-einfovn@@EINFO_1.0
-elog
-elog@@EINFO_1.0
-eoutdent
-eoutdent@@EINFO_1.0
-eoutdentv
-eoutdentv@@EINFO_1.0
-eprefix
-eprefix@@EINFO_1.0
-ewarn
-ewarn@@EINFO_1.0
-ewarnn
-ewarnn@@EINFO_1.0
-ewarnv
-ewarnv@@EINFO_1.0
-ewarnvn
-ewarnvn@@EINFO_1.0
-ewarnx
-ewarnx@@EINFO_1.0
-ewend
-ewend@@EINFO_1.0
-ewendv
-ewendv@@EINFO_1.0
diff --git a/src/test/rc.data.list b/src/test/rc.data.list
deleted file mode 100644
index 3c27c954..00000000
--- a/src/test/rc.data.list
+++ /dev/null
@@ -1,3 +0,0 @@
-RC_1.0
-rc_environ_fd
-rc_environ_fd@@RC_1.0
diff --git a/src/test/rc.funcs.list b/src/test/rc.funcs.list
deleted file mode 100644
index f4c90b51..00000000
--- a/src/test/rc.funcs.list
+++ /dev/null
@@ -1,120 +0,0 @@
-rc_conf_value
-rc_conf_value@@RC_1.0
-rc_config_list
-rc_config_list@@RC_1.0
-rc_config_load
-rc_config_load@@RC_1.0
-rc_config_value
-rc_config_value@@RC_1.0
-rc_deptree_depend
-rc_deptree_depend@@RC_1.0
-rc_deptree_depends
-rc_deptree_depends@@RC_1.0
-rc_deptree_free
-rc_deptree_free@@RC_1.0
-rc_deptree_load
-rc_deptree_load@@RC_1.0
-rc_deptree_load_file
-rc_deptree_load_file@@RC_1.0
-rc_deptree_order
-rc_deptree_order@@RC_1.0
-rc_deptree_update
-rc_deptree_update@@RC_1.0
-rc_deptree_update_needed
-rc_deptree_update_needed@@RC_1.0
-rc_find_pids
-rc_find_pids@@RC_1.0
-rc_getfile
-rc_getfile@@RC_1.0
-rc_getline
-rc_getline@@RC_1.0
-rc_newer_than
-rc_newer_than@@RC_1.0
-rc_older_than
-rc_older_than@@RC_1.0
-rc_proc_getent
-rc_proc_getent@@RC_1.0
-rc_runlevel_exists
-rc_runlevel_exists@@RC_1.0
-rc_runlevel_get
-rc_runlevel_get@@RC_1.0
-rc_runlevel_list
-rc_runlevel_list@@RC_1.0
-rc_runlevel_set
-rc_runlevel_set@@RC_1.0
-rc_runlevel_stack
-rc_runlevel_stack@@RC_1.0
-rc_runlevel_stacks
-rc_runlevel_stacks@@RC_1.0
-rc_runlevel_starting
-rc_runlevel_starting@@RC_1.0
-rc_runlevel_stopping
-rc_runlevel_stopping@@RC_1.0
-rc_runlevel_unstack
-rc_runlevel_unstack@@RC_1.0
-rc_service_add
-rc_service_add@@RC_1.0
-rc_service_daemon_set
-rc_service_daemon_set@@RC_1.0
-rc_service_daemons_crashed
-rc_service_daemons_crashed@@RC_1.0
-rc_service_delete
-rc_service_delete@@RC_1.0
-rc_service_description
-rc_service_description@@RC_1.0
-rc_service_exists
-rc_service_exists@@RC_1.0
-rc_service_extra_commands
-rc_service_extra_commands@@RC_1.0
-rc_service_in_runlevel
-rc_service_in_runlevel@@RC_1.0
-rc_service_mark
-rc_service_mark@@RC_1.0
-rc_service_resolve
-rc_service_resolve@@RC_1.0
-rc_service_schedule_clear
-rc_service_schedule_clear@@RC_1.0
-rc_service_schedule_start
-rc_service_schedule_start@@RC_1.0
-rc_service_started_daemon
-rc_service_started_daemon@@RC_1.0
-rc_service_state
-rc_service_state@@RC_1.0
-rc_service_value_get
-rc_service_value_get@@RC_1.0
-rc_service_value_set
-rc_service_value_set@@RC_1.0
-rc_services_in_runlevel
-rc_services_in_runlevel@@RC_1.0
-rc_services_in_runlevel_stacked
-rc_services_in_runlevel_stacked@@RC_1.0
-rc_services_in_state
-rc_services_in_state@@RC_1.0
-rc_services_scheduled
-rc_services_scheduled@@RC_1.0
-rc_services_scheduled_by
-rc_services_scheduled_by@@RC_1.0
-rc_stringlist_add
-rc_stringlist_add@@RC_1.0
-rc_stringlist_addu
-rc_stringlist_addu@@RC_1.0
-rc_stringlist_delete
-rc_stringlist_delete@@RC_1.0
-rc_stringlist_find
-rc_stringlist_find@@RC_1.0
-rc_stringlist_free
-rc_stringlist_free@@RC_1.0
-rc_stringlist_new
-rc_stringlist_new@@RC_1.0
-rc_stringlist_sort
-rc_stringlist_sort@@RC_1.0
-rc_stringlist_split
-rc_stringlist_split@@RC_1.0
-rc_sys
-rc_sys@@RC_1.0
-rc_sys_v1
-rc_sys_v1@@RC_1.0
-rc_sys_v2
-rc_sys_v2@@RC_1.0
-rc_yesno
-rc_yesno@@RC_1.0
diff --git a/src/test/runtests.sh b/src/test/runtests.sh
deleted file mode 100755
index 5a87c847..00000000
--- a/src/test/runtests.sh
+++ /dev/null
@@ -1,124 +0,0 @@
-#!/bin/sh
-
-top_srcdir=${top_srcdir:-../..}
-. ${top_srcdir}/test/setup_env.sh
-
-libeinfo_srcdir="${srcdir}/../libeinfo"
-libeinfo_builddir="${builddir}/../libeinfo"
-librc_srcdir="${srcdir}/../librc"
-librc_builddir="${builddir}/../librc"
-rc_srcdir="${srcdir}/../rc"
-rc_builddir="${builddir}/../rc"
-
-checkit() {
-	local base=$1; shift
-	echo "$@" | tr ' ' '\n' > ${base}.out
-	diff -u ${base}.list ${base}.out
-	eend $?
-	: $(( ret += $? ))
-}
-
-ret=0
-
-ebegin "Checking exported symbols in libeinfo.so (data)"
-checkit einfo.data $(
-readelf -Ws ${libeinfo_builddir}/libeinfo.so \
-	| awk '$4 == "OBJECT" && $5 == "GLOBAL" && $7 != "UND" {print $NF}' \
-	| LC_ALL=C sort -u
-)
-
-ebegin "Checking exported symbols in libeinfo.so (functions)"
-checkit einfo.funcs $(
-readelf -Ws ${libeinfo_builddir}/libeinfo.so \
-	| awk '$4 == "FUNC" && $5 == "GLOBAL" && $7 != "UND" {print $NF}' \
-	| LC_ALL=C sort -u \
-	| egrep -v \
-		-e '^_(init|fini)$'
-)
-
-ebegin "Checking exported symbols in librc.so (data)"
-checkit rc.data $(
-readelf -Ws ${librc_builddir}/librc.so \
-	| awk '$4 == "OBJECT" && $5 == "GLOBAL" && $7 != "UND" {print $NF}' \
-	| LC_ALL=C sort -u
-)
-
-ebegin "Checking exported symbols in librc.so (functions)"
-checkit rc.funcs $(
-readelf -Ws ${librc_builddir}/librc.so \
-	| awk '$4 == "FUNC" && $5 == "GLOBAL" && $7 != "UND" {print $NF}' \
-	| LC_ALL=C sort -u \
-	| egrep -v \
-		-e '^_(init|fini)$'
-)
-
-ebegin "Checking hidden functions in librc.so"
-sed -n '/^librc_hidden_proto/s:.*(\(.*\))$:\1:p' ${librc_srcdir}/librc.h \
-	| LC_ALL=C sort -u \
-	> librc.funcs.hidden.list
-readelf -Wr $(grep -l '#include[[:space:]]"librc\.h"' ${librc_srcdir}/*.c | sed 's:\.c$:.o:') \
-	| egrep -v -e 'R_PARISC_(DP|SEG)REL' \
-	| awk '$5 ~ /^rc_/ {print $5}' \
-	| LC_ALL=C sort -u \
-	| egrep -v '^rc_environ_fd$' \
-	> librc.funcs.hidden.out
-syms=$(diff -u librc.funcs.hidden.list librc.funcs.hidden.out | sed -n '/^+[^+]/s:^+::p')
-[ -z "${syms}" ]
-eend $? "Missing hidden defs:"$'\n'"${syms}"
-: $(( ret += $? ))
-
-ebegin "Checking trailing whitespace in code"
-# XXX: Should we check man pages too ?
-out=$(cd ${top_srcdir}; find */ \
-	'(' -name '*.[ch]' -o -name '*.in' -o -name '*.sh' ')' \
-	-exec grep -n -E '[[:space:]]+$' {} +)
-[ -z "${out}" ]
-eend $? "Trailing whitespace needs to be deleted:"$'\n'"${out}"
-
-ebegin "Checking trailing newlines in code"
-out=$(cd ${top_srcdir};
-	for f in `find */ -name '*.[ch]'` ; do
-		sed -n -e :a -e '/^\n*$/{$q1;N;ba' -e '}' $f || echo $f
-	done)
-[ -z "${out}" ]
-eend $? "Trailing newlines need to be deleted:"$'\n'"${out}"
-
-ebegin "Checking for obsolete functions"
-out=$(cd ${top_srcdir}; find src -name '*.[ch]' \
-	-exec grep -n -E '\<(malloc|memory|sys/(errno|fcntl|signal|stropts|termios|unistd))\.h\>' {} +)
-[ -z "${out}" ]
-eend $? "Avoid these obsolete functions:"$'\n'"${out}"
-
-ebegin "Checking for x* func usage"
-out=$(cd ${top_srcdir}; find src -name '*.[ch]' \
-	-exec grep -n -E '\<(malloc|strdup)[[:space:]]*\(' {} + \
-	| grep -v \
-		-e src/includes/helpers.h \
-		-e src/libeinfo/libeinfo.c)
-[ -z "${out}" ]
-eend $? "These need to be using the x* variant:"$'\n'"${out}"
-
-ebegin "Checking spacing style"
-out=$(cd ${top_srcdir}; find src -name '*.[ch]' \
-	-exec grep -n -E \
-		-e '\<(for|if|switch|while)\(' \
-		-e '\<(for|if|switch|while) \( ' \
-		-e ' ;' \
-		-e '[[:space:]]$' \
-		-e '\){' \
-		-e '(^|[^:])//' \
-	{} +)
-[ -z "${out}" ]
-eend $? "These lines violate style rules:"$'\n'"${out}"
-
-einfo "Running unit tests"
-eindent
-for u in units/*; do
-	[ -x "${u}" -a -f "${u}" ] || continue
-	ebegin "$(basename "${u}")"
-	./"${u}"
-	eend $?
-	: $(( ret += $? ))
-done
-
-exit ${ret}
diff --git a/src/test/units/is_older_than b/src/test/units/is_older_than
deleted file mode 100755
index 47a62d78..00000000
--- a/src/test/units/is_older_than
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/bin/sh
-# unit test for is_older_than code of baselayout (2008/06/19)
-# Author: Matthias Schwarzott <zzam@gentoo.org>
-
-TMPDIR=tmp-"$(basename "$0")"
-
-# Please note that we added this unit test because the function
-# should really be called is_newer_than as it's what it's really testing.
-# Or more perversly, returning 0 on failure and 1 and success.
-
-# bool is_older_than(reference, files/dirs to check)
-#
-#   return 0 if any of the files/dirs are newer than
-#   the reference file
-#
-#   EXAMPLE: if is_older_than a.out *.o ; then ...
-ref_is_older_than()
-{
-	local x= ref="$1"
-	shift
-
-	for x; do
-		[ "${x}" -nt "${ref}" ] && return 0
-		if [ -d "${x}" ]; then
-			ref_is_older_than "${ref}" "${x}"/* && return 0
-		fi
-	done
-	return 1
-}
-
-do_test()
-{
-	local r1= r2=
-
-	ref_is_older_than "$@"
-	r1=$?
-	is_older_than "$@"
-	r2=$?
-
-	[ -n "${VERBOSE}" ] && echo "reference = $r1  |  OpenRC = $r2"
-	[ $r1 = $r2 ]
-}
-
-echo_cmd()
-{
-	[ -n "${VERBOSE}" ] && echo "$@"
-	"$@"
-}
-
-test_it()
-{
-	do_test "${TMPDIR}"/ref "${TMPDIR}"/dir1 "${TMPDIR}"/dir2
-}
-
-run_test()
-{
-	echo_cmd mkdir -p "${TMPDIR}"/dir1 "${TMPDIR}"/dir2
-	echo_cmd touch "${TMPDIR}"/dir1/f1 "${TMPDIR}"/dir1/f2 \
-		"${TMPDIR}"/dir1/f3 "${TMPDIR}"/dir2/f1 \
-		"${TMPDIR}"/dir2/f2 "${TMPDIR}"/dir2/f3
-	echo_cmd sleep 1
-	echo_cmd touch "${TMPDIR}"/ref
-	test_it || return 1
-
-	echo_cmd sleep 1
-	echo_cmd touch "${TMPDIR}"/dir1/f2
-	test_it || return 1
-
-	echo_cmd sleep 1
-	echo_cmd touch "${TMPDIR}"/ref
-	test_it || return 1
-
-	echo_cmd sleep 1
-	echo_cmd touch "${TMPDIR}"/dir2/f2
-	test_it || return 1
-}
-
-rm -rf "${TMPDIR}"
-mkdir "${TMPDIR}"
-run_test
-retval=$?
-rm -rf "${TMPDIR}"
-exit ${retval}
diff --git a/src/tools/Makefile b/src/tools/Makefile
deleted file mode 100644
index 92ff5063..00000000
--- a/src/tools/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-DIR=	${UPREFIX}/bin
-BIN=	deptree2dot
-
-MK=	../../mk
-include ${MK}/scripts.mk
diff --git a/src/tools/deptree2dot b/src/tools/deptree2dot
deleted file mode 100644
index 07ba17af..00000000
--- a/src/tools/deptree2dot
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/perl -w
-# -*- cperl -*-
-# Copyright © 2012 Diego Elio Pettenò <flameeyes@flameeyes.eu>
-# Released under the 2-clause BSD license.
-#
-#Example usage:
-#deptree2dot > deptree.dot
-#deptree2dot | dot -Tpng -o deptree.png
-
-my $deptree = defined($ARGV[0]) ? $ARGV[0] : "/run/openrc/deptree";
-
-open DEPTREE, $deptree or exit 1;
-
-print "digraph deptree {\n";
-
-my @deptree;
-
-while(my $line = readline(DEPTREE)) {
-  $line =~ /^depinfo_([0-9]+)_([a-z]+)(?:_[0-9]+)?='(.*)'\n$/;
-  my $index = $1;
-  my $prop = $2;
-  my $value = $3; $value =~ s/[-\.:~]/_/g;
-
-  if ( $prop eq "service" ) {
-    $deptree[$index] = $value;
-    printf "%s [shape=box];\n", $value;
-  } else {
-    my $service = $deptree[$index];
-
-    if ( $prop eq "ineed" ) {
-      printf "%s -> %s;\n", $service, $value;
-    } elsif ( $prop eq "iuse" ) {
-      printf "%s -> %s [color=blue];\n", $service, $value;
-    } elsif ( $prop eq "ibefore" ) {
-      printf "%s -> %s [style=dotted];\n", $service, $value;
-    } elsif ( $prop eq "iafter" ) {
-      printf "%s -> %s [style=dotted color=purple];\n", $value, $service;
-    } elsif ( $prop eq "iprovide" ) {
-      printf "%s -> %s [color=red];\n", $value, $service;
-    }
-  }
-}
-
-print "}\n";