proc.c

/***********************************************************************
*                                                                      *
*               This software is part of the BSD package               *
*Copyright (c) 1978-2009 The Regents of the University of California an*
*                                                                      *
* 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 Regents of the University of California*
*       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 OWNER 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.                                          *
*                                                                      *
* 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.                                                         *
*                                                                      *
*                          Kurt Shoens (UCB)                           *
*                                 gsf                                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Mail -- a mail program
 *
 * Process control.
 */

#include "mailx.h"

#define READ 0
#define WRITE 1

static void
register_file(FILE* fp, int pid)
{
	struct file*	fpp;

	if (!(fpp = (struct file*)malloc(sizeof *fpp)))
		note(PANIC, "Out of space");
	fpp->fp = fp;
	fpp->pid = pid;
	fpp->link = state.files;
	state.files = fpp;
}

/*
 * return std stream for file,mode
 * 0 if no match
 */

FILE*
filestd(char* file, char* mode)
{
	if (*mode == 'r') {
		if (streq(file, "-") || streq(file, "/dev/stdin") || streq(file, "/dev/fd/0"))
			return stdin;
	}
	else if (*mode == 'w') {
		if (streq(file, "-") || streq(file, "/dev/stdout") || streq(file, "/dev/fd/1"))
			return stdout;
		else if (streq(file, "/dev/stderr") || streq(file, "/dev/fd/2"))
			return stderr;
	}
	return 0;
}

/*
 * fopen() with some extra mode prefixes:
 *
 *	E	enable error messages
 *	I	don't register_file (fclose to close)
 *	M	umask(~MAILMODE)
 *	R	file must be S_ISREG()
 *	X	expand() file name before open
 *
 * Open fd is set close-on-exec.
 */

FILE*
fileopen(char* file, char* mode)
{
	FILE*		fp;
	int		n;
	int		ignore = 0;
	int		mask = 0;
	int		regular = 0;
	int		verbose = 0;

	for (;; mode++) {
		switch (*mode) {
		case 'E':
			verbose = 1;
			continue;
		case 'I':
			ignore = 1;
			continue;
		case 'M':
			mask = 1;
			continue;
		case 'R':
			regular = 1;
			continue;
		case 'X':
			if (!(file = expand(file, 1)))
				return 0;
			continue;
		}
		break;
	}
	if (fp = filestd(file, mode))
		return fp;
	if (mask)
		n = umask(~MAILMODE);
	fp = fopen(file, mode);
	if (mask) {
		umask(n);
		if (state.readonly && streq(mode, "w"))
			chmod(file, S_IRUSR);
	}
	if (fp) {
		if (fstat(fileno(fp), &state.openstat)) {
			fclose(fp);
			if (verbose)
				note(SYSTEM, "%s", file);
			return 0;
		}
		if (S_ISDIR(state.openstat.st_mode)) {
			fclose(fp);
			errno = EISDIR;
			if (verbose)
				note(SYSTEM, "%s", file);
			return 0;
		}
		if (regular && !S_ISREG(state.openstat.st_mode)) {
			fclose(fp);
			errno = EFTYPE;
			if (verbose)
				note(SYSTEM, "%s", file);
			return 0;
		}
		if (!ignore)
			register_file(fp, 0);
		fcntl(fileno(fp), F_SETFD, 1);
#if 0 && MORE_DISCIPLINE
		sfsetbuf(fp, (void*)fp, SF_UNBOUND);
#endif
	}
	else if (verbose)
		note(SYSTEM, "%s", file);
	return fp;
}

/*
 * fdopen() that calls register_file()
 */

FILE*
filefd(int fd, char* mode)
{
	FILE *fp;

	if (fp = fdopen(fd, mode)) {
		register_file(fp, 0);
		fcntl(fileno(fp), F_SETFD, 1);
	}
	return fp;
}

/*
 * Generate temp file name.
 * If fd>0 then create it and return file pointer.
 * If fd>0 and buf==0 then remove after create.
 */

FILE*
filetemp(char* buf, int size, int type, int fd)
{
	register char*	s;
	register char*	b;
	register char*	e;
	FILE*		fp = 0;

	if (!(b = buf)) {
		if (fd <= 0)
			return 0;
		b = state.path.path;
		size = sizeof(state.path.path);
	}
	e = b + size - 1;
	s = strncopy(b, state.tmp.dir, e - b);
	s = strncopy(s, "Mail", e - s);
	if (s < e)
		*s++ = type;
	strncopy(s, "XXXXXX", e - s);
	if (fd) {
		fd = mkstemp(b);
		if (!buf && *b)
			remove(b);
		if (fd < 0 || !(fp = filefd(fd, "r+"))) {
			if (fd >= 0)
				close(fd);
			note(FATAL|SYSTEM|ERROR|IDENTIFY, "\"%s\": temporary file error", b);
		}
	}
	else
		mktemp(b);
	if (!*b)
		note(FATAL|SYSTEM|ERROR|IDENTIFY, "\"%s\": temporary file error", b);
	return fp;
}

/*
 * Call this after fileopen() or filefd().
 */

int
fileclose(FILE* fp)
{
	int		r;
	struct file*	p;
	struct file**	pp;

	if (fp == 0 || fp == stdin)
		return 0;
	if (fp == stdout || fp == stderr)
		return fflush(fp);
	r = 0;
	for (pp = &state.files;; pp = &p->link) {
		if (!(p = *pp)) {
			fclose(fp);
			return 0;
		}
		if (p->fp == fp) {
			r = p->pid;
			*pp = p->link;
			free(p);
			break;
		}
	}
	if (r) {
		holdsigs();
		fclose(fp);
		signal(SIGPIPE, SIG_IGN);
		r = wait_command(r);
		signal(SIGPIPE, SIG_DFL);
		relsesigs();
	}
	else
		r = fclose(fp);
	return r;
}

/*
 * fileclose() all registered files.
 */

void
fileclear(void)
{
	while (state.files)
		fileclose(state.files->fp);
}

/*
 * Copy n chars from from file ip to file op.
 * If in is specified then input error messages enabled.
 * If on is specified then output error messages enabled.
 * If lines!=0 then it will point to the copied line count.
 * If chars!=0 then it will point to the copied char count.
 * If n==0 then all chars copied.
 * If n>0 then exactly that many chars are copied.
 *
 * 0 returned on success.
 */

int
filecopy(const char* in, FILE* ip, const char* on, FILE* op, FILE* ap, register off_t n, register off_t* lines, off_t* chars, unsigned long flags)
{
	register off_t	c;
	register char*	s;
	int		r = 0;
	off_t		lc = 0;
	off_t		cc = 0;
	char		buf[LINESIZE + 1];

	buf[sizeof(buf) - 1] = 0;
	while (n >= 0) {
		if ((c = fread(buf, 1, sizeof(buf) - 1, ip)) <= 0) {
			if (c < 0) {
				r = -1;
				if (in) {
					note(SYSTEM, "%s", in);
					in = 0;
				}
			}
			break;
		}
		if (n) {
			if (n > c)
				n -= c;
			else {
				c = n;
				n = -1;
			}
		}
		if (fwrite(buf, 1, c, op) != c) {
			r = -1;
			if (on) {
				note(SYSTEM, "%s", on);
				on = 0;
			}
			break;
		}
		cc += c;
		if (ap)
			fwrite(buf, 1, c, ap);
		if (lines)
			for (s = buf; s = strchr(s, '\n'); lc++, s++);
	}
	if (flags & GNL)
		putc('\n', op);
	if (fflush(op)) {
		r = -1;
		if (on)
			note(SYSTEM, "%s", on);
	}
	if (n > 0) {
		r = -1;
		if (in)
			note(SYSTEM, "%s", in);
	}
	if (lines)
		*lines = lc;
	if (chars)
		*chars = cc;
	return r;
}

/*
 * Respond to a broken pipe signal --
 * probably caused by quitting more.
 */
static void
sigpipe(int sig)
{
	longjmp(state.jump.sigpipe, sig);
}

/*
 * popen() via register_file()
 */
FILE*
pipeopen(char* cmd, char* mode)
{
	int	myside;
	int	hisside;
	int	fd0;
	int	fd1;
	int	pid;
	FILE*	fp;
	int	p[2];
	int	background = 0;
	int	jump = 0;

	if (pipe(p) < 0)
		goto bad;
	fcntl(p[READ], F_SETFD, 1);
	fcntl(p[WRITE], F_SETFD, 1);
	for (;; mode++) {
		switch (*mode) {
		case 'J':
			jump = 1;
			continue;
		case 'N':
			background = 1;
			continue;
		}
		break;
	}
	if (*mode == 'r') {
		myside = p[READ];
		fd0 = -1;
		hisside = fd1 = p[WRITE];
	}
	else {
		myside = p[WRITE];
		hisside = fd0 = p[READ];
		fd1 = -1;
	}
	if ((pid = start_command(state.var.shell, 0, fd0, fd1, "-c", cmd, NiL)) < 0) {
		close(p[READ]);
		close(p[WRITE]);
		goto bad;
	}
	close(hisside);
	if (!(fp = fdopen(myside, mode)))
		goto bad;
	register_file(fp, background ? 0 : pid);
	if (jump && !background)
		signal(SIGPIPE, sigpipe);
	return fp;
 bad:
	note(SYSTEM, "\"%s\"", cmd);
	return 0;
}

/*
 * Run a command without a shell, with optional arguments and splicing
 * of stdin and stdout.  The command name can be a sequence of words.
 * Signals must be handled by the caller.
 * critical will mask interesting signals in the new process.
 * SIGINT is enabled if critical==0.
 */
int
run_command(char* cmd, int critical, int infd, int outfd, char* a0, char* a1, char* a2)
{
	int	pid;
	int	code;

	if ((pid = start_command(cmd, critical, infd, outfd, a0, a1, a2)) < 0)
		return -1;
	if (code = wait_command(pid)) {
		note(SYSTEM, "Fatal exit code %d from %s", code, cmd);
		return -1;
	}
	return 0;
}

extern pid_t	spawnvp(const char*, char* const*);	/* ast obsolete, but so is mailx, sort of */

int
start_command(char* cmd, int critical, int infd, int outfd, char* a0, char* a1, char* a2)
{
	int		pid;
	int		savein;
	int		saveout;
	char**		args;
	char**		p;

	struct argvec	vec;

	if (!a0 && a1)
		args = (char**)a1;
	else {
		initargs(&vec);
		getargs(&vec, cmd);
		if (a0) {
			addarg(&vec, a0);
			if (a1) {
				addarg(&vec, a1);
				if (a2)
					addarg(&vec, a2);
			}
		}
		endargs(&vec);
		cmd = vec.argv[0];
		args = vec.argv;
	}
	if (infd > READ) {
		if ((savein = dup(READ)) < 0) {
			note(SYSTEM, "%s: Cannot save standard input", cmd);
			return -1;
		}
		fcntl(savein, F_SETFD, 1);
		fcntl(infd, F_SETFD, 1);
		close(READ);
		if (dup(infd) != READ) {
			note(SYSTEM, "%s: Cannot redirect standard input", cmd);
			dup(savein);
			close(savein);
			return -1;
		}
	}
	else infd = -1;
	if (outfd > WRITE) {
		if ((saveout = dup(WRITE)) < 0) {
			note(SYSTEM, "%s: Cannot save standard output", cmd);
			return -1;
		}
		fcntl(saveout, F_SETFD, 1);
		fcntl(outfd, F_SETFD, 1);
		close(WRITE);
		if (dup(outfd) != WRITE) {
			note(SYSTEM, "%s: Cannot redirect standard input", cmd);
			dup(savein);
			close(savein);
			dup(saveout);
			close(saveout);
			return -1;
		}
	}
	else
		outfd = -1;
	if (state.var.debug) {
		note(DEBUG|PROMPT, "spawn:");
		for (p = args; *p; p++)
			printf(" \"%s\"", *p);
		printf("\n");
	}
	if (critical)
		sigcritical(critical);
	if ((pid = spawnvp(cmd, args)) == -1)
		note(SYSTEM, "%s", cmd);
	if (critical)
		sigcritical(0);
	if (infd > READ) {
		close(READ);
		if (dup(savein) != READ) {
			note(SYSTEM, "%s: Cannot restore standard input", cmd);
			return -1;
		}
		close(savein);
		fcntl(READ, F_SETFD, 0);
	}
	if (outfd > WRITE) {
		close(WRITE);
		if (dup(saveout) != WRITE) {
			note(SYSTEM, "%s: Cannot restore standard output", cmd);
			return -1;
		}
		close(saveout);
		fcntl(WRITE, F_SETFD, 0);
	}
	return pid;
}

static struct child*
findchild(int pid)
{
	register struct child**	cpp;

	for (cpp = &state.children; *cpp && (*cpp)->pid != pid;
	     cpp = &(*cpp)->link)
			;
	if (*cpp || (*cpp = (struct child*)malloc(sizeof(struct child)))) {
		(*cpp)->pid = pid;
		(*cpp)->done = (*cpp)->free = 0;
		(*cpp)->link = 0;
	}
	return *cpp;
}

static void
delchild(register struct child* cp)
{
	register struct child**	cpp;

	for (cpp = &state.children; *cpp != cp; cpp = &(*cpp)->link) ;
	*cpp = cp->link;
	free(cp);
}

/*
 * Wait for a specific child to die.
 */
int
wait_command(int pid)
{
	register struct child*	cp = findchild(pid);
	int			status = -1;

	holdsigs();
	while (waitpid(pid, &status, 0) == -1 && errno == EINTR);
	relsesigs();
	delchild(cp);
	return status;
}

/*
 * Mark a command as don't care.
 */
void
free_command(int pid)
{
	register struct child*	cp = findchild(pid);

	if (cp->done)
		delchild(cp);
	else
		cp->free = 1;
}