Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/vi/build/../ex/ex_script.c	Lines:	0	264	0.0 %
Date:	2017-11-07	Branches:	0	283	0.0 %


/*	$OpenBSD: ex_script.c,v 1.27 2017/04/18 01:45:35 deraadt Exp $	*/

/*-
 * Copyright (c) 1992, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1992, 1993, 1994, 1995, 1996
 *	Keith Bostic.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Brian Hirt.
 *
 * See the LICENSE file for redistribution information.
 */

#include "config.h"

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <bitstring.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>		/* XXX: OSF/1 bug: include before <grp.h> */
#include <grp.h>
#include <limits.h>
#include <poll.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <util.h>

#include "../common/common.h"
#include "../vi/vi.h"
#include "script.h"
#include "pathnames.h"

static void	sscr_check(SCR *);
static int	sscr_getprompt(SCR *);
static int	sscr_init(SCR *);
static int	sscr_insert(SCR *);
static int	sscr_matchprompt(SCR *, char *, size_t, size_t *);
static int	sscr_setprompt(SCR *, char *, size_t);

/*
 * ex_script -- : sc[ript][!] [file]
 *	Switch to script mode.
 *
 * PUBLIC: int ex_script(SCR *, EXCMD *);
 */
int
ex_script(SCR *sp, EXCMD *cmdp)
{
	/* Vi only command. */
	if (!F_ISSET(sp, SC_VI)) {
		msgq(sp, M_ERR,
		    "The script command is only available in vi mode");
		return (1);
	}

	/* Switch to the new file. */
	if (cmdp->argc != 0 && ex_edit(sp, cmdp))
		return (1);

	/* Create the shell, figure out the prompt. */
	if (sscr_init(sp))
		return (1);

	return (0);
}

/*
 * sscr_init --
 *	Create a pty setup for a shell.
 */
static int
sscr_init(SCR *sp)
{
	SCRIPT *sc;
	char *sh, *sh_path;

	/* We're going to need a shell. */
	if (opts_empty(sp, O_SHELL, 0))
		return (1);

	MALLOC_RET(sp, sc, sizeof(SCRIPT));
	sp->script = sc;
	sc->sh_prompt = NULL;
	sc->sh_prompt_len = 0;

	/*
	 * There are two different processes running through this code.
	 * They are the shell and the parent.
	 */
	sc->sh_master = sc->sh_slave = -1;

	if (tcgetattr(STDIN_FILENO, &sc->sh_term) == -1) {
		msgq(sp, M_SYSERR, "tcgetattr");
		goto err;
	}

	/*
	 * Turn off output postprocessing and echo.
	 */
	sc->sh_term.c_oflag &= ~OPOST;
	sc->sh_term.c_cflag &= ~(ECHO|ECHOE|ECHONL|ECHOK);

	if (ioctl(STDIN_FILENO, TIOCGWINSZ, &sc->sh_win) == -1) {
		msgq(sp, M_SYSERR, "tcgetattr");
		goto err;
	}

	if (openpty(&sc->sh_master,
	    &sc->sh_slave, sc->sh_name, &sc->sh_term, &sc->sh_win) == -1) {
		msgq(sp, M_SYSERR, "pty");
		goto err;
	}

	/*
	 * __TK__ huh?
	 * Don't use vfork() here, because the signal semantics differ from
	 * implementation to implementation.
	 */
	switch (sc->sh_pid = fork()) {
	case -1:			/* Error. */
		msgq(sp, M_SYSERR, "fork");
err:		if (sc->sh_master != -1)
			(void)close(sc->sh_master);
		if (sc->sh_slave != -1)
			(void)close(sc->sh_slave);
		return (1);
	case 0:				/* Utility. */
		/*
		 * XXX
		 * So that shells that do command line editing turn it off.
		 */
		if (setenv("TERM", "emacs", 1) == -1 ||
		    setenv("TERMCAP", "emacs:", 1) == -1 ||
		    setenv("EMACS", "t", 1) == -1)
			_exit(126);

		(void)setsid();
		/*
		 * 4.4BSD allocates a controlling terminal using the TIOCSCTTY
		 * ioctl, not by opening a terminal device file.  POSIX 1003.1
		 * doesn't define a portable way to do this.
		 */
		(void)ioctl(sc->sh_slave, TIOCSCTTY, 0);
		(void)close(sc->sh_master);
		(void)dup2(sc->sh_slave, STDIN_FILENO);
		(void)dup2(sc->sh_slave, STDOUT_FILENO);
		(void)dup2(sc->sh_slave, STDERR_FILENO);
		(void)close(sc->sh_slave);

		/* Assumes that all shells have -i. */
		sh_path = O_STR(sp, O_SHELL);
		if ((sh = strrchr(sh_path, '/')) == NULL)
			sh = sh_path;
		else
			++sh;
		execl(sh_path, sh, "-i", (char *)NULL);
		msgq_str(sp, M_SYSERR, sh_path, "execl: %s");
		_exit(127);
	default:			/* Parent. */
		break;
	}

	if (sscr_getprompt(sp))
		return (1);

	F_SET(sp, SC_SCRIPT);
	F_SET(sp->gp, G_SCRWIN);
	return (0);
}

/*
 * sscr_getprompt --
 *	Eat lines printed by the shell until a line with no trailing
 *	carriage return comes; set the prompt from that line.
 */
static int
sscr_getprompt(SCR *sp)
{
	CHAR_T *endp, *p, *t, buf[1024];
	SCRIPT *sc;
	struct pollfd pfd[1];
	recno_t lline;
	size_t llen, len;
	u_int value;
	int nr;

	endp = buf;
	len = sizeof(buf);

	/* Wait up to a second for characters to read. */
	sc = sp->script;
	pfd[0].fd = sc->sh_master;
	pfd[0].events = POLLIN;
	switch (poll(pfd, 1, 5 * 1000)) {
	case -1:		/* Error or interrupt. */
		msgq(sp, M_SYSERR, "poll");
		goto prompterr;
	case  0:		/* Timeout */
		msgq(sp, M_ERR, "Error: timed out");
		goto prompterr;
	default:		/* Characters to read. */
		break;
	}

	/* Read the characters. */
more:	len = sizeof(buf) - (endp - buf);
	switch (nr = read(sc->sh_master, endp, len)) {
	case  0:			/* EOF. */
		msgq(sp, M_ERR, "Error: shell: EOF");
		goto prompterr;
	case -1:			/* Error or interrupt. */
		msgq(sp, M_SYSERR, "shell");
		goto prompterr;
	default:
		endp += nr;
		break;
	}

	/* If any complete lines, push them into the file. */
	for (p = t = buf; p < endp; ++p) {
		value = KEY_VAL(sp, *p);
		if (value == K_CR || value == K_NL) {
			if (db_last(sp, &lline) ||
			    db_append(sp, 0, lline, t, p - t))
				goto prompterr;
			t = p + 1;
		}
	}
	if (p > buf) {
		memmove(buf, t, endp - t);
		endp = buf + (endp - t);
	}
	if (endp == buf)
		goto more;

	/* Wait up 1/10 of a second to make sure that we got it all. */
	switch (poll(pfd, 1, 100)) {
	case -1:		/* Error or interrupt. */
		msgq(sp, M_SYSERR, "poll");
		goto prompterr;
	case  0:		/* Timeout */
		break;
	default:		/* Characters to read. */
		goto more;
	}

	/* Timed out, so theoretically we have a prompt. */
	llen = endp - buf;
	endp = buf;

	/* Append the line into the file. */
	if (db_last(sp, &lline) || db_append(sp, 0, lline, buf, llen)) {
prompterr:	sscr_end(sp);
		return (1);
	}

	return (sscr_setprompt(sp, buf, llen));
}

/*
 * sscr_exec --
 *	Take a line and hand it off to the shell.
 *
 * PUBLIC: int sscr_exec(SCR *, recno_t);
 */
int
sscr_exec(SCR *sp, recno_t lno)
{
	SCRIPT *sc;
	recno_t last_lno;
	size_t blen, len, last_len, tlen;
	int isempty, matchprompt, nw, rval;
	char *bp, *p;

	/* If there's a prompt on the last line, append the command. */
	if (db_last(sp, &last_lno))
		return (1);
	if (db_get(sp, last_lno, DBG_FATAL, &p, &last_len))
		return (1);
	if (sscr_matchprompt(sp, p, last_len, &tlen) && tlen == 0) {
		matchprompt = 1;
		GET_SPACE_RET(sp, bp, blen, last_len + 128);
		memmove(bp, p, last_len);
	} else
		matchprompt = 0;

	/* Get something to execute. */
	if (db_eget(sp, lno, &p, &len, &isempty)) {
		if (isempty)
			goto empty;
		goto err1;
	}

	/* Empty lines aren't interesting. */
	if (len == 0)
		goto empty;

	/* Delete any prompt. */
	if (sscr_matchprompt(sp, p, len, &tlen)) {
		if (tlen == len) {
empty:			msgq(sp, M_BERR, "No command to execute");
			goto err1;
		}
		p += (len - tlen);
		len = tlen;
	}

	/* Push the line to the shell. */
	sc = sp->script;
	if ((nw = write(sc->sh_master, p, len)) != len)
		goto err2;
	rval = 0;
	if (write(sc->sh_master, "\n", 1) != 1) {
err2:		if (nw == 0)
			errno = EIO;
		msgq(sp, M_SYSERR, "shell");
		goto err1;
	}

	if (matchprompt) {
		ADD_SPACE_RET(sp, bp, blen, last_len + len);
		memmove(bp + last_len, p, len);
		if (db_set(sp, last_lno, bp, last_len + len))
err1:			rval = 1;
	}
	if (matchprompt)
		FREE_SPACE(sp, bp, blen);
	return (rval);
}

/*
 * sscr_check_input -
 *	Check for input from command input or scripting windows.
 *
 * PUBLIC: int sscr_check_input(SCR *sp);
 */
int
sscr_check_input(SCR *sp)
{
	GS *gp;
	SCR *tsp;
	struct pollfd *pfd;
	int nfds, rval;

	gp = sp->gp;
	rval = 0;

	/* Allocate space for pfd. */
	nfds = 1;
	TAILQ_FOREACH(tsp, &gp->dq, q)
		if (F_ISSET(sp, SC_SCRIPT))
			nfds++;
	pfd = calloc(nfds, sizeof(struct pollfd));
	if (pfd == NULL) {
		msgq(sp, M_SYSERR, "malloc");
		return (1);
	}

	/* Setup events bitmasks. */
	pfd[0].fd = STDIN_FILENO;
	pfd[0].events = POLLIN;
	nfds = 1;
	TAILQ_FOREACH(tsp, &gp->dq, q)
		if (F_ISSET(sp, SC_SCRIPT)) {
			pfd[nfds].fd = sp->script->sh_master;
			pfd[nfds].events = POLLIN;
			nfds++;
		}

loop:
	/* Check for input. */
	switch (poll(pfd, nfds, INFTIM)) {
	case -1:
		msgq(sp, M_SYSERR, "poll");
		rval = 1;
		/* FALLTHROUGH */
	case 0:
		goto done;
	default:
		break;
	}

	/* Only insert from the scripting windows if no command input */
	if (!(pfd[0].revents & POLLIN)) {
		nfds = 1;
		TAILQ_FOREACH(tsp, &gp->dq, q)
			if (F_ISSET(sp, SC_SCRIPT)) {
				if ((pfd[nfds].revents & POLLHUP) && sscr_end(sp))
					goto done;
				if ((pfd[nfds].revents & POLLIN) && sscr_insert(sp))
					goto done;
				nfds++;
			}
		goto loop;
	}
done:
	free(pfd);
	return (rval);
}

/*
 * sscr_input --
 *	Read any waiting shell input.
 *
 * PUBLIC: int sscr_input(SCR *);
 */
int
sscr_input(SCR *sp)
{
	GS *gp;
	struct pollfd *pfd;
	int nfds, rval;

	gp = sp->gp;
	rval = 0;

	/* Allocate space for pfd. */
	nfds = 0;
	TAILQ_FOREACH(sp, &gp->dq, q)
		if (F_ISSET(sp, SC_SCRIPT))
			nfds++;
	if (nfds == 0)
		return (0);
	pfd = calloc(nfds, sizeof(struct pollfd));
	if (pfd == NULL) {
		msgq(sp, M_SYSERR, "malloc");
		return (1);
	}

	/* Setup events bitmasks. */
	nfds = 0;
	TAILQ_FOREACH(sp, &gp->dq, q)
		if (F_ISSET(sp, SC_SCRIPT)) {
			pfd[nfds].fd = sp->script->sh_master;
			pfd[nfds].events = POLLIN;
			nfds++;
		}

loop:
	/* Check for input. */
	switch (poll(pfd, nfds, 0)) {
	case -1:
		msgq(sp, M_SYSERR, "poll");
		rval = 1;
		/* FALLTHROUGH */
	case 0:
		goto done;
	default:
		break;
	}

	/* Read the input. */
	nfds = 0;
	TAILQ_FOREACH(sp, &gp->dq, q)
		if (F_ISSET(sp, SC_SCRIPT)) {
			if ((pfd[nfds].revents & POLLHUP) && sscr_end(sp))
				goto done;
			if ((pfd[nfds].revents & POLLIN) && sscr_insert(sp))
				goto done;
			nfds++;
		}
	goto loop;
done:
	free(pfd);
	return (rval);
}

/*
 * sscr_insert --
 *	Take a line from the shell and insert it into the file.
 */
static int
sscr_insert(SCR *sp)
{
	CHAR_T *endp, *p, *t;
	SCRIPT *sc;
	struct pollfd pfd[1];
	recno_t lno;
	size_t blen, len, tlen;
	u_int value;
	int nr, rval;
	char *bp;

	/* Find out where the end of the file is. */
	if (db_last(sp, &lno))
		return (1);

#define	MINREAD	1024
	GET_SPACE_RET(sp, bp, blen, MINREAD);
	endp = bp;

	/* Read the characters. */
	rval = 1;
	sc = sp->script;
more:	switch (nr = read(sc->sh_master, endp, MINREAD)) {
	case  0:			/* EOF; shell just exited. */
		sscr_end(sp);
		rval = 0;
		goto ret;
	case -1:			/* Error or interrupt. */
		msgq(sp, M_SYSERR, "shell");
		goto ret;
	default:
		endp += nr;
		break;
	}

	/* Append the lines into the file. */
	for (p = t = bp; p < endp; ++p) {
		value = KEY_VAL(sp, *p);
		if (value == K_CR || value == K_NL) {
			len = p - t;
			if (db_append(sp, 1, lno++, t, len))
				goto ret;
			t = p + 1;
		}
	}
	if (p > t) {
		len = p - t;
		/*
		 * If the last thing from the shell isn't another prompt, wait
		 * up to 1/10 of a second for more stuff to show up, so that
		 * we don't break the output into two separate lines.  Don't
		 * want to hang indefinitely because some program is hanging,
		 * confused the shell, or whatever.
		 */
		if (!sscr_matchprompt(sp, t, len, &tlen) || tlen != 0) {
			pfd[0].fd = sc->sh_master;
			pfd[0].events = POLLIN;
			if (poll(pfd, 1, 100) > 0) {
				memmove(bp, t, len);
				endp = bp + len;
				goto more;
			}
		}
		if (sscr_setprompt(sp, t, len))
			return (1);
		if (db_append(sp, 1, lno++, t, len))
			goto ret;
	}

	/* The cursor moves to EOF. */
	sp->lno = lno;
	sp->cno = len ? len - 1 : 0;
	rval = vs_refresh(sp, 1);

ret:	FREE_SPACE(sp, bp, blen);
	return (rval);
}

/*
 * sscr_setprompt --
 *
 * Set the prompt to the last line we got from the shell.
 *
 */
static int
sscr_setprompt(SCR *sp, char *buf, size_t len)
{
	SCRIPT *sc;

	sc = sp->script;
	free(sc->sh_prompt);
	MALLOC(sp, sc->sh_prompt, len + 1);
	if (sc->sh_prompt == NULL) {
		sscr_end(sp);
		return (1);
	}
	memmove(sc->sh_prompt, buf, len);
	sc->sh_prompt_len = len;
	sc->sh_prompt[len] = '\0';
	return (0);
}

/*
 * sscr_matchprompt --
 *	Check to see if a line matches the prompt.  Nul's indicate
 *	parts that can change, in both content and size.
 */
static int
sscr_matchprompt(SCR *sp, char *lp, size_t line_len, size_t *lenp)
{
	SCRIPT *sc;
	size_t prompt_len;
	char *pp;

	sc = sp->script;
	if (line_len < (prompt_len = sc->sh_prompt_len))
		return (0);

	for (pp = sc->sh_prompt;
	    prompt_len && line_len; --prompt_len, --line_len) {
		if (*pp == '\0') {
			for (; prompt_len && *pp == '\0'; --prompt_len, ++pp);
			if (!prompt_len)
				return (0);
			for (; line_len && *lp != *pp; --line_len, ++lp);
			if (!line_len)
				return (0);
		}
		if (*pp++ != *lp++)
			break;
	}

	if (prompt_len)
		return (0);
	if (lenp != NULL)
		*lenp = line_len;
	return (1);
}

/*
 * sscr_end --
 *	End the pipe to a shell.
 *
 * PUBLIC: int sscr_end(SCR *);
 */
int
sscr_end(SCR *sp)
{
	SCRIPT *sc;

	if ((sc = sp->script) == NULL)
		return (0);

	/* Turn off the script flags. */
	F_CLR(sp, SC_SCRIPT);
	sscr_check(sp);

	/* Close down the parent's file descriptors. */
	if (sc->sh_master != -1)
	    (void)close(sc->sh_master);
	if (sc->sh_slave != -1)
	    (void)close(sc->sh_slave);

	/* This should have killed the child. */
	(void)proc_wait(sp, sc->sh_pid, "script-shell", 0, 0);

	/* Free memory. */
	free(sc->sh_prompt);
	free(sc);
	sp->script = NULL;

	return (0);
}

/*
 * sscr_check --
 *	Set/clear the global scripting bit.
 */
static void
sscr_check(SCR *sp)
{
	GS *gp;

	gp = sp->gp;
	TAILQ_FOREACH(sp, &gp->dq, q)
		if (F_ISSET(sp, SC_SCRIPT)) {
			F_SET(gp, G_SCRWIN);
			return;
		}
	F_CLR(gp, G_SCRWIN);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: ex_script.c,v 1.27 2017/04/18 01:45:35 deraadt Exp $ */
2
3			/*-
4			* Copyright (c) 1992, 1993, 1994
5			* The Regents of the University of California. All rights reserved.
6			* Copyright (c) 1992, 1993, 1994, 1995, 1996
7			* Keith Bostic. All rights reserved.
8			*
9			* This code is derived from software contributed to Berkeley by
10			* Brian Hirt.
11			*
12			* See the LICENSE file for redistribution information.
13			*/
14
15			#include "config.h"
16
17			#include <sys/types.h>
18			#include <sys/ioctl.h>
19			#include <sys/queue.h>
20			#include <sys/stat.h>
21			#include <sys/time.h>
22			#include <sys/wait.h>
23
24			#include <bitstring.h>
25			#include <errno.h>
26			#include <fcntl.h>
27			#include <stdio.h> /* XXX: OSF/1 bug: include before <grp.h> */
28			#include <grp.h>
29			#include <limits.h>
30			#include <poll.h>
31			#include <stdlib.h>
32			#include <string.h>
33			#include <termios.h>
34			#include <unistd.h>
35			#include <util.h>
36
37			#include "../common/common.h"
38			#include "../vi/vi.h"
39			#include "script.h"
40			#include "pathnames.h"
41
42			static void sscr_check(SCR *);
43			static int sscr_getprompt(SCR *);
44			static int sscr_init(SCR *);
45			static int sscr_insert(SCR *);
46			static int sscr_matchprompt(SCR , char , size_t, size_t *);
47			static int sscr_setprompt(SCR , char , size_t);
48
49			/*
50			* ex_script -- : sc[ript][!] [file]
51			* Switch to script mode.
52			*
53			* PUBLIC: int ex_script(SCR , EXCMD );
54			*/
55			int
56			ex_script(SCR sp, EXCMD cmdp)
57			{
58			/* Vi only command. */
59			if (!F_ISSET(sp, SC_VI)) {
60			msgq(sp, M_ERR,
61			"The script command is only available in vi mode");
62			return (1);
63			}
64
65			/* Switch to the new file. */
66			if (cmdp->argc != 0 && ex_edit(sp, cmdp))
67			return (1);
68
69			/* Create the shell, figure out the prompt. */
70			if (sscr_init(sp))
71			return (1);
72
73			return (0);
74			}
75
76			/*
77			* sscr_init --
78			* Create a pty setup for a shell.
79			*/
80			static int
81			sscr_init(SCR *sp)
82			{
83			SCRIPT *sc;
84			char sh, sh_path;
85
86			/* We're going to need a shell. */
87			if (opts_empty(sp, O_SHELL, 0))
88			return (1);
89
90			MALLOC_RET(sp, sc, sizeof(SCRIPT));
91			sp->script = sc;
92			sc->sh_prompt = NULL;
93			sc->sh_prompt_len = 0;
94
95			/*
96			* There are two different processes running through this code.
97			* They are the shell and the parent.
98			*/
99			sc->sh_master = sc->sh_slave = -1;
100
101			if (tcgetattr(STDIN_FILENO, &sc->sh_term) == -1) {
102			msgq(sp, M_SYSERR, "tcgetattr");
103			goto err;
104			}
105
106			/*
107			* Turn off output postprocessing and echo.
108			*/
109			sc->sh_term.c_oflag &= ~OPOST;
110			sc->sh_term.c_cflag &= ~(ECHO\|ECHOE\|ECHONL\|ECHOK);
111
112			if (ioctl(STDIN_FILENO, TIOCGWINSZ, &sc->sh_win) == -1) {
113			msgq(sp, M_SYSERR, "tcgetattr");
114			goto err;
115			}
116
117			if (openpty(&sc->sh_master,
118			&sc->sh_slave, sc->sh_name, &sc->sh_term, &sc->sh_win) == -1) {
119			msgq(sp, M_SYSERR, "pty");
120			goto err;
121			}
122
123			/*
124			* __TK__ huh?
125			* Don't use vfork() here, because the signal semantics differ from
126			* implementation to implementation.
127			*/
128			switch (sc->sh_pid = fork()) {
129			case -1: /* Error. */
130			msgq(sp, M_SYSERR, "fork");
131			err: if (sc->sh_master != -1)
132			(void)close(sc->sh_master);
133			if (sc->sh_slave != -1)
134			(void)close(sc->sh_slave);
135			return (1);
136			case 0: /* Utility. */
137			/*
138			* XXX
139			* So that shells that do command line editing turn it off.
140			*/
141			if (setenv("TERM", "emacs", 1) == -1 \|\|
142			setenv("TERMCAP", "emacs:", 1) == -1 \|\|
143			setenv("EMACS", "t", 1) == -1)
144			_exit(126);
145
146			(void)setsid();
147			/*
148			* 4.4BSD allocates a controlling terminal using the TIOCSCTTY
149			* ioctl, not by opening a terminal device file. POSIX 1003.1
150			* doesn't define a portable way to do this.
151			*/
152			(void)ioctl(sc->sh_slave, TIOCSCTTY, 0);
153			(void)close(sc->sh_master);
154			(void)dup2(sc->sh_slave, STDIN_FILENO);
155			(void)dup2(sc->sh_slave, STDOUT_FILENO);
156			(void)dup2(sc->sh_slave, STDERR_FILENO);
157			(void)close(sc->sh_slave);
158
159			/* Assumes that all shells have -i. */
160			sh_path = O_STR(sp, O_SHELL);
161			if ((sh = strrchr(sh_path, '/')) == NULL)
162			sh = sh_path;
163			else
164			++sh;
165			execl(sh_path, sh, "-i", (char *)NULL);
166			msgq_str(sp, M_SYSERR, sh_path, "execl: %s");
167			_exit(127);
168			default: /* Parent. */
169			break;
170			}
171
172			if (sscr_getprompt(sp))
173			return (1);
174
175			F_SET(sp, SC_SCRIPT);
176			F_SET(sp->gp, G_SCRWIN);
177			return (0);
178			}
179
180			/*
181			* sscr_getprompt --
182			* Eat lines printed by the shell until a line with no trailing
183			* carriage return comes; set the prompt from that line.
184			*/
185			static int
186			sscr_getprompt(SCR *sp)
187			{
188			CHAR_T endp, p, *t, buf[1024];
189			SCRIPT *sc;
190			struct pollfd pfd[1];
191			recno_t lline;
192			size_t llen, len;
193			u_int value;
194			int nr;
195
196			endp = buf;
197			len = sizeof(buf);
198
199			/* Wait up to a second for characters to read. */
200			sc = sp->script;
201			pfd[0].fd = sc->sh_master;
202			pfd[0].events = POLLIN;
203			switch (poll(pfd, 1, 5 * 1000)) {
204			case -1: /* Error or interrupt. */
205			msgq(sp, M_SYSERR, "poll");
206			goto prompterr;
207			case 0: /* Timeout */
208			msgq(sp, M_ERR, "Error: timed out");
209			goto prompterr;
210			default: /* Characters to read. */
211			break;
212			}
213
214			/* Read the characters. */
215			more: len = sizeof(buf) - (endp - buf);
216			switch (nr = read(sc->sh_master, endp, len)) {
217			case 0: /* EOF. */
218			msgq(sp, M_ERR, "Error: shell: EOF");
219			goto prompterr;
220			case -1: /* Error or interrupt. */
221			msgq(sp, M_SYSERR, "shell");
222			goto prompterr;
223			default:
224			endp += nr;
225			break;
226			}
227
228			/* If any complete lines, push them into the file. */
229			for (p = t = buf; p < endp; ++p) {
230			value = KEY_VAL(sp, *p);
231			if (value == K_CR \|\| value == K_NL) {
232			if (db_last(sp, &lline) \|\|
233			db_append(sp, 0, lline, t, p - t))
234			goto prompterr;
235			t = p + 1;
236			}
237			}
238			if (p > buf) {
239			memmove(buf, t, endp - t);
240			endp = buf + (endp - t);
241			}
242			if (endp == buf)
243			goto more;
244
245			/* Wait up 1/10 of a second to make sure that we got it all. */
246			switch (poll(pfd, 1, 100)) {
247			case -1: /* Error or interrupt. */
248			msgq(sp, M_SYSERR, "poll");
249			goto prompterr;
250			case 0: /* Timeout */
251			break;
252			default: /* Characters to read. */
253			goto more;
254			}
255
256			/* Timed out, so theoretically we have a prompt. */
257			llen = endp - buf;
258			endp = buf;
259
260			/* Append the line into the file. */
261			if (db_last(sp, &lline) \|\| db_append(sp, 0, lline, buf, llen)) {
262			prompterr: sscr_end(sp);
263			return (1);
264			}
265
266			return (sscr_setprompt(sp, buf, llen));
267			}
268
269			/*
270			* sscr_exec --
271			* Take a line and hand it off to the shell.
272			*
273			* PUBLIC: int sscr_exec(SCR *, recno_t);
274			*/
275			int
276			sscr_exec(SCR *sp, recno_t lno)
277			{
278			SCRIPT *sc;
279			recno_t last_lno;
280			size_t blen, len, last_len, tlen;
281			int isempty, matchprompt, nw, rval;
282			char bp, p;
283
284			/* If there's a prompt on the last line, append the command. */
285			if (db_last(sp, &last_lno))
286			return (1);
287			if (db_get(sp, last_lno, DBG_FATAL, &p, &last_len))
288			return (1);
289			if (sscr_matchprompt(sp, p, last_len, &tlen) && tlen == 0) {
290			matchprompt = 1;
291			GET_SPACE_RET(sp, bp, blen, last_len + 128);
292			memmove(bp, p, last_len);
293			} else
294			matchprompt = 0;
295
296			/* Get something to execute. */
297			if (db_eget(sp, lno, &p, &len, &isempty)) {
298			if (isempty)
299			goto empty;
300			goto err1;
301			}
302
303			/* Empty lines aren't interesting. */
304			if (len == 0)
305			goto empty;
306
307			/* Delete any prompt. */
308			if (sscr_matchprompt(sp, p, len, &tlen)) {
309			if (tlen == len) {
310			empty: msgq(sp, M_BERR, "No command to execute");
311			goto err1;
312			}
313			p += (len - tlen);
314			len = tlen;
315			}
316
317			/* Push the line to the shell. */
318			sc = sp->script;
319			if ((nw = write(sc->sh_master, p, len)) != len)
320			goto err2;
321			rval = 0;
322			if (write(sc->sh_master, "\n", 1) != 1) {
323			err2: if (nw == 0)
324			errno = EIO;
325			msgq(sp, M_SYSERR, "shell");
326			goto err1;
327			}
328
329			if (matchprompt) {
330			ADD_SPACE_RET(sp, bp, blen, last_len + len);
331			memmove(bp + last_len, p, len);
332			if (db_set(sp, last_lno, bp, last_len + len))
333			err1: rval = 1;
334			}
335			if (matchprompt)
336			FREE_SPACE(sp, bp, blen);
337			return (rval);
338			}
339
340			/*
341			* sscr_check_input -
342			* Check for input from command input or scripting windows.
343			*
344			* PUBLIC: int sscr_check_input(SCR *sp);
345			*/
346			int
347			sscr_check_input(SCR *sp)
348			{
349			GS *gp;
350			SCR *tsp;
351			struct pollfd *pfd;
352			int nfds, rval;
353
354			gp = sp->gp;
355			rval = 0;
356
357			/* Allocate space for pfd. */
358			nfds = 1;
359			TAILQ_FOREACH(tsp, &gp->dq, q)
360			if (F_ISSET(sp, SC_SCRIPT))
361			nfds++;
362			pfd = calloc(nfds, sizeof(struct pollfd));
363			if (pfd == NULL) {
364			msgq(sp, M_SYSERR, "malloc");
365			return (1);
366			}
367
368			/* Setup events bitmasks. */
369			pfd[0].fd = STDIN_FILENO;
370			pfd[0].events = POLLIN;
371			nfds = 1;
372			TAILQ_FOREACH(tsp, &gp->dq, q)
373			if (F_ISSET(sp, SC_SCRIPT)) {
374			pfd[nfds].fd = sp->script->sh_master;
375			pfd[nfds].events = POLLIN;
376			nfds++;
377			}
378
379			loop:
380			/* Check for input. */
381			switch (poll(pfd, nfds, INFTIM)) {
382			case -1:
383			msgq(sp, M_SYSERR, "poll");
384			rval = 1;
385			/* FALLTHROUGH */
386			case 0:
387			goto done;
388			default:
389			break;
390			}
391
392			/* Only insert from the scripting windows if no command input */
393			if (!(pfd[0].revents & POLLIN)) {
394			nfds = 1;
395			TAILQ_FOREACH(tsp, &gp->dq, q)
396			if (F_ISSET(sp, SC_SCRIPT)) {
397			if ((pfd[nfds].revents & POLLHUP) && sscr_end(sp))
398			goto done;
399			if ((pfd[nfds].revents & POLLIN) && sscr_insert(sp))
400			goto done;
401			nfds++;
402			}
403			goto loop;
404			}
405			done:
406			free(pfd);
407			return (rval);
408			}
409
410			/*
411			* sscr_input --
412			* Read any waiting shell input.
413			*
414			* PUBLIC: int sscr_input(SCR *);
415			*/
416			int
417			sscr_input(SCR *sp)
418			{
419			GS *gp;
420			struct pollfd *pfd;
421			int nfds, rval;
422
423			gp = sp->gp;
424			rval = 0;
425
426			/* Allocate space for pfd. */
427			nfds = 0;
428			TAILQ_FOREACH(sp, &gp->dq, q)
429			if (F_ISSET(sp, SC_SCRIPT))
430			nfds++;
431			if (nfds == 0)
432			return (0);
433			pfd = calloc(nfds, sizeof(struct pollfd));
434			if (pfd == NULL) {
435			msgq(sp, M_SYSERR, "malloc");
436			return (1);
437			}
438
439			/* Setup events bitmasks. */
440			nfds = 0;
441			TAILQ_FOREACH(sp, &gp->dq, q)
442			if (F_ISSET(sp, SC_SCRIPT)) {
443			pfd[nfds].fd = sp->script->sh_master;
444			pfd[nfds].events = POLLIN;
445			nfds++;
446			}
447
448			loop:
449			/* Check for input. */
450			switch (poll(pfd, nfds, 0)) {
451			case -1:
452			msgq(sp, M_SYSERR, "poll");
453			rval = 1;
454			/* FALLTHROUGH */
455			case 0:
456			goto done;
457			default:
458			break;
459			}
460
461			/* Read the input. */
462			nfds = 0;
463			TAILQ_FOREACH(sp, &gp->dq, q)
464			if (F_ISSET(sp, SC_SCRIPT)) {
465			if ((pfd[nfds].revents & POLLHUP) && sscr_end(sp))
466			goto done;
467			if ((pfd[nfds].revents & POLLIN) && sscr_insert(sp))
468			goto done;
469			nfds++;
470			}
471			goto loop;
472			done:
473			free(pfd);
474			return (rval);
475			}
476
477			/*
478			* sscr_insert --
479			* Take a line from the shell and insert it into the file.
480			*/
481			static int
482			sscr_insert(SCR *sp)
483			{
484			CHAR_T endp, p, *t;
485			SCRIPT *sc;
486			struct pollfd pfd[1];
487			recno_t lno;
488			size_t blen, len, tlen;
489			u_int value;
490			int nr, rval;
491			char *bp;
492
493			/* Find out where the end of the file is. */
494			if (db_last(sp, &lno))
495			return (1);
496
497			#define MINREAD 1024
498			GET_SPACE_RET(sp, bp, blen, MINREAD);
499			endp = bp;
500
501			/* Read the characters. */
502			rval = 1;
503			sc = sp->script;
504			more: switch (nr = read(sc->sh_master, endp, MINREAD)) {
505			case 0: /* EOF; shell just exited. */
506			sscr_end(sp);
507			rval = 0;
508			goto ret;
509			case -1: /* Error or interrupt. */
510			msgq(sp, M_SYSERR, "shell");
511			goto ret;
512			default:
513			endp += nr;
514			break;
515			}
516
517			/* Append the lines into the file. */
518			for (p = t = bp; p < endp; ++p) {
519			value = KEY_VAL(sp, *p);
520			if (value == K_CR \|\| value == K_NL) {
521			len = p - t;
522			if (db_append(sp, 1, lno++, t, len))
523			goto ret;
524			t = p + 1;
525			}
526			}
527			if (p > t) {
528			len = p - t;
529			/*
530			* If the last thing from the shell isn't another prompt, wait
531			* up to 1/10 of a second for more stuff to show up, so that
532			* we don't break the output into two separate lines. Don't
533			* want to hang indefinitely because some program is hanging,
534			* confused the shell, or whatever.
535			*/
536			if (!sscr_matchprompt(sp, t, len, &tlen) \|\| tlen != 0) {
537			pfd[0].fd = sc->sh_master;
538			pfd[0].events = POLLIN;
539			if (poll(pfd, 1, 100) > 0) {
540			memmove(bp, t, len);
541			endp = bp + len;
542			goto more;
543			}
544			}
545			if (sscr_setprompt(sp, t, len))
546			return (1);
547			if (db_append(sp, 1, lno++, t, len))
548			goto ret;
549			}
550
551			/* The cursor moves to EOF. */
552			sp->lno = lno;
553			sp->cno = len ? len - 1 : 0;
554			rval = vs_refresh(sp, 1);
555
556			ret: FREE_SPACE(sp, bp, blen);
557			return (rval);
558			}
559
560			/*
561			* sscr_setprompt --
562			*
563			* Set the prompt to the last line we got from the shell.
564			*
565			*/
566			static int
567			sscr_setprompt(SCR sp, char buf, size_t len)
568			{
569			SCRIPT *sc;
570
571			sc = sp->script;
572			free(sc->sh_prompt);
573			MALLOC(sp, sc->sh_prompt, len + 1);
574			if (sc->sh_prompt == NULL) {
575			sscr_end(sp);
576			return (1);
577			}
578			memmove(sc->sh_prompt, buf, len);
579			sc->sh_prompt_len = len;
580			sc->sh_prompt[len] = '\0';
581			return (0);
582			}
583
584			/*
585			* sscr_matchprompt --
586			* Check to see if a line matches the prompt. Nul's indicate
587			* parts that can change, in both content and size.
588			*/
589			static int
590			sscr_matchprompt(SCR sp, char lp, size_t line_len, size_t *lenp)
591			{
592			SCRIPT *sc;
593			size_t prompt_len;
594			char *pp;
595
596			sc = sp->script;
597			if (line_len < (prompt_len = sc->sh_prompt_len))
598			return (0);
599
600			for (pp = sc->sh_prompt;
601			prompt_len && line_len; --prompt_len, --line_len) {
602			if (*pp == '\0') {
603			for (; prompt_len && *pp == '\0'; --prompt_len, ++pp);
604			if (!prompt_len)
605			return (0);
606			for (; line_len && lp != pp; --line_len, ++lp);
607			if (!line_len)
608			return (0);
609			}
610			if (pp++ != lp++)
611			break;
612			}
613
614			if (prompt_len)
615			return (0);
616			if (lenp != NULL)
617			*lenp = line_len;
618			return (1);
619			}
620
621			/*
622			* sscr_end --
623			* End the pipe to a shell.
624			*
625			* PUBLIC: int sscr_end(SCR *);
626			*/
627			int
628			sscr_end(SCR *sp)
629			{
630			SCRIPT *sc;
631
632			if ((sc = sp->script) == NULL)
633			return (0);
634
635			/* Turn off the script flags. */
636			F_CLR(sp, SC_SCRIPT);
637			sscr_check(sp);
638
639			/* Close down the parent's file descriptors. */
640			if (sc->sh_master != -1)
641			(void)close(sc->sh_master);
642			if (sc->sh_slave != -1)
643			(void)close(sc->sh_slave);
644
645			/* This should have killed the child. */
646			(void)proc_wait(sp, sc->sh_pid, "script-shell", 0, 0);
647
648			/* Free memory. */
649			free(sc->sh_prompt);
650			free(sc);
651			sp->script = NULL;
652
653			return (0);
654			}
655
656			/*
657			* sscr_check --
658			* Set/clear the global scripting bit.
659			*/
660			static void
661			sscr_check(SCR *sp)
662			{
663			GS *gp;
664
665			gp = sp->gp;
666			TAILQ_FOREACH(sp, &gp->dq, q)
667			if (F_ISSET(sp, SC_SCRIPT)) {
668			F_SET(gp, G_SCRWIN);
669			return;
670			}
671			F_CLR(gp, G_SCRWIN);
672			}