Head

GCC Code Coverage Report

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


/*	$OpenBSD: ex_filter.c,v 1.15 2016/08/01 18:27:35 bentley Exp $	*/

/*-
 * Copyright (c) 1991, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1991, 1993, 1994, 1995, 1996
 *	Keith Bostic.  All rights reserved.
 *
 * See the LICENSE file for redistribution information.
 */

#include "config.h"

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/queue.h>

#include <bitstring.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "../common/common.h"

static int filter_ldisplay(SCR *, FILE *);

/*
 * ex_filter --
 *	Run a range of lines through a filter utility and optionally
 *	replace the original text with the stdout/stderr output of
 *	the utility.
 *
 * PUBLIC: int ex_filter(SCR *,
 * PUBLIC:    EXCMD *, MARK *, MARK *, MARK *, char *, enum filtertype);
 */
int
ex_filter(SCR *sp, EXCMD *cmdp, MARK *fm, MARK *tm, MARK *rp, char *cmd,
    enum filtertype ftype)
{
	FILE *ifp, *ofp;
	pid_t parent_writer_pid, utility_pid;
	recno_t nread;
	int input[2], output[2], fd, rval;
	char *name, tname[] = "/tmp/vi.XXXXXXXXXX";

	rval = 0;

	/* Set return cursor position, which is never less than line 1. */
	*rp = *fm;
	if (rp->lno == 0)
		rp->lno = 1;

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

	/*
	 * There are three different processes running through this code.
	 * They are the utility, the parent-writer and the parent-reader.
	 * The parent-writer is the process that writes from the file to
	 * the utility, the parent reader is the process that reads from
	 * the utility.
	 *
	 * Input and output are named from the utility's point of view.
	 * The utility reads from input[0] and the parent(s) write to
	 * input[1].  The parent(s) read from output[0] and the utility
	 * writes to output[1].
	 *
	 * !!!
	 * Historically, in the FILTER_READ case, the utility reads from
	 * the terminal (e.g. :r! cat works).  Otherwise open up utility
	 * input pipe.
	 */
	ofp = NULL;
	input[0] = input[1] = output[0] = output[1] = -1;

	if (ftype == FILTER_BANG) {
		fd = mkstemp(tname);
		if (fd == -1) {
			msgq(sp, M_SYSERR,
			    "Unable to create temporary file");
			if (fd != -1) {
				(void)close(fd);
				(void)unlink(tname);
			}
			goto err;
		}
		if (unlink(tname) == -1)
			msgq(sp, M_SYSERR, "unlink");
		if ((ifp = fdopen(fd, "w")) == NULL) {
			msgq(sp, M_SYSERR, "fdopen");
			(void)close(fd);
			goto err;
		}
		if ((input[0] = dup(fd)) == -1) {
			msgq(sp, M_SYSERR, "dup");
			(void)fclose(ifp);
			goto err;
		}
		/*
		 * Write the selected lines into the temporary file.
		 * This instance of ifp is closed by ex_writefp.
		 */
		if (ex_writefp(sp, "filter", ifp, fm, tm, NULL, NULL, 1))
			goto err;
		if (lseek(input[0], 0, SEEK_SET) == -1) {
			msgq(sp, M_SYSERR, "lseek");
			goto err;
		}
	} else if (ftype != FILTER_READ && pipe(input) < 0) {
		msgq(sp, M_SYSERR, "pipe");
		goto err;
	}

	/* Open up utility output pipe. */
	if (pipe(output) < 0) {
		msgq(sp, M_SYSERR, "pipe");
		goto err;
	}
	if ((ofp = fdopen(output[0], "r")) == NULL) {
		msgq(sp, M_SYSERR, "fdopen");
		goto err;
	}

	/* Fork off the utility process. */
	switch (utility_pid = vfork()) {
	case -1:			/* Error. */
		msgq(sp, M_SYSERR, "vfork");
err:		if (input[0] != -1)
			(void)close(input[0]);
		if (input[1] != -1)
			(void)close(input[1]);
		if (ofp != NULL)
			(void)fclose(ofp);
		else if (output[0] != -1)
			(void)close(output[0]);
		if (output[1] != -1)
			(void)close(output[1]);
		return (1);
	case 0:				/* Utility. */
		/*
		 * Redirect stdin from the read end of the input pipe, and
		 * redirect stdout/stderr to the write end of the output pipe.
		 *
		 * !!!
		 * Historically, ex only directed stdout into the input pipe,
		 * letting stderr come out on the terminal as usual.  Vi did
		 * not, directing both stdout and stderr into the input pipe.
		 * We match that practice in both ex and vi for consistency.
		 */
		if (input[0] != -1)
			(void)dup2(input[0], STDIN_FILENO);
		(void)dup2(output[1], STDOUT_FILENO);
		(void)dup2(output[1], STDERR_FILENO);

		/* Close the utility's file descriptors. */
		if (input[0] != -1)
			(void)close(input[0]);
		if (input[1] != -1)
			(void)close(input[1]);
		(void)close(output[0]);
		(void)close(output[1]);

		if ((name = strrchr(O_STR(sp, O_SHELL), '/')) == NULL)
			name = O_STR(sp, O_SHELL);
		else
			++name;

		execl(O_STR(sp, O_SHELL), name, "-c", cmd, (char *)NULL);
		msgq_str(sp, M_SYSERR, O_STR(sp, O_SHELL), "execl: %s");
		_exit (127);
		/* NOTREACHED */
	default:			/* Parent-reader, parent-writer. */
		/* Close the pipe ends neither parent will use. */
		if (input[0] != -1)
			(void)close(input[0]);
		(void)close(output[1]);
		break;
	}

	/*
	 * FILTER_RBANG, FILTER_READ:
	 *
	 * Reading is the simple case -- we don't need a parent writer,
	 * so the parent reads the output from the read end of the output
	 * pipe until it finishes, then waits for the child.  Ex_readfp
	 * appends to the MARK, and closes ofp.
	 *
	 * For FILTER_RBANG, there is nothing to write to the utility.
	 * Make sure it doesn't wait forever by closing its standard
	 * input.
	 *
	 * !!!
	 * Set the return cursor to the last line read in for FILTER_READ.
	 * Historically, this behaves differently from ":r file" command,
	 * which leaves the cursor at the first line read in.  Check to
	 * make sure that it's not past EOF because we were reading into an
	 * empty file.
	 */
	if (ftype == FILTER_RBANG || ftype == FILTER_READ) {
		if (ftype == FILTER_RBANG)
			(void)close(input[1]);

		if (ex_readfp(sp, "filter", ofp, fm, &nread, 1))
			rval = 1;
		sp->rptlines[L_ADDED] += nread;
		if (ftype == FILTER_READ) {
			if (fm->lno == 0)
				rp->lno = nread;
			else
				rp->lno += nread;
		}
	}

	/*
	 * FILTER_WRITE
	 *
	 * Here we need both a reader and a writer.  Temporary files are
	 * expensive and we'd like to avoid disk I/O.  Using pipes has the
	 * obvious starvation conditions.  It's done as follows:
	 *
	 *	fork
	 *	child
	 *		write lines out
	 *		exit
	 *	parent
	 *		read and display lines
	 *		wait for child
	 *
	 * We get away without locking the underlying database because we know
	 * that filter_ldisplay() does not modify it.  When the DB code has
	 * locking, we should treat vi as if it were multiple applications
	 * sharing a database, and do the required locking.  If necessary a
	 * work-around would be to do explicit locking in the line.c:db_get()
	 * code, based on the flag set here.
	 */
	if (ftype == FILTER_WRITE) {
		F_SET(sp->ep, F_MULTILOCK);
		switch (parent_writer_pid = fork()) {
		case -1:		/* Error. */
			msgq(sp, M_SYSERR, "fork");
			(void)close(input[1]);
			(void)close(output[0]);
			rval = 1;
			break;
		case 0:			/* Parent-writer. */
			/*
			 * Write the selected lines to the write end of the
			 * input pipe.  This instance of ifp is closed by
			 * ex_writefp.
			 */
			(void)close(output[0]);
			if ((ifp = fdopen(input[1], "w")) == NULL)
				_exit (1);
			_exit(ex_writefp(sp, "filter",
			    ifp, fm, tm, NULL, NULL, 1));
			/* NOTREACHED */
		default:		/* Parent-reader. */
			(void)close(input[1]);
			/*
			 * Read the output from the read end of the output
			 * pipe and display it.  Filter_ldisplay closes ofp.
			 */
			if (filter_ldisplay(sp, ofp))
				rval = 1;

			/* Wait for the parent-writer. */
			if (proc_wait(sp,
			    parent_writer_pid, "parent-writer", 0, 1))
				rval = 1;
			break;
		}
		F_CLR(sp->ep, F_MULTILOCK);
	}

	/*
	 * FILTER_BANG
	 *
	 * Here we need a temporary file because our database lacks locking.
	 *
	 * XXX
	 * Temporary files are expensive and we'd like to avoid disk I/O.
	 * When the DB code has locking, we should treat vi as if it were
	 * multiple applications sharing a database, and do the required
	 * locking.  If necessary a work-around would be to do explicit
	 * locking in the line.c:db_get() code, based on F_MULTILOCK flag set
	 * here.
	 */
	if (ftype == FILTER_BANG) {
		/*
		 * Read the output from the read end of the output
		 * pipe.  Ex_readfp appends to the MARK and closes
		 * ofp.
		 */
		if (ex_readfp(sp, "filter", ofp, tm, &nread, 1))
			rval = 1;
		sp->rptlines[L_ADDED] += nread;

		/* Delete any lines written to the utility. */
		if (rval == 0 &&
		    (cut(sp, NULL, fm, tm, CUT_LINEMODE) ||
		    del(sp, fm, tm, 1))) {
			rval = 1;
			goto uwait;
		}

		/*
		 * If the filter had no output, we may have just deleted
		 * the cursor.  Don't do any real error correction, we'll
		 * try and recover later.
		 */
		 if (rp->lno > 1 && !db_exist(sp, rp->lno))
			--rp->lno;
	}

	/*
	 * !!!
	 * Ignore errors on vi file reads, to make reads prettier.  It's
	 * completely inconsistent, and historic practice.
	 */
uwait:	return (proc_wait(sp, utility_pid, cmd,
	    ftype == FILTER_READ && F_ISSET(sp, SC_VI) ? 1 : 0, 0) || rval);
}

/*
 * filter_ldisplay --
 *	Display output from a utility.
 *
 * !!!
 * Historically, the characters were passed unmodified to the terminal.
 * We use the ex print routines to make sure they're printable.
 */
static int
filter_ldisplay(SCR *sp, FILE *fp)
{
	size_t len;

	EX_PRIVATE *exp;

	for (exp = EXP(sp); !ex_getline(sp, fp, &len) && !INTERRUPTED(sp);)
		if (ex_ldisplay(sp, exp->ibp, len, 0, 0))
			break;
	if (ferror(fp))
		msgq(sp, M_SYSERR, "filter read");
	(void)fclose(fp);
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: ex_filter.c,v 1.15 2016/08/01 18:27:35 bentley Exp $ */
2
3			/*-
4			* Copyright (c) 1991, 1993, 1994
5			* The Regents of the University of California. All rights reserved.
6			* Copyright (c) 1991, 1993, 1994, 1995, 1996
7			* Keith Bostic. All rights reserved.
8			*
9			* See the LICENSE file for redistribution information.
10			*/
11
12			#include "config.h"
13
14			#include <sys/stat.h>
15			#include <sys/types.h>
16			#include <sys/queue.h>
17
18			#include <bitstring.h>
19			#include <errno.h>
20			#include <fcntl.h>
21			#include <limits.h>
22			#include <stdio.h>
23			#include <stdlib.h>
24			#include <string.h>
25			#include <unistd.h>
26
27			#include "../common/common.h"
28
29			static int filter_ldisplay(SCR , FILE );
30
31			/*
32			* ex_filter --
33			* Run a range of lines through a filter utility and optionally
34			* replace the original text with the stdout/stderr output of
35			* the utility.
36			*
37			* PUBLIC: int ex_filter(SCR *,
38			* PUBLIC: EXCMD , MARK , MARK , MARK , char *, enum filtertype);
39			*/
40			int
41			ex_filter(SCR sp, EXCMD cmdp, MARK fm, MARK tm, MARK rp, char cmd,
42			enum filtertype ftype)
43			{
44			FILE ifp, ofp;
45			pid_t parent_writer_pid, utility_pid;
46			recno_t nread;
47			int input[2], output[2], fd, rval;
48			char *name, tname[] = "/tmp/vi.XXXXXXXXXX";
49
50			rval = 0;
51
52			/* Set return cursor position, which is never less than line 1. */
53			rp = fm;
54			if (rp->lno == 0)
55			rp->lno = 1;
56
57			/* We're going to need a shell. */
58			if (opts_empty(sp, O_SHELL, 0))
59			return (1);
60
61			/*
62			* There are three different processes running through this code.
63			* They are the utility, the parent-writer and the parent-reader.
64			* The parent-writer is the process that writes from the file to
65			* the utility, the parent reader is the process that reads from
66			* the utility.
67			*
68			* Input and output are named from the utility's point of view.
69			* The utility reads from input[0] and the parent(s) write to
70			* input[1]. The parent(s) read from output[0] and the utility
71			* writes to output[1].
72			*
73			* !!!
74			* Historically, in the FILTER_READ case, the utility reads from
75			* the terminal (e.g. :r! cat works). Otherwise open up utility
76			* input pipe.
77			*/
78			ofp = NULL;
79			input[0] = input[1] = output[0] = output[1] = -1;
80
81			if (ftype == FILTER_BANG) {
82			fd = mkstemp(tname);
83			if (fd == -1) {
84			msgq(sp, M_SYSERR,
85			"Unable to create temporary file");
86			if (fd != -1) {
87			(void)close(fd);
88			(void)unlink(tname);
89			}
90			goto err;
91			}
92			if (unlink(tname) == -1)
93			msgq(sp, M_SYSERR, "unlink");
94			if ((ifp = fdopen(fd, "w")) == NULL) {
95			msgq(sp, M_SYSERR, "fdopen");
96			(void)close(fd);
97			goto err;
98			}
99			if ((input[0] = dup(fd)) == -1) {
100			msgq(sp, M_SYSERR, "dup");
101			(void)fclose(ifp);
102			goto err;
103			}
104			/*
105			* Write the selected lines into the temporary file.
106			* This instance of ifp is closed by ex_writefp.
107			*/
108			if (ex_writefp(sp, "filter", ifp, fm, tm, NULL, NULL, 1))
109			goto err;
110			if (lseek(input[0], 0, SEEK_SET) == -1) {
111			msgq(sp, M_SYSERR, "lseek");
112			goto err;
113			}
114			} else if (ftype != FILTER_READ && pipe(input) < 0) {
115			msgq(sp, M_SYSERR, "pipe");
116			goto err;
117			}
118
119			/* Open up utility output pipe. */
120			if (pipe(output) < 0) {
121			msgq(sp, M_SYSERR, "pipe");
122			goto err;
123			}
124			if ((ofp = fdopen(output[0], "r")) == NULL) {
125			msgq(sp, M_SYSERR, "fdopen");
126			goto err;
127			}
128
129			/* Fork off the utility process. */
130			switch (utility_pid = vfork()) {
131			case -1: /* Error. */
132			msgq(sp, M_SYSERR, "vfork");
133			err: if (input[0] != -1)
134			(void)close(input[0]);
135			if (input[1] != -1)
136			(void)close(input[1]);
137			if (ofp != NULL)
138			(void)fclose(ofp);
139			else if (output[0] != -1)
140			(void)close(output[0]);
141			if (output[1] != -1)
142			(void)close(output[1]);
143			return (1);
144			case 0: /* Utility. */
145			/*
146			* Redirect stdin from the read end of the input pipe, and
147			* redirect stdout/stderr to the write end of the output pipe.
148			*
149			* !!!
150			* Historically, ex only directed stdout into the input pipe,
151			* letting stderr come out on the terminal as usual. Vi did
152			* not, directing both stdout and stderr into the input pipe.
153			* We match that practice in both ex and vi for consistency.
154			*/
155			if (input[0] != -1)
156			(void)dup2(input[0], STDIN_FILENO);
157			(void)dup2(output[1], STDOUT_FILENO);
158			(void)dup2(output[1], STDERR_FILENO);
159
160			/* Close the utility's file descriptors. */
161			if (input[0] != -1)
162			(void)close(input[0]);
163			if (input[1] != -1)
164			(void)close(input[1]);
165			(void)close(output[0]);
166			(void)close(output[1]);
167
168			if ((name = strrchr(O_STR(sp, O_SHELL), '/')) == NULL)
169			name = O_STR(sp, O_SHELL);
170			else
171			++name;
172
173			execl(O_STR(sp, O_SHELL), name, "-c", cmd, (char *)NULL);
174			msgq_str(sp, M_SYSERR, O_STR(sp, O_SHELL), "execl: %s");
175			_exit (127);
176			/* NOTREACHED */
177			default: /* Parent-reader, parent-writer. */
178			/* Close the pipe ends neither parent will use. */
179			if (input[0] != -1)
180			(void)close(input[0]);
181			(void)close(output[1]);
182			break;
183			}
184
185			/*
186			* FILTER_RBANG, FILTER_READ:
187			*
188			* Reading is the simple case -- we don't need a parent writer,
189			* so the parent reads the output from the read end of the output
190			* pipe until it finishes, then waits for the child. Ex_readfp
191			* appends to the MARK, and closes ofp.
192			*
193			* For FILTER_RBANG, there is nothing to write to the utility.
194			* Make sure it doesn't wait forever by closing its standard
195			* input.
196			*
197			* !!!
198			* Set the return cursor to the last line read in for FILTER_READ.
199			* Historically, this behaves differently from ":r file" command,
200			* which leaves the cursor at the first line read in. Check to
201			* make sure that it's not past EOF because we were reading into an
202			* empty file.
203			*/
204			if (ftype == FILTER_RBANG \|\| ftype == FILTER_READ) {
205			if (ftype == FILTER_RBANG)
206			(void)close(input[1]);
207
208			if (ex_readfp(sp, "filter", ofp, fm, &nread, 1))
209			rval = 1;
210			sp->rptlines[L_ADDED] += nread;
211			if (ftype == FILTER_READ) {
212			if (fm->lno == 0)
213			rp->lno = nread;
214			else
215			rp->lno += nread;
216			}
217			}
218
219			/*
220			* FILTER_WRITE
221			*
222			* Here we need both a reader and a writer. Temporary files are
223			* expensive and we'd like to avoid disk I/O. Using pipes has the
224			* obvious starvation conditions. It's done as follows:
225			*
226			* fork
227			* child
228			* write lines out
229			* exit
230			* parent
231			* read and display lines
232			* wait for child
233			*
234			* We get away without locking the underlying database because we know
235			* that filter_ldisplay() does not modify it. When the DB code has
236			* locking, we should treat vi as if it were multiple applications
237			* sharing a database, and do the required locking. If necessary a
238			* work-around would be to do explicit locking in the line.c:db_get()
239			* code, based on the flag set here.
240			*/
241			if (ftype == FILTER_WRITE) {
242			F_SET(sp->ep, F_MULTILOCK);
243			switch (parent_writer_pid = fork()) {
244			case -1: /* Error. */
245			msgq(sp, M_SYSERR, "fork");
246			(void)close(input[1]);
247			(void)close(output[0]);
248			rval = 1;
249			break;
250			case 0: /* Parent-writer. */
251			/*
252			* Write the selected lines to the write end of the
253			* input pipe. This instance of ifp is closed by
254			* ex_writefp.
255			*/
256			(void)close(output[0]);
257			if ((ifp = fdopen(input[1], "w")) == NULL)
258			_exit (1);
259			_exit(ex_writefp(sp, "filter",
260			ifp, fm, tm, NULL, NULL, 1));
261			/* NOTREACHED */
262			default: /* Parent-reader. */
263			(void)close(input[1]);
264			/*
265			* Read the output from the read end of the output
266			* pipe and display it. Filter_ldisplay closes ofp.
267			*/
268			if (filter_ldisplay(sp, ofp))
269			rval = 1;
270
271			/* Wait for the parent-writer. */
272			if (proc_wait(sp,
273			parent_writer_pid, "parent-writer", 0, 1))
274			rval = 1;
275			break;
276			}
277			F_CLR(sp->ep, F_MULTILOCK);
278			}
279
280			/*
281			* FILTER_BANG
282			*
283			* Here we need a temporary file because our database lacks locking.
284			*
285			* XXX
286			* Temporary files are expensive and we'd like to avoid disk I/O.
287			* When the DB code has locking, we should treat vi as if it were
288			* multiple applications sharing a database, and do the required
289			* locking. If necessary a work-around would be to do explicit
290			* locking in the line.c:db_get() code, based on F_MULTILOCK flag set
291			* here.
292			*/
293			if (ftype == FILTER_BANG) {
294			/*
295			* Read the output from the read end of the output
296			* pipe. Ex_readfp appends to the MARK and closes
297			* ofp.
298			*/
299			if (ex_readfp(sp, "filter", ofp, tm, &nread, 1))
300			rval = 1;
301			sp->rptlines[L_ADDED] += nread;
302
303			/* Delete any lines written to the utility. */
304			if (rval == 0 &&
305			(cut(sp, NULL, fm, tm, CUT_LINEMODE) \|\|
306			del(sp, fm, tm, 1))) {
307			rval = 1;
308			goto uwait;
309			}
310
311			/*
312			* If the filter had no output, we may have just deleted
313			* the cursor. Don't do any real error correction, we'll
314			* try and recover later.
315			*/
316			if (rp->lno > 1 && !db_exist(sp, rp->lno))
317			--rp->lno;
318			}
319
320			/*
321			* !!!
322			* Ignore errors on vi file reads, to make reads prettier. It's
323			* completely inconsistent, and historic practice.
324			*/
325			uwait: return (proc_wait(sp, utility_pid, cmd,
326			ftype == FILTER_READ && F_ISSET(sp, SC_VI) ? 1 : 0, 0) \|\| rval);
327			}
328
329			/*
330			* filter_ldisplay --
331			* Display output from a utility.
332			*
333			* !!!
334			* Historically, the characters were passed unmodified to the terminal.
335			* We use the ex print routines to make sure they're printable.
336			*/
337			static int
338			filter_ldisplay(SCR sp, FILE fp)
339			{
340			size_t len;
341
342			EX_PRIVATE *exp;
343
344			for (exp = EXP(sp); !ex_getline(sp, fp, &len) && !INTERRUPTED(sp);)
345			if (ex_ldisplay(sp, exp->ibp, len, 0, 0))
346			break;
347			if (ferror(fp))
348			msgq(sp, M_SYSERR, "filter read");
349			(void)fclose(fp);
350			return (0);
351			}