xref: /dflybsd-src/usr.bin/dsynth/subs.c (revision a361ab312536a661d74caf5630c7ae20bcd8e3e4)

/*
 * Copyright (c) 2019-2020 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * This code uses concepts and configuration based on 'synth', by
 * John R. Marino <draco@marino.st>, which was written in ada.
 *
 * 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 DragonFly Project 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 COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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 "dsynth.h"

struct logerrinfo {
	struct logerrinfo *next;
	char	*logid;
	pid_t	pid;
	long	seq;
	int	exited;
};

buildenv_t *BuildEnv;
static buildenv_t **BuildEnvTail = &BuildEnv;

extern char **environ;

static void *dexec_logerr_thread(void *info);

#define EINFO_HSIZE	1024
#define EINFO_HMASK	(EINFO_HSIZE - 1)

static struct logerrinfo *EInfo[EINFO_HSIZE];
static pthread_t ETid;
static int EFds[2];
static pthread_cond_t ECond;

static __inline
struct logerrinfo **
einfohash(pid_t pid)
{
	return(&EInfo[pid & EINFO_HMASK]);
}

__dead2 void
_dfatal(const char *file __unused, int line __unused, const char *func,
	int do_errno, const char *ctl, ...)
{
	va_list va;

	fprintf(stderr, "%s: ", func);
	va_start(va, ctl);
	vfprintf(stderr, ctl, va);
	va_end(va);
	if (do_errno & 1)
		fprintf(stderr, ": %s", strerror(errno));
	fprintf(stderr, "\n");
	fflush(stderr);

	if (do_errno & 2)
		kill(getpid(), SIGQUIT);
	exit(1);
}

void
_ddprintf(int tab, const char *ctl, ...)
{
	va_list va;

	if (tab)
		printf("%*.*s", tab, tab, "");
	va_start(va, ctl);
	vfprintf(stdout, ctl, va);
	va_end(va);
}

char *
strdup_or_null(char *str)
{
	if (str && str[0])
		return(strdup(str));
	return NULL;
}

static const char *DLogNames[] = {
	"00_last_results.log",
	"01_success_list.log",
	"02_failure_list.log",
	"03_ignored_list.log",
	"04_skipped_list.log",
	"05_abnormal_command_output.log",
	"06_obsolete_packages.log",
	"07_debug.log",
};

static int DLogFd[DLOG_COUNT];
static pthread_mutex_t DLogFdMutex;

#define arysize(ary)	(sizeof((ary)) / sizeof((ary)[0]))

static int
dlogfd(int which, int modes)
{
	char *path;
	int fd;

	which &= DLOG_MASK;
	if ((fd = DLogFd[which]) > 0)
		return fd;
	pthread_mutex_lock(&DLogFdMutex);
	if ((fd = DLogFd[which]) <= 0) {
		asprintf(&path, "%s/%s", LogsPath, DLogNames[which]);
		fd = open(path, modes, 0666);
		DLogFd[which] = fd;
		free(path);
	}
	pthread_mutex_unlock(&DLogFdMutex);

	return fd;
}


void
dlogreset(void)
{
	int i;

	ddassert(DLOG_COUNT == arysize(DLogNames));
	for (i = 0; i < DLOG_COUNT; ++i) {
		if (DLogFd[i] > 0) {
			close(DLogFd[i]);
			DLogFd[i] = -1;
		}
		(void)dlogfd(i, O_RDWR|O_CREAT|O_TRUNC|O_APPEND);
	}
}

void
_dlog(int which, const char *ctl, ...)
{
	va_list va;
	char *buf;
	char *ptr;
	size_t len;
	int fd;
	int filter;

	filter = which;
	which &= DLOG_MASK;

	ddassert((uint)which < DLOG_COUNT);
	va_start(va, ctl);
	vasprintf(&buf, ctl, va);
	va_end(va);
	len = strlen(buf);

	/*
	 * The special sequence ## right-justfies the text after the ##.
	 *
	 * NOTE: Alignment test includes \n so use 80 instead of 79 to
	 *	 leave one char unused on a 80-column terminal.
	 */
	if ((ptr = strstr(buf, "##")) != NULL) {
		size_t l2;
		size_t l1;
		char *b2;
		int spc;

		l1 = (int)(ptr - buf);
		l2 = len - l1 - 2;
		if (l1 <= 80 - l2) {
			spc = 80 - l1 - l2;
			buf[l1] = 0;
			asprintf(&b2, "%s%*.*s%s",
				 buf, spc, spc, "", ptr + 2);
		} else {
			buf[l1] = 0;
			asprintf(&b2, "%s%s", buf, ptr + 2);
		}
		len = strlen(b2);
		free(buf);
		buf = b2;
	}

	/*
	 * All logs also go to log 00.
	 */
	if (which != DLOG_ALL) {
		fd = dlogfd(DLOG_ALL, O_RDWR|O_CREAT|O_APPEND);
		if (fd > 0)
			write(fd, buf, len);
	}

	/*
	 * Nominal log target
	 */
	fd = dlogfd(which, O_RDWR|O_CREAT|O_APPEND);
	write(fd, buf, len);

	/*
	 * If ncurses is not being used, all log output also goes
	 * to stdout, unless filtered.
	 */
	if ((UseNCurses == 0 || (filter & DLOG_STDOUT)) &&
	    (filter & DLOG_FILTER) == 0) {
		if (ColorOpt) {
			if (filter & DLOG_GRN)
				write(1, "\x1b[0;32m", 7);
			if (filter & DLOG_RED)
				write(1, "\x1b[0;31m", 7);
		}
		write(1, buf, len);
		if (ColorOpt && (filter & (DLOG_GRN|DLOG_RED))) {
			write(1, "\x1b[0;39m", 7);
		}
	}
	free(buf);
}

int
dlog00_fd(void)
{
	return(dlogfd(DLOG_ALL, O_RDWR|O_CREAT|O_APPEND));
}

/*
 * Bulk and Build environment control.  These routines are only called
 * unthreaded or when dsynth threads are idle.
 */
void
addbuildenv(const char *label, const char *data, int type)
{
	buildenv_t *env;

	env = calloc(1, sizeof(*env));
	env->a1 = strdup(label);
	env->a2 = strdup(data);
	env->label = env->a1;
	env->data = env->a2;
	env->type = type;
	*BuildEnvTail = env;
	BuildEnvTail = &env->next;
}

void
delbuildenv(const char *label)
{
	buildenv_t **envp;
	buildenv_t *env;

	envp = &BuildEnv;
	while ((env = *envp) != NULL) {
		if (strcmp(env->label, label) == 0) {
			*envp = env->next;
			if (env->a1)
				free(env->a1);
			if (env->a2)
				free(env->a2);
			free(env);
		} else {
			envp = &env->next;
		}
	}
	BuildEnvTail = envp;
}

const char *
getbuildenv(const char *label)
{
	buildenv_t **envp;
	buildenv_t *env;

	envp = &BuildEnv;
	while ((env = *envp) != NULL) {
		if (strcmp(env->label, label) == 0)
			return env->data;
		envp = &env->next;
	}
	return NULL;
}

void
freestrp(char **strp)
{
	if (*strp) {
		free(*strp);
		*strp = NULL;
	}
}

void
dupstrp(char **strp)
{
	if (*strp)
		*strp = strdup(*strp);
}

int
ipcreadmsg(int fd, wmsg_t *msg)
{
	size_t res;
	ssize_t r;
	char *ptr;

	res = sizeof(*msg);
	ptr = (char *)(void *)msg;
	while (res) {
		r = read(fd, ptr, res);
		if (r <= 0) {
			if (errno == EINTR)
				continue;
			return -1;
		}
		res -= (size_t)r;
		ptr += r;
	}
	return 0;
}

int
ipcwritemsg(int fd, wmsg_t *msg)
{
	size_t res;
	ssize_t r;
	char *ptr;

	res = sizeof(*msg);
	ptr = (char *)(void *)msg;
	while (res) {
		r = write(fd, ptr, res);
		if (r < 0) {
			if (errno == EINTR)
				continue;
			return -1;
		}
		res -= (size_t)r;
		ptr += r;
	}
	return 0;
}

int
askyn(const char *ctl, ...)
{
	va_list va;
	char buf[256];
	int res = 0;

	if (YesOpt)
		return 1;

	for (;;) {
		va_start(va, ctl);
		vprintf(ctl, va);
		va_end(va);
		fflush(stdout);
		if (fgets(buf, sizeof(buf), stdin) == NULL)
			break;
		if (buf[0] == 'y' || buf[0] == 'Y') {
			res = 1;
			break;
		}
		if (buf[0] == 'n' || buf[0] == 'N') {
			res = 0;
			break;
		}
		printf("Please type y/n\n");
	}
	return res;
}

/*
 * Get swap% used 0.0-1.0.
 *
 * NOTE: This routine is intended to return quickly.
 *
 * NOTE: swap_cache (caching for hard drives) is persistent and should
 *	 not be counted for our purposes.
 */
double
getswappct(int *noswapp)
{
	long swap_size = 0;
	long swap_anon = 0;
	long swap_cache __unused = 0;
	size_t len;
	double dswap;

	len = sizeof(swap_size);
	sysctlbyname("vm.swap_size", &swap_size, &len, NULL, 0);
	len = sizeof(swap_size);
	sysctlbyname("vm.swap_anon_use", &swap_anon, &len, NULL, 0);
	len = sizeof(swap_size);
	sysctlbyname("vm.swap_cache_use", &swap_cache, &len, NULL, 0);
	if (swap_size) {
		dswap = (double)(swap_anon /*+swap_cache*/) / (double)swap_size;
		*noswapp = 0;
	} else {
		dswap = 0.0;
		*noswapp = 1;
	}
	return dswap;
}

/*
 * dexec_open()/fgets/dexec_close()
 *
 * Similar to popen() but directly exec()s the argument list (cav[0] must
 * be an absolute path).
 *
 * If xenv is non-NULL its an array of local buildenv_t's to be used.
 * The array is terminated with a NULL xenv->label.
 *
 * If with_env is non-zero the configured environment is included.
 *
 * If with_mvars is non-zero the make environment is passed as VAR=DATA
 * elements on the command line.
 */
FILE *
dexec_open(const char *logid, const char **cav, int cac,
	   pid_t *pidp, buildenv_t *xenv, int with_env, int with_mvars)
{
	buildenv_t *benv;
	const char **cenv;
	char *allocary[MAXCAC*2];
	int env_basei;
	int envi;
	int alloci;
	int nullfd;
	int fds[2];	/* stdout */
	pid_t pid;
	FILE *fp;
	struct logerrinfo *einfo;
	static int warned;

	/*
	 * Error logging thread setup
	 */
	if (ETid == 0) {
		pthread_mutex_lock(&DLogFdMutex);
		if (ETid == 0) {
			if (socketpair(AF_UNIX, SOCK_DGRAM, 0, EFds) < 0)
				dfatal_errno("socketpair");
#ifdef SO_PASSCRED
			int optval = 1;
			if (setsockopt(EFds[0], SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval)) < 0) {
				if (warned == 0) {
					warned = 1;
					fprintf(stderr, "SO_PASSCRED not supported\n");
				}
			}
#endif

			pthread_cond_init(&ECond, NULL);
			pthread_create(&ETid, NULL, dexec_logerr_thread, NULL);
		}
		pthread_mutex_unlock(&DLogFdMutex);
	}

	env_basei = 0;
#if 0
	/*
	 * For now we are ignoring the passed-in environment, so don't
	 * copy the existing environment into the exec environment.
	 */
	while (environ[env_basei])
		++env_basei;
#endif
	cenv = calloc(env_basei + MAXCAC, sizeof(char *));
	for (envi = 0; envi < env_basei; ++envi)
		cenv[envi] = environ[envi];

	alloci = 0;
	for (benv = BuildEnv; benv; benv = benv->next) {
		if (with_mvars &&
		    (benv->type & BENV_CMDMASK) == BENV_MAKECONF) {
			asprintf(&allocary[alloci], "%s=%s",
				 benv->label, benv->data);
			cav[cac++] = allocary[alloci];
			++alloci;
		}
		if (with_env &&
		    (benv->type & BENV_PKGLIST) &&
		    (benv->type & BENV_CMDMASK) == BENV_ENVIRONMENT) {
			asprintf(&allocary[alloci], "%s=%s",
				 benv->label, benv->data);
			cenv[envi++] = allocary[alloci];
			++alloci;
		}
		ddassert(cac < MAXCAC && envi - env_basei < MAXCAC);
	}

	/*
	 * Extra environment specific to this particular dexec
	 */
	while (xenv && xenv->label) {
		asprintf(&allocary[alloci], "%s=%s",
			 xenv->label, xenv->data);
		cenv[envi++] = allocary[alloci];
		++alloci;
		++xenv;
	}

	cav[cac] = NULL;
	cenv[envi] = NULL;

	if (pipe2(fds, O_CLOEXEC) < 0)
		dfatal_errno("pipe");
	nullfd = open("/dev/null", O_RDWR | O_CLOEXEC);
	if (nullfd < 0)
		dfatal_errno("open(\"/dev/null\")");

	/*
	 * We have to be very careful using vfork(), do only the bare
	 * minimum necessary in the child to set it up and exec it.
	 */
	pid = vfork();
	if (pid == 0) {
#if 0
		int i;
		printf("%s", cav[0]);
		for (i = 0; cav[i]; ++i)
			printf(" %s", cav[i]);
		printf("\n");
		printf("ENV: ");
		for (i = 0; cenv[i]; ++i)
			printf(" %s", cenv[i]);
#endif

		if (fds[1] != 1) {
			dup2(fds[1], 1);
			close(fds[1]);
		}
		if (EFds[1] != 2) {
			dup2(EFds[1], 2);
			close(EFds[1]);
		}
		close(fds[0]);		/* safety */
		close(EFds[0]);		/* safety */
		dup2(nullfd, 0);	/* no questions! */
		closefrom(3);		/* be nice */

		/*
		 * Self-nice to be nice (ignore any error)
		 */
		if (NiceOpt)
			setpriority(PRIO_PROCESS, 0, NiceOpt);

		/*
		 * Throw in some capability restrictions
		 */
		set_capability_restrictions();

		execve(cav[0], (void *)cav, (void *)cenv);
		write(2, "EXEC FAILURE\n", 13);
		_exit(1);
	}
	close(nullfd);
	close(fds[1]);
	if (pid < 0) {
		close(fds[0]);
		dfatal_errno("vfork failed");
	}
	fp = fdopen(fds[0], "r");
	*pidp = pid;

	/*
	 * einfo setup
	 */
	einfo = calloc(1, sizeof(*einfo));
	if (logid)
		einfo->logid = strdup(logid);

	pthread_mutex_lock(&DLogFdMutex);
	einfo->pid = pid;
	einfo->next = *einfohash(pid);
	*einfohash(pid) = einfo;
	pthread_cond_signal(&ECond);
	pthread_mutex_unlock(&DLogFdMutex);

	while (--alloci >= 0)
		free(allocary[alloci]);
	free(cenv);

	return fp;
}

int
dexec_close(FILE *fp, pid_t pid)
{
	struct logerrinfo **einfop;
	struct logerrinfo *einfo;
	pid_t rpid;
	int status;

	fclose(fp);
	while ((rpid = waitpid(pid, &status, 0)) != pid) {
		if (rpid < 0) {
			if (errno == EINTR)
				continue;
			return 1;
		}
	}

	pthread_mutex_lock(&DLogFdMutex);
	einfop = einfohash(pid);
	while ((einfo = *einfop) != NULL) {
		if (einfo->pid == pid) {
			einfo->exited = 1;
			break;
		}
		einfop = &einfo->next;
	}
	pthread_mutex_unlock(&DLogFdMutex);

	return (WEXITSTATUS(status));
}

static void *
dexec_logerr_thread(void *dummy __unused)
{
	char buf[4096];
	union {
		char cbuf[CMSG_SPACE(sizeof(struct ucred))];
		struct cmsghdr cbuf_align;
	} cmsg_buf;
	struct cmsghdr *cmsg;
	struct logerrinfo **einfop;
	struct logerrinfo *einfo;
	struct msghdr msg;
	struct iovec iov;
	ssize_t len;
	int mflags = MSG_DONTWAIT;
	int fd;

	pthread_detach(pthread_self());

	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_iov = &iov;

	msg.msg_control = cmsg_buf.cbuf;
	msg.msg_controllen = sizeof(cmsg_buf.cbuf);

	fd = EFds[0];
	for (;;) {
		int i;

		msg.msg_iovlen = 1;
		iov.iov_base = buf;
		iov.iov_len = sizeof(buf) - 1;

		/*
		 * Wait for message, if none are pending then clean-up
		 * exited einfos (this ensures that we have flushed all
		 * error output before freeing the structure).
		 *
		 * Don't obtain the mutex until we really need it.  The
		 * parent thread can only 'add' einfo entries to the hash
		 * table so we are basically scan-safe.
		 */
		len = recvmsg(fd, &msg, mflags);
		if (len < 0) {
			if (errno != EAGAIN) {	/* something messed up */
				fprintf(stderr, "ERRNO %d\n", errno);
				break;
			}

			for (i = 0; i < EINFO_HSIZE; ++i) {
				einfo = EInfo[i];
				while (einfo) {
					if (einfo->exited)
						break;
					einfo = einfo->next;
				}
				if (einfo == NULL)
					continue;
				pthread_mutex_lock(&DLogFdMutex);
				einfop = &EInfo[i];
				while ((einfo = *einfop) != NULL) {
					if (einfo->exited) {
						*einfop = einfo->next;
						if (einfo->logid)
							free(einfo->logid);
						free(einfo);
					} else {
						einfop = &einfo->next;
					}
				}
				pthread_mutex_unlock(&DLogFdMutex);
			}
			mflags = 0;
			continue;
		}

		/*
		 * Process SCM_CREDS, if present.  Throw away SCM_RIGHTS
		 * if some sub-process stupidly sent it.
		 */
		einfo = NULL;
		mflags = MSG_DONTWAIT;

		if (len && buf[len-1] == '\n')
			--len;
		buf[len] = 0;

		for (cmsg = CMSG_FIRSTHDR(&msg);
		     cmsg;
		     cmsg = CMSG_NXTHDR(&msg, cmsg)) {
			struct cmsgcred *cred;
			int *fds;
			int n;

			if (cmsg->cmsg_level != SOL_SOCKET)
				continue;

			switch(cmsg->cmsg_type) {
			case SCM_CREDS:

				cred = (void *)CMSG_DATA(cmsg);

				einfo = *einfohash(cred->cmcred_pid);
				while (einfo && einfo->pid != cred->cmcred_pid)
					einfo = einfo->next;
				break;
			case SCM_RIGHTS:
				fds = (void *)CMSG_DATA(cmsg);
				n = (cmsg->cmsg_len - sizeof(cmsg)) /
				    sizeof(int);
				for (i = 0; i < n; ++i)
					close(fds[i]);
				break;
			}
		}

		if (einfo && einfo->logid) {
			dlog(DLOG_ALL | DLOG_STDOUT,
			     "%s: %s\n",
			     einfo->logid, buf);
		} else {
			dlog(DLOG_ALL | DLOG_STDOUT, "%s", buf);
		}
	}
	return NULL;
}

const char *
getphasestr(worker_phase_t phaseid)
{
	const char *phase;

	switch(phaseid) {
	case PHASE_PENDING:
		phase = "pending";
		break;
	case PHASE_INSTALL_PKGS:
		phase = "install-pkgs";
		break;
	case PHASE_CHECK_SANITY:
		phase = "check-sanity";
		break;
	case PHASE_PKG_DEPENDS:
		phase = "pkg-depends";
		break;
	case PHASE_FETCH_DEPENDS:
		phase = "fetch-depends";
		break;
	case PHASE_FETCH:
		phase = "fetch";
		break;
	case PHASE_CHECKSUM:
		phase = "checksum";
		break;
	case PHASE_EXTRACT_DEPENDS:
		phase = "extract-depends";
		break;
	case PHASE_EXTRACT:
		phase = "extract";
		break;
	case PHASE_PATCH_DEPENDS:
		phase = "patch-depends";
		break;
	case PHASE_PATCH:
		phase = "patch";
		break;
	case PHASE_BUILD_DEPENDS:
		phase = "build-depends";
		break;
	case PHASE_LIB_DEPENDS:
		phase = "lib-depends";
		break;
	case PHASE_CONFIGURE:
		phase = "configure";
		break;
	case PHASE_BUILD:
		phase = "build";
		break;
	case PHASE_RUN_DEPENDS:
		phase = "run-depends";
		break;
	case PHASE_STAGE:
		phase = "stage";
		break;
	case PHASE_TEST:
		phase = "test";
		break;
	case PHASE_CHECK_PLIST:
		phase = "check-plist";
		break;
	case PHASE_PACKAGE:
		phase = "package";
		break;
	case PHASE_INSTALL:
		phase = "install";
		break;
	case PHASE_DEINSTALL:
		phase = "deinstall";
		break;
	case PHASE_DUMP_ENV:
		phase = "dump-env";
		break;
	case PHASE_DUMP_VAR:
		phase = "dump-var";
		break;
	case PHASE_SHOW_CONFIG:
		phase = "show-config";
		break;
	case PHASE_DUMP_MAKECONF:
		phase = "make-conf";
		break;
	default:
		phase = "Run-Unknown";
		break;
	}
	return phase;
}

int
readlogline(monitorlog_t *log, char **bufp)
{
	int r;
	int n;

	/*
	 * Reset buffer as an optimization to avoid unnecessary
	 * shifts.
	 */
	*bufp = NULL;
	if (log->buf_beg == log->buf_end) {
		log->buf_beg = 0;
		log->buf_end = 0;
		log->buf_scan = 0;
	}

	/*
	 * Look for newline, handle discard mode
	 */
again:
	for (n = log->buf_scan; n < log->buf_end; ++n) {
		if (log->buf[n] == '\n') {
			*bufp = log->buf + log->buf_beg;
			r = n - log->buf_beg;
			log->buf_beg = n + 1;
			log->buf_scan = n + 1;

			if (log->buf_discard_mode == 0)
				return r;
			log->buf_discard_mode = 0;
			goto again;
		}
	}

	/*
	 * Handle overflow
	 */
	if (n == sizeof(log->buf)) {
		if (log->buf_beg) {
			/*
			 * Shift the buffer to make room and read more data.
			 */
			bcopy(log->buf + log->buf_beg,
			      log->buf,
			      n - log->buf_beg);
			log->buf_end -= log->buf_beg;
			log->buf_scan -= log->buf_beg;
			n -= log->buf_beg;
			log->buf_beg = 0;
		} else if (log->buf_discard_mode) {
			/*
			 * Overflow.  If in discard mode just throw it all
			 * away.  Stay in discard mode.
			 */
			log->buf_beg = 0;
			log->buf_end = 0;
			log->buf_scan = 0;
		} else {
			/*
			 * Overflow.  If not in discard mode return a truncated
			 * line and enter discard mode.
			 *
			 * The caller will temporarily set ptr[r] = 0 so make
			 * sure that does not overflow our buffer as we are not
			 * at a newline.
			 *
			 * (log->buf_beg is 0);
			 */
			*bufp = log->buf + log->buf_beg;
			r = n - 1;
			log->buf_beg = n;
			log->buf_scan = n;
			log->buf_discard_mode = 1;

			return r;
		}
	}

	/*
	 * Read more data.  If there is no data pending then return -1,
	 * otherwise loop up to see if more complete line(s) are available.
	 */
	r = pread(log->fd,
		  log->buf + log->buf_end,
		  sizeof(log->buf) - log->buf_end,
		  log->offset);
	if (r <= 0)
		return -1;
	log->offset += r;
	log->buf_end += r;
	goto again;
}

uint32_t
crcDirTree(const char *path)
{
	FTS *fts;
	FTSENT *fen;
	struct stat *st;
	char *pav[2];
	uint32_t crc;
	uint32_t val;

	crc = 0;
	pav[0] = strdup(path);
	pav[1] = NULL;

	fts = fts_open(pav, FTS_PHYSICAL | FTS_NOCHDIR, NULL);
	if (fts == NULL)
		goto failed;
	while ((fen = fts_read(fts)) != NULL) {
		if (fen->fts_info != FTS_F && fen->fts_info != FTS_SL)
			continue;
		/*
		 * Ignore hidden dot files or ones ending with .core from the
		 * calculated CRC sum to prevent unnecessary rebuilds.
		 */
		if (fen->fts_name[0] == '.')
			continue;
		if (fen->fts_namelen >= 5 &&
		    !strcmp(fen->fts_name + fen->fts_namelen - 5, ".core")) {
			continue;
		}

		st = fen->fts_statp;

		val = iscsi_crc32(&st->st_mtime, sizeof(st->st_mtime));
		val = iscsi_crc32_ext(&st->st_size, sizeof(st->st_size), val);
		val = iscsi_crc32_ext(fen->fts_path, fen->fts_pathlen, val);
		crc ^= val;
	}
	fts_close(fts);
failed:
	free(pav[0]);

	return crc;
}

void
set_capability_restrictions(void)
{
	if (CapabilityRestrictions) {
#if !defined(SYSCAP_UNAVAILABLE)
		syscap_set(SYSCAP_RESTRICTEDROOT, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_SENSITIVEROOT, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_NONET_SENSITIVE, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_NOVFS_SENSITIVE, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_NOMOUNT, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_NOJAIL, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_NONET_RESPORT, __SYSCAP_ALL,
			   NULL, 0);
		syscap_set(SYSCAP_NONET_RAW, __SYSCAP_ALL,
			   NULL, 0);
#endif
	}
}