massive simpliciation and small bug fixes (not tested yet)

Signed-off-by: Mattias Andrée <maandree@member.fsf.org>

1 files changed, 501 insertions, 0 deletions

diff --git a/src/common.c b/src/common.c
new file mode 100644
index 0000000..a6f4c7c
--- /dev/null
+++ b/src/common.c
@@ -0,0 +1,501 @@
+/**
+ * Copyright © 2015, 2016  Mattias Andrée <maandree@member.fsf.org>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "common.h"
+#include <ctype.h>
+#include <stdarg.h>
+#include <pwd.h>
+#include <sys/wait.h>
+
+
+
+/**
+ * The environment.
+ */
+extern char **environ;
+
+
+
+/**
+ * Common code for `preadn` and `pwriten`.
+ * 
+ * @param  FUN  `pread` or `pwrite`.
+ */
+#define PIO(FUN)  \
+	ssize_t r, n = 0;  \
+	int saved_errno = 0;  \
+	sigset_t mask, oldmask;  \
+	sigfillset(&mask);  \
+	sigprocmask(SIG_BLOCK, &mask, &oldmask);  \
+	while (nbyte) {  \
+		t (r = FUN(fildes, buffer, nbyte, (off_t)offset), r < 0);  \
+		if (r == 0)  \
+			break;  \
+		n += r;  \
+		buffer += r;  \
+		offset += (size_t)r;  \
+		nbyte -= (size_t)r;  \
+	}  \
+done:  \
+	sigprocmask(SIG_SETMASK, &oldmask, NULL);  \
+	errno = saved_errno;  \
+	return n;  \
+fail:  \
+	saved_errno = errno;  \
+	n = -1;  \
+	goto done
+
+
+/**
+ * Wrapper for `pread` that reads the required amount of data.
+ * 
+ * @param   fildes  See pread(3).
+ * @param   buf     See pread(3).
+ * @param   nbyte   See pread(3).
+ * @param   offset  See pread(3).
+ * @return          See pread(3), only short if the file is shorter.
+ */
+ssize_t
+preadn(int fildes, void *buf, size_t nbyte, size_t offset)
+{
+	char *buffer = buf;
+	PIO(pread);
+}
+
+
+/**
+ * Wrapper for `pwrite` that writes all specified data.
+ * 
+ * @param   fildes  See pwrite(3).
+ * @param   buf     See pwrite(3).
+ * @param   nbyte   See pwrite(3).
+ * @param   offset  See pwrite(3).
+ * @return          See pwrite(3).
+ */
+ssize_t
+pwriten(int fildes, const void *buf, size_t nbyte, size_t offset)
+{
+	const char *buffer = buf;
+	PIO(pwrite);
+}
+
+
+/**
+ * Unmarshal a `NULL`-terminated string array.
+ * 
+ * The elements are not actually copied, subpointers
+ * to `buf` are stored in the returned list.
+ * 
+ * @param   buf  The marshalled array. Must end with a NUL byte.
+ * @param   len  The length of `buf`.
+ * @param   n    Output parameter for the number of elements. May be `NULL`
+ * @return       The list, `NULL` on error.
+ * 
+ * @throws  Any exception specified for realloc(3).
+ */
+char **
+restore_array(char *buf, size_t len, size_t *n)
+{
+	char **rc = malloc((len + 1) * sizeof(char*));
+	char **new = NULL;
+	size_t i = 0, e = 0;
+
+	t (!rc);
+	while (i < len)  i += strlen(rc[e++] = buf + i) + 1;
+	if (n)           *n = e;
+	rc[e++] = NULL;
+	new = realloc(rc, e * sizeof(char*));
+fail:
+	return new ? new : rc;
+}
+
+
+/**
+ * Create `NULL`-terminate subcopy of an list,
+ * 
+ * @param   list  The list.
+ * @param   n     The number of elements in the new sublist.
+ * @return        The sublist, `NULL` on error.
+ * 
+ * @throws  Any exception specified for malloc(3).
+ */
+char **
+sublist(char *const *list, size_t n)
+{
+	char **rc = malloc((n + 1) * sizeof(char*));
+	t (!rc);
+	for (rc[n] = NULL; n--; rc[n] = list[n]);
+fail:
+	return rc;
+}
+
+
+/**
+ * Create a new open file descriptor for an already
+ * existing file descriptor.
+ * 
+ * @param   fd     The file descriptor that shall be promoted
+ *                 to a new open file descriptor.
+ * @param   oflag  See open(3), `O_CREAT` is not allowed.
+ * @return         0 on success, -1 on error.
+ */
+int
+reopen(int fd, int oflag)
+{
+	char path[sizeof("/dev/fd/") + 3 * sizeof(int)];
+	int r, saved_errno;
+
+	sprintf(path, "/dev/fd/%i", fd);
+	if (r = open(path, oflag), r < 0)
+		return -1;
+	if (DUP2_AND_CLOSE(r, fd) == -1)
+		return S(close(r)), -1;
+	return 0;
+}
+
+
+/**
+ * Run a job or a hook.
+ * 
+ * @param   job   The job.
+ * @param   hook  The hook, `NULL` to run the job.
+ * @return        0 on success, -1 on error, 1 if the child failed.
+ */
+int
+run_job_or_hook(struct job *job, const char *hook)
+{
+	pid_t pid;
+	char **args = NULL;
+	char **argv = NULL;
+	char **envp = NULL;
+	size_t argsn;
+	void *new;
+	int status = 0, saved_errno;
+
+	t (!(args = restore_array(job->payload, job->n, &argsn)));
+	t (!(argv = sublist(args, (size_t)(job->argc))));
+	t (!(envp = sublist(args + job->argc, argsn - (size_t)(job->argc)))); /* Includes wdir. */
+	free(args), args = NULL;
+
+	if (hook) {
+		t (!(new = realloc(argv, ((size_t)(job->argc) + 3) * sizeof(*argv))));
+		argv = new;
+		memmove(argv + 2, argv, ((size_t)(job->argc) + 1) * sizeof(*argv));
+		argv[0] = getenv("SAT_HOOK_PATH");
+		argv[1] = (strstr)(hook, hook); /* strstr: just to remove a warning */
+	}
+
+	if (!(pid = fork())) {
+		close(STATE_FILENO), close(BOOT_FILENO), close(REAL_FILENO);
+		(void)(status = chdir(envp[0]));
+		environ = envp + 1;
+		execvp(*argv, argv);
+		exit(1);
+	}
+
+	t ((pid < 0) || (waitpid(pid, &status, 0) != pid));
+fail:
+	S(free(args), free(argv), free(envp));
+	return status ? 1 : -!!saved_errno;
+}
+
+
+/**
+ * Removes (and optionally runs) a job.
+ * 
+ * @param   jobno   The job number, `NULL` for any job.
+ * @param   runjob  Shall we run the job too? 2 if its time has expired (not forced).
+ * @return          0 on success, -1 on error.
+ * 
+ * @throws  0  The job is not in the queue.
+ */
+int
+remove_job(const char *jobno, int runjob)
+{
+	char *end;
+	char *buf = NULL;
+	size_t no = 0, off = sizeof(size_t), n;
+	ssize_t r;
+	struct stat attr;
+	struct job job;
+	struct job *job_full = NULL;
+	int rc = 0, saved_errno = 0;
+
+	if (jobno) {
+		no = (errno = 0, strtoul)(jobno, &end, 10);
+		if (errno || *end || !isdigit(*jobno))
+			return 0;
+	}
+
+	t (flock(STATE_FILENO, LOCK_EX));
+	t (fstat(STATE_FILENO, &attr));
+	for (n = (size_t)(attr.st_size); off < n; off += sizeof(job) + job.n) {
+		t (preadn(STATE_FILENO, &job, sizeof(job), off) < (ssize_t)sizeof(job));
+		if (!jobno || (job.no == no))
+			goto found_it;
+	}
+	flock(STATE_FILENO, LOCK_UN); /* Failure isn't fatal. */
+	return errno = 0, -1;
+
+found_it:
+	t (!(job_full = malloc(sizeof(job) + job.n)));
+	*job_full = job;
+	t (preadn(STATE_FILENO, job_full->payload, job.n, off + sizeof(job)) < (ssize_t)(job.n));
+	n -= off + sizeof(job) + job.n;
+	t (!(buf = malloc(n)));
+	t (r = preadn(STATE_FILENO, buf, n, off + sizeof(job) + job.n), r < 0);
+	t (pwriten(STATE_FILENO, buf, (size_t)r, off) < 0);
+	t (ftruncate(STATE_FILENO, (off_t)r + (off_t)off));
+	free(buf), buf = NULL;
+	fsync(STATE_FILENO);
+
+	if (runjob) {
+		run_job_or_hook(job_full, runjob == 2 ? "expired" : "forced");
+		rc = run_job_or_hook(job_full, NULL);
+		saved_errno = errno;
+		run_job_or_hook(job_full, rc ? "failure" : "success");
+		rc = rc == 1 ? 0 : rc;
+	} else {
+		run_job_or_hook(job_full, "removed");
+	}
+
+	free(job_full);
+	flock(STATE_FILENO, LOCK_UN); /* Unlock late so that hooks are synchronised. Failure isn't fatal. */
+	errno = saved_errno;
+	return rc;
+
+fail:
+	S(flock(STATE_FILENO, LOCK_UN), free(buf), free(job_full));
+	return -1;
+}
+
+
+/**
+ * Get a `NULL`-terminated list of all queued jobs.
+ * 
+ * @return  A `NULL`-terminated list of all queued jobs. `NULL` on error.
+ */
+struct job **
+get_jobs(void)
+{
+	size_t off = sizeof(size_t), n, j = 0;
+	struct stat attr;
+	struct job **js = NULL;
+	struct job job;
+	int saved_errno;
+
+	t (flock(STATE_FILENO, LOCK_SH));
+	t (fstat(STATE_FILENO, &attr));
+	n = (size_t)(attr.st_size);
+	t (!(js = malloc((n / sizeof(**js) + 1) * sizeof(*js))));
+	while (off < n) {
+		t (preadn(STATE_FILENO, &job, sizeof(job), off) < (ssize_t)sizeof(job));
+		off += sizeof(job);
+		t (!(js[j] = malloc(sizeof(job) + job.n)));
+		*(js[j]) = job;
+		t (preadn(STATE_FILENO, js[j++]->payload, job.n, off) < (ssize_t)(job.n));
+		off += job.n;
+	}
+	t (flock(STATE_FILENO, LOCK_UN));
+	return js[j] = NULL, js;
+
+fail:
+	saved_errno = errno;
+	flock(STATE_FILENO, LOCK_UN);
+	while (j--)  free(js[j]);
+	free(js);
+	errno = saved_errno;
+	return NULL;
+}
+
+
+/**
+ * Duplicate a file descriptor, and
+ * open /dev/null to the old file descriptor.
+ * However, if `old` is 3 or greater, it will
+ * be closed rather than /dev/null.
+ * 
+ * @param   old  The old file descriptor.
+ * @param   new  The new file descriptor.
+ * @return       `new`, -1 on error.
+ */
+int
+dup2_and_null(int old, int new)
+{
+	int fd = -1, saved_errno;
+
+	if (old == new)  return new;  t (DUP2_AND_CLOSE(old, new));
+	if (old >= 3)    return new;  t (fd = open("/dev/null", O_RDWR), fd == -1);
+	if (fd == old)   return new;  t (DUP2_AND_CLOSE(fd, old));
+	return new;
+fail:
+	return S(close(fd)), -1;
+}
+
+
+/**
+ * Create or open the state file.
+ * 
+ * @param   open_flags  Flags (the second parameter) for `open`.
+ * @param   state_path  Output parameter for the state file's pathname.
+ *                      May be `NULL`;
+ * @return              A file descriptor to the state file, -1 on error.
+ * 
+ * @throws  0  `!(open_flags & O_CREAT)` and the file does not exist.
+ */
+int
+open_state(int open_flags, char **state_path)
+{
+	const char *dir;
+	char *path;
+	int fd = -1, saved_errno;
+
+	/* Create directory. */
+	dir = getenv("XDG_RUNTIME_DIR"), dir = (dir ? dir : "/run");
+	t (!(path = malloc(strlen(dir) * sizeof(char) + sizeof("/" PACKAGE "/state"))));
+	stpcpy(stpcpy(path, dir), "/" PACKAGE "/state");
+	t (fd = open(path, open_flags, S_IRUSR | S_IWUSR), fd == -1);
+
+	if (state_path)  *state_path = path, path = NULL;
+	else             free(path), path = NULL;
+fail:
+	S(free(path));
+	if (!(open_flags & O_CREAT) && ((errno == ENOENT) || (errno == ENOTDIR)))
+		errno = 0;
+	return fd;
+}
+
+
+/**
+ * Let the daemon know that it may need to
+ * update the timers, and perhaps exit.
+ * 
+ * @param   start  Start the daemon if it is not running?
+ * @param   name   The name of the process.
+ * @return         0 on success, -1 on error.
+ */
+int
+poke_daemon(int start, const char *name)
+{
+	char *path = NULL;
+	const char *dir;
+	pid_t pid;
+	int fd = -1, status, saved_errno;
+
+	/* Get the lock file's pathname. */
+	dir = getenv("XDG_RUNTIME_DIR"), dir = (dir ? dir : "/run");
+	t (!(path = malloc(strlen(dir) * sizeof(char) + sizeof("/" PACKAGE "/lock"))));
+	stpcpy(stpcpy(path, dir), "/" PACKAGE "/lock");
+
+	/* Any daemon listening? */
+	fd = open(path, O_RDONLY);
+	if (fd == -1) {
+		t ((errno != ENOENT) && (errno != ENOTDIR));
+	} else {
+		if (flock(fd, LOCK_SH | LOCK_NB /* and LOCK_DRY if that was ever added... */))
+			t (start = 0, errno != EWOULDBLOCK);
+		else
+			flock(fd, LOCK_UN);
+		t (read(fd, &pid, sizeof(pid)) < (ssize_t)sizeof(pid));
+		close(fd), fd = -1;
+	}
+
+	/* Start daemon if not running, otherwise poke it. */
+	if (start) {
+		switch ((pid = fork())) {
+		case -1:
+			goto fail;
+		case 0:
+			execl(BINDIR "/satd", BINDIR "/satd", NULL);
+			perror(name);
+			exit(1);
+		default:
+			t (waitpid(pid, &status, 0) != pid);
+			t (errno = 0, status);
+			break;
+		}
+	} else {
+		t (kill(pid, SIGCHLD));
+	}
+
+	return 0;
+fail:
+	return S(close(fd), free(path)), -1;
+}
+
+
+/**
+ * Construct the pathname for the hook script.
+ * 
+ * @param   env     The environment variable to use for the beginning
+ *                  of the pathname, `NULL` for the home directory.
+ * @param   suffix  The rest of the pathname.
+ * @return          The pathname.
+ * 
+ * @throws  0  The environment variable is not set, or, if `env` is
+ *             `NULL` the user is root or homeless.
+ */
+static char *
+hookpath(const char *env, const char *suffix)
+{
+	struct passwd *pwd;
+	const char *prefix = NULL;
+	char *path;
+
+	if (env) {
+		prefix = getenv(env);
+	} else if (getuid()) {
+		pwd = getpwuid(getuid());
+		prefix = pwd ? pwd->pw_dir : NULL;
+	}
+	if (!prefix || !*prefix)
+		return errno = 0, NULL;
+
+	t (!(path = malloc((strlen(prefix) + strlen(suffix) + 1) * sizeof(char))));
+	stpcpy(stpcpy(path, prefix), suffix);
+fail:
+	return path;
+}
+
+
+/**
+ * Set SAT_HOOK_PATH.
+ * 
+ * @return  0 on success, -1 on error.
+ */
+int
+set_hookpath(void)
+{
+#define HOOKPATH(PRE, SUF)  \
+	t (path = path ? path : hookpath(PRE, SUF), !path && errno)
+	char *path = NULL;
+	int saved_errno;
+	if (!getenv("SAT_HOOK_PATH")) {
+		HOOKPATH("XDG_CONFIG_HOME", "/sat/hook");
+		HOOKPATH("HOME", "/.config/sat/hook");
+		HOOKPATH(NULL, "/.config/sat/hook");
+		t (setenv("SAT_HOOK_PATH", path ? path : "/etc/sat/hook", 1));
+	}
+	return free(path), 0;
+fail:
+	return S(free(path)), -1;
+}
+