First commit (NetBSD 9.1)

1 files changed, 503 insertions, 0 deletions

diff --git a/io.c b/io.c
new file mode 100644
index 0000000..86febf6
--- /dev/null
+++ b/io.c
@@ -0,0 +1,503 @@
+/*	$NetBSD: io.c,v 1.18 2018/05/08 16:37:59 kamil Exp $	*/
+
+/*
+ * shell buffered IO and formatted output
+ */
+#include <sys/cdefs.h>
+
+#ifndef lint
+__RCSID("$NetBSD: io.c,v 1.18 2018/05/08 16:37:59 kamil Exp $");
+#endif
+
+#include <sys/stat.h>
+#include <ctype.h>
+#include "sh.h"
+
+static int initio_done;
+
+/*
+ * formatted output functions
+ */
+
+
+/* A shell error occurred (eg, syntax error, etc.) */
+void
+errorf(const char *fmt, ...)
+{
+	va_list va;
+
+	shl_stdout_ok = 0;	/* debugging: note that stdout not valid */
+	exstat = 1;
+	if (*fmt) {
+		error_prefix(true);
+		va_start(va, fmt);
+		shf_vfprintf(shl_out, fmt, va);
+		va_end(va);
+		shf_putchar('\n', shl_out);
+	}
+	shf_flush(shl_out);
+	unwind(LERROR);
+}
+
+/* like errorf(), but no unwind is done */
+void
+warningf(int fileline, const char *fmt, ...)
+{
+	va_list va;
+
+	error_prefix(fileline);
+	va_start(va, fmt);
+	shf_vfprintf(shl_out, fmt, va);
+	va_end(va);
+	shf_putchar('\n', shl_out);
+	shf_flush(shl_out);
+}
+
+/* Used by built-in utilities to prefix shell and utility name to message
+ * (also unwinds environments for special builtins).
+ */
+void
+bi_errorf(const char *fmt, ...)
+{
+	va_list va;
+
+	shl_stdout_ok = 0;	/* debugging: note that stdout not valid */
+	exstat = 1;
+	if (*fmt) {
+		error_prefix(true);
+		/* not set when main() calls parse_args() */
+		if (builtin_argv0)
+			shf_fprintf(shl_out, "%s: ", builtin_argv0);
+		va_start(va, fmt);
+		shf_vfprintf(shl_out, fmt, va);
+		va_end(va);
+		shf_putchar('\n', shl_out);
+	}
+	shf_flush(shl_out);
+	/* POSIX special builtins and ksh special builtins cause
+	 * non-interactive shells to exit.
+	 * XXX odd use of KEEPASN; also may not want LERROR here
+	 */
+	if ((builtin_flag & SPEC_BI)
+	    || (Flag(FPOSIX) && (builtin_flag & KEEPASN)))
+	{
+		builtin_argv0 = (char *) 0;
+		unwind(LERROR);
+	}
+}
+
+/* Called when something that shouldn't happen does */
+void
+internal_errorf(int jump, const char *fmt, ...)
+{
+	va_list va;
+
+	error_prefix(true);
+	shf_fprintf(shl_out, "internal error: ");
+	va_start(va, fmt);
+	shf_vfprintf(shl_out, fmt, va);
+	va_end(va);
+	shf_putchar('\n', shl_out);
+	shf_flush(shl_out);
+	if (jump)
+		unwind(LERROR);
+}
+
+/* used by error reporting functions to print "ksh: .kshrc[25]: " */
+void
+error_prefix(fileline)
+	int fileline;
+{
+	/* Avoid foo: foo[2]: ... */
+	if (!fileline || !source || !source->file
+	    || strcmp(source->file, kshname) != 0)
+		shf_fprintf(shl_out, "%s: ", kshname + (*kshname == '-'));
+	if (fileline && source && source->file != NULL) {
+		shf_fprintf(shl_out, "%s[%d]: ", source->file,
+			source->errline > 0 ? source->errline : source->line);
+		source->errline = 0;
+	}
+}
+
+/* printf to shl_out (stderr) with flush */
+void
+shellf(const char *fmt, ...)
+{
+	va_list va;
+
+	if (!initio_done) /* shl_out may not be set up yet... */
+		return;
+	va_start(va, fmt);
+	shf_vfprintf(shl_out, fmt, va);
+	va_end(va);
+	shf_flush(shl_out);
+}
+
+/* printf to shl_stdout (stdout) */
+void
+shprintf(const char *fmt, ...)
+{
+	va_list va;
+
+	if (!shl_stdout_ok)
+		internal_errorf(1, "shl_stdout not valid");
+	va_start(va, fmt);
+	shf_vfprintf(shl_stdout, fmt, va);
+	va_end(va);
+}
+
+#ifdef KSH_DEBUG
+static struct shf *kshdebug_shf;
+
+void
+kshdebug_init_()
+{
+	if (kshdebug_shf)
+		shf_close(kshdebug_shf);
+	kshdebug_shf = shf_open("/tmp/ksh-debug.log",
+				O_WRONLY|O_APPEND|O_CREAT, 0600,
+				SHF_WR|SHF_MAPHI);
+	if (kshdebug_shf) {
+		shf_fprintf(kshdebug_shf, "\nNew shell[pid %d]\n", getpid());
+		shf_flush(kshdebug_shf);
+	}
+}
+
+/* print to debugging log */
+void
+kshdebug_printf_(const char *fmt, ...)
+{
+	va_list va;
+
+	if (!kshdebug_shf)
+		return;
+	va_start(va, fmt);
+	shf_fprintf(kshdebug_shf, "[%d] ", getpid());
+	shf_vfprintf(kshdebug_shf, fmt, va);
+	va_end(va);
+	shf_flush(kshdebug_shf);
+}
+
+void
+kshdebug_dump_(str, mem, nbytes)
+	const char *str;
+	const void *mem;
+	int nbytes;
+{
+	int i, j;
+	int nprow = 16;
+
+	if (!kshdebug_shf)
+		return;
+	shf_fprintf(kshdebug_shf, "[%d] %s:\n", getpid(), str);
+	for (i = 0; i < nbytes; i += nprow) {
+		char c = '\t';
+		for (j = 0; j < nprow && i + j < nbytes; j++) {
+			shf_fprintf(kshdebug_shf, "%c%02x",
+				c, ((const unsigned char *) mem)[i + j]);
+			c = ' ';
+		}
+		shf_fprintf(kshdebug_shf, "\n");
+	}
+	shf_flush(kshdebug_shf);
+}
+#endif /* KSH_DEBUG */
+
+/* test if we can seek backwards fd (returns 0 or SHF_UNBUF) */
+int
+can_seek(fd)
+	int fd;
+{
+	struct stat statb;
+
+	return fstat(fd, &statb) == 0 && !S_ISREG(statb.st_mode) ?
+		SHF_UNBUF : 0;
+}
+
+struct shf	shf_iob[3];
+
+void
+initio()
+{
+	shf_fdopen(1, SHF_WR, shl_stdout);	/* force buffer allocation */
+	shf_fdopen(2, SHF_WR, shl_out);
+	shf_fdopen(2, SHF_WR, shl_spare);	/* force buffer allocation */
+	initio_done = 1;
+	kshdebug_init();
+}
+
+/* A dup2() with error checking */
+int
+ksh_dup2(ofd, nfd, errok)
+	int ofd;
+	int nfd;
+	int errok;
+{
+	int ret = dup2(ofd, nfd);
+
+	if (ret < 0 && errno != EBADF && !errok)
+		errorf("too many files open in shell");
+
+	return ret;
+}
+
+/*
+ * move fd from user space (0<=fd<10) to shell space (fd>=10),
+ * set close-on-exec flag.
+ */
+int
+savefd(fd, noclose)
+	int fd;
+	int noclose;
+{
+	int nfd;
+
+	if (fd < FDBASE) {
+		nfd = ksh_dupbase(fd, FDBASE);
+		if (nfd < 0) {
+			if (errno == EBADF)
+				return -1;
+			else
+				errorf("too many files open in shell");
+		}
+		if (!noclose)
+			close(fd);
+	} else
+		nfd = fd;
+	fd_clexec(nfd);
+	return nfd;
+}
+
+void
+restfd(fd, ofd)
+	int fd, ofd;
+{
+	if (fd == 2)
+		shf_flush(&shf_iob[fd]);
+	if (ofd < 0)		/* original fd closed */
+		close(fd);
+	else if (fd != ofd) {
+		ksh_dup2(ofd, fd, true); /* XXX: what to do if this fails? */
+		close(ofd);
+	}
+}
+
+void
+openpipe(pv)
+	int *pv;
+{
+	if (pipe(pv) < 0)
+		errorf("can't create pipe - try again");
+	pv[0] = savefd(pv[0], 0);
+	pv[1] = savefd(pv[1], 0);
+}
+
+void
+closepipe(pv)
+	int *pv;
+{
+	close(pv[0]);
+	close(pv[1]);
+}
+
+/* Called by iosetup() (deals with 2>&4, etc.), c_read, c_print to turn
+ * a string (the X in 2>&X, read -uX, print -uX) into a file descriptor.
+ */
+int
+check_fd(name, mode, emsgp)
+	char *name;
+	int mode;
+	const char **emsgp;
+{
+	int fd, fl;
+
+	if (isdigit((unsigned char)name[0]) && !name[1]) {
+		fd = name[0] - '0';
+		if ((fl = fcntl(fd = name[0] - '0', F_GETFL, 0)) < 0) {
+			if (emsgp)
+				*emsgp = "bad file descriptor";
+			return -1;
+		}
+		fl &= O_ACCMODE;
+
+		/* X_OK is a kludge to disable this check for dups (x<&1):
+		 * historical shells never did this check (XXX don't know what
+		 * posix has to say).
+		 */
+		if (!(mode & X_OK) && fl != O_RDWR
+		    && (((mode & R_OK) && fl != O_RDONLY)
+			|| ((mode & W_OK) && fl != O_WRONLY)))
+		{
+			if (emsgp)
+				*emsgp = (fl == O_WRONLY) ?
+						"fd not open for reading"
+					      : "fd not open for writing";
+			return -1;
+		}
+		return fd;
+	}
+#ifdef KSH
+	else if (name[0] == 'p' && !name[1])
+		return coproc_getfd(mode, emsgp);
+#endif /* KSH */
+	if (emsgp)
+		*emsgp = "illegal file descriptor name";
+	return -1;
+}
+
+#ifdef KSH
+/* Called once from main */
+void
+coproc_init()
+{
+	coproc.read = coproc.readw = coproc.write = -1;
+	coproc.njobs = 0;
+	coproc.id = 0;
+}
+
+/* Called by c_read() when eof is read - close fd if it is the co-process fd */
+void
+coproc_read_close(fd)
+	int fd;
+{
+	if (coproc.read >= 0 && fd == coproc.read) {
+		coproc_readw_close(fd);
+		close(coproc.read);
+		coproc.read = -1;
+	}
+}
+
+/* Called by c_read() and by iosetup() to close the other side of the
+ * read pipe, so reads will actually terminate.
+ */
+void
+coproc_readw_close(fd)
+	int fd;
+{
+	if (coproc.readw >= 0 && coproc.read >= 0 && fd == coproc.read) {
+		close(coproc.readw);
+		coproc.readw = -1;
+	}
+}
+
+/* Called by c_print when a write to a fd fails with EPIPE and by iosetup
+ * when co-process input is dup'd
+ */
+void
+coproc_write_close(fd)
+	int fd;
+{
+	if (coproc.write >= 0 && fd == coproc.write) {
+		close(coproc.write);
+		coproc.write = -1;
+	}
+}
+
+/* Called to check for existence of/value of the co-process file descriptor.
+ * (Used by check_fd() and by c_read/c_print to deal with -p option).
+ */
+int
+coproc_getfd(mode, emsgp)
+	int mode;
+	const char **emsgp;
+{
+	int fd = (mode & R_OK) ? coproc.read : coproc.write;
+
+	if (fd >= 0)
+		return fd;
+	if (emsgp)
+		*emsgp = "no coprocess";
+	return -1;
+}
+
+/* called to close file descriptors related to the coprocess (if any)
+ * Should be called with SIGCHLD blocked.
+ */
+void
+coproc_cleanup(reuse)
+	int reuse;
+{
+	/* This to allow co-processes to share output pipe */
+	if (!reuse || coproc.readw < 0 || coproc.read < 0) {
+		if (coproc.read >= 0) {
+			close(coproc.read);
+			coproc.read = -1;
+		}
+		if (coproc.readw >= 0) {
+			close(coproc.readw);
+			coproc.readw = -1;
+		}
+	}
+	if (coproc.write >= 0) {
+		close(coproc.write);
+		coproc.write = -1;
+	}
+}
+#endif /* KSH */
+
+
+/*
+ * temporary files
+ */
+
+struct temp *
+maketemp(ap, type, tlist)
+	Area *ap;
+	Temp_type type;
+	struct temp **tlist;
+{
+#ifndef __NetBSD__
+	static unsigned int inc;
+#endif
+	struct temp *tp;
+	int len;
+	int fd;
+	char *pathx;
+	const char *dir;
+
+	dir = tmpdir ? tmpdir : "/tmp";
+	/* The 20 + 20 is a paranoid worst case for pid/inc */
+	len = strlen(dir) + 3 + 20 + 20 + 1;
+	tp = (struct temp *) alloc(sizeof(struct temp) + len, ap);
+	tp->name = pathx = (char *) &tp[1];
+	tp->shf = (struct shf *) 0;
+	tp->type = type;
+#ifdef __NetBSD__
+	shf_snprintf(pathx, len, "%s/shXXXXXXXX", dir);
+	fd = mkstemp(pathx);
+	if (fd >= 0)
+		tp->shf = shf_fdopen(fd, SHF_WR, (struct shf *) 0);
+#else
+	while (1) {
+		/* Note that temp files need to fit 8.3 DOS limits */
+		shf_snprintf(pathx, len, "%s/sh%05u.%03x",
+			     dir, (unsigned) procpid, inc++);
+		/* Mode 0600 to be paranoid, O_TRUNC in case O_EXCL isn't
+		 * really there.
+		 */
+		fd = open(pathx, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0600);
+		if (fd >= 0) {
+			tp->shf = shf_fdopen(fd, SHF_WR, (struct shf *) 0);
+			break;
+		}
+		if (errno != EINTR
+#ifdef EEXIST
+		    && errno != EEXIST
+#endif /* EEXIST */
+#ifdef EISDIR
+		    && errno != EISDIR
+#endif /* EISDIR */
+			)
+			/* Error must be printed by caller: don't know here if
+			 * errorf() or bi_errorf() should be used.
+			 */
+			break;
+	}
+#endif /* __NetBSD__ */
+	tp->pid = procpid;
+
+	tp->next = *tlist;
+	*tlist = tp;
+
+	return tp;
+}