Change license and style, reorganise file, make makefile portable, and fix bugs1.3

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 875 insertions, 0 deletions

diff --git a/coopgammad.c b/coopgammad.c
new file mode 100644
index 0000000..50ba53b
--- /dev/null
+++ b/coopgammad.c
@@ -0,0 +1,875 @@
+/* See LICENSE file for copyright and license details. */
+#include "arg.h"
+#include "util.h"
+#include "state.h"
+#include "servers-master.h"
+#include "servers-kernel.h"
+#include "servers-crtc.h"
+#include "servers-gamma.h"
+#include "servers-coopgamma.h"
+
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+/**
+ * Number put in front of the marshalled data
+ * so the program an detect incompatible updates
+ */
+#define MARSHAL_VERSION  0
+
+
+#ifndef GCC_ONLY
+# if defined(__GNUC__) && !defined(__clang__)
+#  define GCC_ONLY(...) __VA_ARGS__
+# else
+#  define GCC_ONLY(...) /* nothing */
+# endif
+#endif
+
+
+/**
+ * Lists all function recognised adjustment methods,
+ * will call macro X with the code for the each
+ * adjustment method as the first argument and
+ * corresponding name as the second argument
+ */
+#define LIST_ADJUSTMENT_METHODS\
+	X(LIBGAMMA_METHOD_DUMMY,                "dummy")\
+	X(LIBGAMMA_METHOD_X_RANDR,              "randr")\
+	X(LIBGAMMA_METHOD_X_VIDMODE,            "vidmode")\
+	X(LIBGAMMA_METHOD_LINUX_DRM,            "drm")\
+	X(LIBGAMMA_METHOD_W32_GDI,              "gdi")\
+	X(LIBGAMMA_METHOD_QUARTZ_CORE_GRAPHICS, "quartz")
+
+
+/**
+ * Used by initialisation functions as their return type. If a
+ * value not listed here is returned by such function, it is the
+ * exit value the process shall exit with as soon as possible.
+ */
+enum init_status {
+	/**
+	 * Initialisation was successful
+	 */
+	INIT_SUCCESS = -1,
+
+	/**
+	 * Initialisation failed
+	 */
+	INIT_FAILURE = -2,
+
+	/**
+	 * Server is already running
+	 */
+	INIT_RUNNING = -3,
+};
+
+
+/**
+ * The pathname of the PID file
+ */
+extern char *restrict pidpath;
+char *restrict pidpath = NULL;
+
+/**
+ * The pathname of the socket
+ */
+extern char *restrict socketpath;
+char *restrict socketpath = NULL;
+
+
+
+/**
+ * Called when the process receives
+ * a signal telling it to re-execute
+ * 
+ * @param  signo  The received signal
+ */
+static void
+sig_reexec(int signo)
+{
+	int saved_errno = errno;
+	reexec = 1;
+	signal(signo, sig_reexec);
+	errno = saved_errno;
+}
+
+
+/**
+ * Called when the process receives
+ * a signal telling it to terminate
+ * 
+ * @param  signo  The received signal
+ */
+static void
+sig_terminate(int signo)
+{
+	terminate = 1;
+	(void) signo;
+}
+
+
+/**
+ * Called when the process receives
+ * a signal telling it to disconnect
+ * from or reconnect to the site
+ * 
+ * @param  signo  The received signal
+ */
+static void
+sig_connection(int signo)
+{
+	int saved_errno = errno;
+	connection = signo - SIGRTMIN + 1;
+	signal(signo, sig_connection);
+	errno = saved_errno;
+}
+
+
+/**
+ * Called when the process receives
+ * a signal telling it to dump its
+ * state to stderr
+ * 
+ * @param  signo  The received signal
+ */
+static void
+sig_info(int signo)
+{
+	int saved_errno = errno;
+	char *env;
+	signal(signo, sig_info);
+	env = getenv("COOPGAMMAD_PIDFILE_TOKEN");
+	fprintf(stderr, "PID file token: %s\n", env ? env : "(null)");
+	fprintf(stderr, "PID file: %s\n", pidpath ? pidpath : "(null)");
+	fprintf(stderr, "Socket path: %s\n", socketpath ? socketpath : "(null)");
+	state_dump();
+	errno = saved_errno;
+}
+
+
+/**
+ * Parse adjustment method name (or stringised number)
+ * 
+ * @param   arg  The adjustment method name (or stringised number)
+ * @return       The adjustment method, -1 (negative) on error
+ */
+GCC_ONLY(__attribute__((__nonnull__)))
+static int
+get_method(const char *restrict arg)
+{
+#if LIBGAMMA_METHOD_MAX > 5
+# warning libgamma has added more adjustment methods
+#endif
+
+	const char *restrict p;
+  
+#define X(C, N) if (!strcmp(arg, N)) return C;
+	LIST_ADJUSTMENT_METHODS;
+#undef X
+
+	if (!*arg || (/* avoid overflow: */ strlen(arg) > 4))
+		goto bad;
+	for (p = arg; *p; p++)
+		if ('0' > *p || *p > '9')
+			goto bad;
+
+	return atoi(arg);
+
+bad:
+	fprintf(stderr, "%s: unrecognised adjustment method name: %s\n", argv0, arg);
+	errno = 0;
+	return -1;
+}
+
+
+/**
+ * Set up signal handlers
+ * 
+ * @return  Zero on success, -1 on error
+ */
+static int
+set_up_signals(void)
+{
+	if (signal(SIGUSR1,      sig_reexec)     == SIG_ERR ||
+	    signal(SIGUSR2,      sig_info)       == SIG_ERR ||
+#if defined(SIGINFO)
+	    signal(SIGINFO,      sig_info)       == SIG_ERR ||
+#endif
+	    signal(SIGTERM,      sig_terminate)  == SIG_ERR ||
+	    signal(SIGRTMIN + 0, sig_connection) == SIG_ERR ||
+	    signal(SIGRTMIN + 1, sig_connection) == SIG_ERR)
+		return -1;
+	return 0;
+}
+
+
+/**
+ * Fork the process to the background
+ * 
+ * @param   keep_stderr  Keep stderr open?
+ * @return               An `enum init_status` value or an exit value
+ */
+static enum init_status
+daemonise(int keep_stderr)
+{
+	pid_t pid;
+	int fd = -1, saved_errno;
+	int notify_rw[2] = {-1, -1};
+	char a_byte = 0;
+	ssize_t got;
+
+	if (pipe(notify_rw) < 0)
+		goto fail;
+	if (notify_rw[0] <= STDERR_FILENO)
+		if ((notify_rw[0] = fcntl(notify_rw[0], F_DUPFD, STDERR_FILENO + 1)) < 0)
+			goto fail;
+	if (notify_rw[1] <= STDERR_FILENO)
+		if ((notify_rw[1] = fcntl(notify_rw[1], F_DUPFD, STDERR_FILENO + 1)) < 0)
+			goto fail;
+
+	if ((pid = fork()) < 0)
+		goto fail;
+	if (pid > 0) {
+		/* Original process (parent): */
+		waitpid(pid, NULL, 0);
+		close(notify_rw[1]), notify_rw[1] = -1;
+		got = read(notify_rw[0], &a_byte, 1);
+		if (got < 0)
+			goto fail;
+		close(notify_rw[0]);
+		errno = 0;
+		return got == 0 ? INIT_FAILURE : (enum init_status)0;
+	}
+
+	/* Intermediary process (child): */
+	close(notify_rw[0]), notify_rw[0] = -1;
+	if (setsid() < 0)
+		goto fail;
+	if ((pid = fork()) < 0)
+		goto fail;
+	if (pid > 0) {
+		/* Intermediary process (parent): */
+		return (enum init_status)0;
+	}
+
+	/* Daemon process (child): */
+
+	/* Replace std* with /dev/null */
+	fd = open("/dev/null", O_RDWR);
+	if (fd < 0 ||
+	    dup2(fd, STDIN_FILENO) < 0 ||
+	    dup2(fd, STDOUT_FILENO) < 0 ||
+	    (keep_stderr && dup2(fd, STDERR_FILENO) < 0))
+		goto fail;
+	if (fd > STDERR_FILENO)
+		close(fd);
+	fd = -1;
+  
+	/* Update PID file */
+	fd = open(pidpath, O_WRONLY);
+	if (fd < 0)
+		goto fail;
+	if (dprintf(fd, "%llu\n", (unsigned long long)getpid()) < 0)
+		goto fail;
+	close(fd);
+	fd = -1;
+
+	/* Notify */
+	if (write(notify_rw[1], &a_byte, 1) <= 0)
+		goto fail;
+	close(notify_rw[1]);
+
+	return INIT_SUCCESS;
+fail:
+	saved_errno = errno;
+	if (fd >= 0)
+		close(fd);
+	if (notify_rw[0] >= 0)
+		close(notify_rw[0]);
+	if (notify_rw[1] >= 0)
+		close(notify_rw[1]);
+	errno = saved_errno;
+	return INIT_FAILURE;
+}
+
+
+/**
+ * Initialise the process
+ * 
+ * @param   foreground   Keep process in the foreground
+ * @param   keep_stderr  Keep stderr open
+ * @param   query        Was -q used, see `main` for description
+ * @return               An `enum init_status` value or an exit value
+ */
+static enum init_status
+initialise(int foreground, int keep_stderr, int query)
+{
+	struct rlimit rlimit;
+	size_t i, n;
+	sigset_t mask;
+	int s;
+	enum init_status r;
+
+	/* Zero out some memory so it can be destroyed safely. */
+	memset(&site, 0, sizeof(site));
+
+	if (!query) {
+		/* Close all file descriptors above stderr */
+		if (getrlimit(RLIMIT_NOFILE, &rlimit) || rlimit.rlim_cur == RLIM_INFINITY)
+			n = 4 << 10;
+		else
+			n = (size_t)(rlimit.rlim_cur);
+		for (i = STDERR_FILENO + 1; i < n; i++)
+			close((int)i);
+
+		/* Set umask, reset signal handlers, and reset signal mask */
+		umask(0);
+		for (s = 1; s < _NSIG; s++)
+			signal(s, SIG_DFL);
+		if (sigfillset(&mask))
+			perror(argv0);
+		else
+			sigprocmask(SIG_UNBLOCK, &mask, NULL);
+	}
+
+	/* Get method */
+	if (method < 0 && libgamma_list_methods(&method, 1, 0) < 1)
+		return fprintf(stderr, "%s: no adjustment method available\n", argv0), -1;
+
+	/* Go no further if we are just interested in the adjustment method and site */
+	if (query)
+		return INIT_SUCCESS;
+
+	/* Get site */
+	if (initialise_site() < 0)
+		goto fail;
+
+	/* Get PID file and socket pathname */
+	if (!(pidpath = get_pidfile_pathname()) ||
+	    !(socketpath = get_socket_pathname()))
+		goto fail;
+
+	/* Create PID file */
+	if ((r = create_pidfile(pidpath)) < 0) {
+		free(pidpath);
+		pidpath = NULL;
+		if (r == -2)
+			return INIT_RUNNING;
+		goto fail;
+	}
+
+	/* Get partitions and CRTC:s */
+	if (initialise_crtcs() < 0)
+		goto fail;
+
+	/* Get CRTC information */
+	if (outputs_n && !(outputs = calloc(outputs_n, sizeof(*outputs))))
+		goto fail;
+	if (initialise_gamma_info() < 0)
+		goto fail;
+
+	/* Sort outputs */
+	qsort(outputs, outputs_n, sizeof(*outputs), output_cmp_by_name);
+
+	/* Load current gamma ramps */
+	store_gamma();
+
+	/* Preserve current gamma ramps at priority=0 if -p */
+	if (preserve && preserve_gamma() < 0)
+		goto fail;
+
+	/* Create socket and start listening */
+	if (create_socket(socketpath) < 0)
+		goto fail;
+
+	/* Get the real pathname of the process's binary, in case
+	 * it is relative, so we can re-execute without problem. */
+	if (*argv0 != '/' && strchr(argv0, '/') && !(argv0_real = realpath(argv0, NULL)))
+		goto fail;
+
+	/* Change directory to / to avoid blocking umounting */
+	if (chdir("/") < 0)
+		perror(argv0);
+
+	/* Set up signal handlers */
+	if (set_up_signals() < 0)
+		goto fail;
+
+	/* Place in the background unless -f */
+	if (!foreground) {
+		return daemonise(keep_stderr);
+	} else {
+		/* Signal the spawner that the service is ready */
+		close(STDOUT_FILENO);
+		/* Avoid potential catastrophes that would occur if a library
+		 * that is being used was so mindless as to write to stdout. */
+		if (dup2(STDERR_FILENO, STDOUT_FILENO) < 0)
+			perror(argv0);
+	}
+
+	return INIT_SUCCESS;
+fail:
+	return INIT_FAILURE;
+}
+
+
+/**
+ * Deinitialise the process
+ * 
+ * @param  full  Perform a full deinitialisation, shall be
+ *               done iff the process is going to re-execute
+ */
+static void
+destroy(int full)
+{
+	if (full) {
+		disconnect_all();
+		close_socket(socketpath);
+		free(argv0_real);
+		if (outputs && connected)
+			restore_gamma();
+	}
+	state_destroy();
+	free(socketpath);
+	if (full && pidpath)
+		unlink(pidpath);
+	free(pidpath);
+}
+
+
+#if defined(__clang__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wcast-align"
+#endif
+
+
+/**
+ * Marshal the state of the process
+ * 
+ * @param   buf  Output buffer for the marshalled data,
+ *               `NULL` to only measure how large the
+ *               buffer needs to be
+ * @return       The number of marshalled bytes
+ */
+static size_t
+marshal(void *restrict buf)
+{
+	size_t off = 0, n;
+	char *restrict bs = buf;
+
+	if (bs)
+		*(int *)&bs[off] = MARSHAL_VERSION;
+	off += sizeof(int);
+
+	n = strlen(pidpath) + 1;
+	if (bs)
+		memcpy(&bs[off], pidpath, n);
+	off += n;
+
+	n = strlen(socketpath) + 1;
+	if (bs)
+		memcpy(&bs[off], socketpath, n);
+	off += n;
+
+	off += state_marshal(bs ? &bs[off] : NULL);
+
+	return off;
+}
+
+
+/**
+ * Unmarshal the state of the process
+ * 
+ * @param   buf  Buffer with the marshalled data
+ * @return       The number of marshalled bytes, 0 on error
+ */
+GCC_ONLY(__attribute__((__nonnull__)))
+static size_t
+unmarshal(const void *restrict buf)
+{
+	size_t off = 0, n;
+	const char *restrict bs = buf;
+
+	if (*(const int *)&bs[off] != MARSHAL_VERSION) {
+		fprintf(stderr, "%s: re-executing to incompatible version, sorry about that\n", argv0);
+		errno = 0;
+		return 0;
+	}
+	off += sizeof(int);
+
+	n = strlen(&bs[off]) + 1;
+	if (!(pidpath = memdup(&bs[off], n)))
+		return 0;
+	off += n;
+
+	n = strlen(&bs[off]) + 1;
+	if (!(socketpath = memdup(&bs[off], n)))
+		return 0;
+	off += n;
+
+	off += n = state_unmarshal(&bs[off]);
+	if (!n)
+		return 0;
+
+	return off;
+}
+
+
+#if defined(__clang__)
+# pragma GCC diagnostic pop
+#endif
+
+
+/**
+ * Do minimal initialisation, unmarshal the state of
+ * the process and merge with new state
+ * 
+ * @param   statefile  The state file
+ * @return             Zero on success, -1 on error
+ */
+GCC_ONLY(__attribute__((__nonnull__)))
+static int
+restore_state(const char *restrict statefile)
+{
+	void *marshalled = NULL;
+	int fd = -1, saved_errno;
+	size_t r, n;
+
+	if (set_up_signals() < 0)
+		goto fail;
+
+	fd = open(statefile, O_RDONLY);
+	if (fd < 0)
+		goto fail;
+
+	if (!(marshalled = nread(fd, &n)))
+		goto fail;
+	close(fd);
+	fd = -1;
+	unlink(statefile);
+	statefile = NULL;
+
+	r = unmarshal(marshalled);
+	if (!r)
+		goto fail;
+	if (r != n) {
+		fprintf(stderr, "%s: unmarshalled state file was %s than the unmarshalled state: read %zu of %zu bytes\n",
+		        argv0, n > r ? "larger" : "smaller", r, n);
+		errno = 0;
+		goto fail;
+	}
+	free(marshalled);
+	marshalled = NULL;
+
+	if (connected) {
+		connected = 0;
+		if (reconnect() < 0)
+			goto fail;
+	}
+
+	return 0;
+fail:
+	saved_errno = errno;
+	if (fd >= 0)
+		close(fd);
+	free(marshalled);
+	errno = saved_errno;
+	return -1;
+}
+
+
+/**
+ * Reexecute the server
+ * 
+ * Returns only on failure
+ * 
+ * @return  Pathname of file where the state is stored,
+ *          `NULL` if the state is in tact
+ */
+static char *
+reexecute(void)
+{
+	char *statefile = NULL;
+	char *statebuffer = NULL;
+	size_t buffer_size;
+	int fd = -1, saved_errno;
+
+	statefile = get_state_pathname();
+	if (!statefile)
+		goto fail;
+
+	buffer_size = marshal(NULL);
+	statebuffer = malloc(buffer_size);
+	if (!statebuffer)
+		goto fail;
+	if (marshal(statebuffer) != buffer_size) {
+		fprintf(stderr, "%s: internal error\n", argv0);
+		errno = 0;
+		goto fail;
+	}
+
+	fd = open(statefile, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR);
+	if (fd < 0)
+		goto fail;
+
+	if (nwrite(fd, statebuffer, buffer_size) != buffer_size)
+		goto fail;
+	free(statebuffer);
+	statebuffer = NULL;
+
+	if (close(fd) < 0) {
+		fd = -1;
+		if (errno != EINTR)
+			goto fail;
+	}
+	fd = -1;
+
+	destroy(0);
+
+	execlp(argv0_real ? argv0_real : argv0, argv0, "- ", statefile, NULL);
+	free(argv0_real);
+	argv0_real = NULL;
+	return statefile;
+
+fail:
+	saved_errno = errno;
+	free(statebuffer);
+	if (fd >= 0)
+		close(fd);
+	if (statefile != NULL) {
+		unlink(statefile);
+		free(statefile);
+	}
+	errno = saved_errno;
+	return NULL;
+}
+
+
+/**
+ * Print the response for the -q option
+ * 
+ * @param   query  See -q for `main`, must be atleast 1
+ * @return         Zero on success, -1 on error
+ */
+static int
+print_method_and_site(int query)
+{
+	const char *restrict methodname = NULL;
+	char *p;
+
+	if (query == 1) {
+		switch (method) {
+#define X(C, N) case C: methodname = N; break;
+		LIST_ADJUSTMENT_METHODS;
+#undef X
+		default:
+			if (printf("%i\n", method) < 0)
+				return -1;
+			break;
+		}
+		if (methodname)
+			if (printf("%s\n", methodname) < 0)
+				return -1;
+	}
+
+	if (!sitename)
+		if ((sitename = libgamma_method_default_site(method)))
+			if (!(sitename = memdup(sitename, strlen(sitename) + 1)))
+				return -1;
+
+	if (sitename) {
+		switch (method) {
+		case LIBGAMMA_METHOD_X_RANDR:
+		case LIBGAMMA_METHOD_X_VIDMODE:
+			if ((p = strrchr(sitename, ':')))
+				if ((p = strchr(p, '.')))
+					*p = '\0';
+			break;
+		default:
+			break;
+		}
+	}
+
+	if (sitename && query == 1)
+		if (printf("%s\n", sitename) < 0)
+			return -1;
+
+	if (query == 2) {
+		site.method = method;
+		site.site = sitename;
+		sitename = NULL;
+		socketpath = get_socket_pathname();
+		if (!socketpath)
+			return -1;
+		if (printf("%s\n", socketpath) < 0)
+			return -1;
+	}
+
+	if (fflush(stdout))
+		return -1;
+	return 0;
+}
+
+
+/**
+ * Print usage information and exit
+ */
+#if defined(__GNU__) || defined(__clang__)
+__attribute__((__noreturn__))
+#endif
+static void
+usage(void)
+{
+	fprintf(stderr, "usage: %s [-m method] [-s site] [-fkpq]\n", argv0);
+	exit(1);
+}
+
+
+#if defined(__clang__)
+# pragma GCC diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+
+/**
+ * Must not be started without stdin, stdout, or stderr (may be /dev/null)
+ * 
+ * argv[0] must refer to the real command name or pathname,
+ * otherwise, re-execute will not work
+ * 
+ * The process closes stdout when the socket has been created
+ * 
+ * @signal  SIGUSR1     Re-execute to updated process image
+ * @signal  SIGUSR2     Dump the state of the process to standard error
+ * @signal  SIGINFO     Ditto
+ * @signal  SIGTERM     Terminate the process gracefully
+ * @signal  SIGRTMIN+0  Disconnect from the site
+ * @signal  SiGRTMIN+1  Reconnect to the site
+ * 
+ * @param   argc  The number of elements in `argv`
+ * @param   argv  Command line arguments. Recognised options:
+ *                  -s SITENAME
+ *                    The site to which to connect
+ *                  -m METHOD
+ *                    Adjustment method name or adjustment method number
+ *                  -p
+ *                    Preserve current gamma ramps at priority 0
+ *                  -f
+ *                    Do not fork the process into the background
+ *                  -k
+ *                    Keep stderr open
+ *                  -q
+ *                    Print the select (possiblity default) adjustment
+ *                    method on the first line in stdout, and the
+ *                    selected (possibility defasult) site on the second
+ *                    line in stdout, and exit. If the site name is `NULL`,
+ *                    the second line is omitted. This is indented to
+ *                    be used by clients to figure out to which instance
+ *                    of the service it should connect. Use twice to
+ *                    simply ge the socket pathname, an a terminating LF.
+ *                    By combining -q and -m you can enumerate the name
+ *                    of all recognised adjustment method, start from 0
+ *                    and work up until a numerical adjustment method is
+ *                    returned.
+ * @return        0: Successful
+ *                1: An error occurred
+ *                2: Already running
+ */
+int
+main(int argc, char *argv[])
+{
+	int rc = 1, foreground = 0, keep_stderr = 0, query = 0, r;
+	char *statefile = NULL, *statefile_ = NULL;
+
+	ARGBEGIN {
+	case 's':
+		sitename = EARGF(usage());
+		/* To simplify re-exec: */
+		sitename = memdup(sitename, strlen(sitename) + 1);
+		if (!sitename)
+			goto fail;
+		break;
+	case 'm':
+		method = get_method(EARGF(usage()));
+		if (method < 0)
+			goto fail;
+		break;
+	case 'p': preserve    = 1;     break;
+	case 'f': foreground  = 1;     break;
+	case 'k': keep_stderr = 1;     break;
+	case 'q': query = 1 + !!query; break;
+	case ' ': /* Internal, do not document */
+		statefile = statefile_ = EARGF(usage());
+		break;
+	default:
+		usage();
+	}
+	ARGEND;
+
+	if (argc > 0)
+		usage();
+
+restart:
+	if (!statefile) {
+		switch ((r = initialise(foreground, keep_stderr, query))) {
+		case INIT_SUCCESS: break;
+		case INIT_RUNNING: rc = 2;  /* fall through */
+		case INIT_FAILURE: goto fail;
+		default:           return r;
+		}
+	} else if (restore_state(statefile) < 0) {
+		goto fail;
+	} else {
+		if (statefile != statefile_)
+			free(statefile);
+		unlink(statefile);
+		statefile = NULL;
+	}
+
+	if (query) {
+		if (print_method_and_site(query) < 0)
+			goto fail;
+		goto done;
+	}
+
+reenter_loop:
+	if (main_loop() < 0)
+		goto fail;
+
+	if (reexec && !terminate) {
+		statefile = reexecute();
+		if (statefile) {
+			perror(argv0);
+			fprintf(stderr, "%s: restoring state without re-executing\n", argv0);
+			reexec = 0;
+			goto restart;
+		}
+		perror(argv0);
+		fprintf(stderr, "%s: continuing without re-executing\n", argv0);
+		reexec = 0;
+		goto reenter_loop;
+	}
+
+done:
+	rc = 0;
+deinit:
+	if (statefile)
+		unlink(statefile);
+	if (reexec)
+		free(statefile);
+	destroy(1);
+	return rc;
+
+fail:
+	if (errno)
+		perror(argv0);
+	goto deinit;
+}