Head

GCC Code Coverage Report

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


/*	$OpenBSD: ex_read.c,v 1.14 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.
 *
 * See the LICENSE file for redistribution information.
 */

#include "config.h"

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

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

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

/*
 * ex_read --	:read [file]
 *		:read [!cmd]
 *	Read from a file or utility.
 *
 * !!!
 * Historical vi wouldn't undo a filter read, for no apparent reason.
 *
 * PUBLIC: int ex_read(SCR *, EXCMD *);
 */
int
ex_read(SCR *sp, EXCMD *cmdp)
{
	enum { R_ARG, R_EXPANDARG, R_FILTER } which;
	struct stat sb;
	CHAR_T *arg, *name;
	EX_PRIVATE *exp;
	FILE *fp;
	FREF *frp;
	GS *gp;
	MARK rm;
	recno_t nlines;
	size_t arglen;
	int argc, rval;
	char *p;

	gp = sp->gp;

	/*
	 * 0 args: read the current pathname.
	 * 1 args: check for "read !arg".
	 */
	switch (cmdp->argc) {
	case 0:
		which = R_ARG;
		arg = NULL;	/* unused */
		arglen = 0;	/* unused */
		break;
	case 1:
		arg = cmdp->argv[0]->bp;
		arglen = cmdp->argv[0]->len;
		if (*arg == '!') {
			++arg;
			--arglen;
			which = R_FILTER;

			/* Secure means no shell access. */
			if (O_ISSET(sp, O_SECURE)) {
				ex_emsg(sp, cmdp->cmd->name, EXM_SECURE_F);
				return (1);
			}
		} else
			which = R_EXPANDARG;
		break;
	default:
		abort();
		/* NOTREACHED */
	}

	/* Load a temporary file if no file being edited. */
	if (sp->ep == NULL) {
		if ((frp = file_add(sp, NULL)) == NULL)
			return (1);
		if (file_init(sp, frp, NULL, 0))
			return (1);
	}

	switch (which) {
	case R_FILTER:
		/*
		 * File name and bang expand the user's argument.  If
		 * we don't get an additional argument, it's illegal.
		 */
		argc = cmdp->argc;
		if (argv_exp1(sp, cmdp, arg, arglen, 1))
			return (1);
		if (argc == cmdp->argc) {
			ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
			return (1);
		}
		argc = cmdp->argc - 1;

		/* Set the last bang command. */
		exp = EXP(sp);
		free(exp->lastbcomm);
		if ((exp->lastbcomm =
		    strdup(cmdp->argv[argc]->bp)) == NULL) {
			msgq(sp, M_SYSERR, NULL);
			return (1);
		}

		/*
		 * Vi redisplayed the user's argument if it changed, ex
		 * always displayed a !, plus the user's argument if it
		 * changed.
		 */
		if (F_ISSET(sp, SC_VI)) {
			if (F_ISSET(cmdp, E_MODIFY))
				(void)vs_update(sp, "!", cmdp->argv[argc]->bp);
		} else {
			if (F_ISSET(cmdp, E_MODIFY))
				(void)ex_printf(sp,
				    "!%s\n", cmdp->argv[argc]->bp);
			else
				(void)ex_puts(sp, "!\n");
			(void)ex_fflush(sp);
		}

		/*
		 * Historically, filter reads as the first ex command didn't
		 * wait for the user. If SC_SCR_EXWROTE not already set, set
		 * the don't-wait flag.
		 */
		if (!F_ISSET(sp, SC_SCR_EXWROTE))
			F_SET(sp, SC_EX_WAIT_NO);

		/*
		 * Switch into ex canonical mode.  The reason to restore the
		 * original terminal modes for read filters is so that users
		 * can do things like ":r! cat /dev/tty".
		 *
		 * !!!
		 * We do not output an extra <newline>, so that we don't touch
		 * the screen on a normal read.
		 */
		if (F_ISSET(sp, SC_VI)) {
			if (gp->scr_screen(sp, SC_EX)) {
				ex_emsg(sp, cmdp->cmd->name, EXM_NOCANON_F);
				return (1);
			}
			/*
			 * !!!
			 * Historically, the read command doesn't switch to
			 * the alternate X11 xterm screen, if doing a filter
			 * read -- don't set SA_ALTERNATE.
			 */
			F_SET(sp, SC_SCR_EX | SC_SCR_EXWROTE);
		}

		if (ex_filter(sp, cmdp, &cmdp->addr1,
		    NULL, &rm, cmdp->argv[argc]->bp, FILTER_READ))
			return (1);

		/* The filter version of read set the autoprint flag. */
		F_SET(cmdp, E_AUTOPRINT);

		/*
		 * If in vi mode, move to the first nonblank.  Might have
		 * switched into ex mode, so saved the original SC_VI value.
		 */
		sp->lno = rm.lno;
		if (F_ISSET(sp, SC_VI)) {
			sp->cno = 0;
			(void)nonblank(sp, sp->lno, &sp->cno);
		}
		return (0);
	case R_ARG:
		name = sp->frp->name;
		break;
	case R_EXPANDARG:
		if (argv_exp2(sp, cmdp, arg, arglen))
			return (1);
		/*
		 *  0 args: impossible.
		 *  1 args: impossible (I hope).
		 *  2 args: read it.
		 * >2 args: object, too many args.
		 *
		 * The 1 args case depends on the argv_sexp() function refusing
		 * to return success without at least one non-blank character.
		 */
		switch (cmdp->argc) {
		case 0:
		case 1:
			abort();
			/* NOTREACHED */
		case 2:
			name = cmdp->argv[1]->bp;
			/*
			 * !!!
			 * Historically, the read and write commands renamed
			 * "unnamed" files, or, if the file had a name, set
			 * the alternate file name.
			 */
			if (F_ISSET(sp->frp, FR_TMPFILE) &&
			    !F_ISSET(sp->frp, FR_EXNAMED)) {
				if ((p = v_strdup(sp, cmdp->argv[1]->bp,
				    cmdp->argv[1]->len)) != NULL) {
					free(sp->frp->name);
					sp->frp->name = p;
				}
				/*
				 * The file has a real name, it's no longer a
				 * temporary, clear the temporary file flags.
				 */
				F_CLR(sp->frp, FR_TMPEXIT | FR_TMPFILE);
				F_SET(sp->frp, FR_NAMECHANGE | FR_EXNAMED);

				/* Notify the screen. */
				(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
			} else
				set_alt_name(sp, name);
			break;
		default:
			ex_emsg(sp, cmdp->argv[0]->bp, EXM_FILECOUNT);
			return (1);

		}
		break;
	default:
		abort();
		/* NOTREACHED */
	}

	/*
	 * !!!
	 * Historically, vi did not permit reads from non-regular files, nor
	 * did it distinguish between "read !" and "read!", so there was no
	 * way to "force" it.  We permit reading from named pipes too, since
	 * they didn't exist when the original implementation of vi was done
	 * and they seem a reasonable addition.
	 */
	if ((fp = fopen(name, "r")) == NULL || fstat(fileno(fp), &sb)) {
		msgq_str(sp, M_SYSERR, name, "%s");
		return (1);
	}
	if (!S_ISFIFO(sb.st_mode) && !S_ISREG(sb.st_mode)) {
		(void)fclose(fp);
		msgq(sp, M_ERR,
		    "Only regular files and named pipes may be read");
		return (1);
	}

	/* Try and get a lock. */
	if (file_lock(sp, NULL, NULL, fileno(fp), 0) == LOCK_UNAVAIL)
		msgq(sp, M_ERR, "%s: read lock was unavailable", name);

	rval = ex_readfp(sp, name, fp, &cmdp->addr1, &nlines, 0);

	/*
	 * In vi, set the cursor to the first line read in, if anything read
	 * in, otherwise, the address.  (Historic vi set it to the line after
	 * the address regardless, but since that line may not exist we don't
	 * bother.)
	 *
	 * In ex, set the cursor to the last line read in, if anything read in,
	 * otherwise, the address.
	 */
	if (F_ISSET(sp, SC_VI)) {
		sp->lno = cmdp->addr1.lno;
		if (nlines)
			++sp->lno;
	} else
		sp->lno = cmdp->addr1.lno + nlines;
	return (rval);
}

/*
 * ex_readfp --
 *	Read lines into the file.
 *
 * PUBLIC: int ex_readfp(SCR *, char *, FILE *, MARK *, recno_t *, int);
 */
int
ex_readfp(SCR *sp, char *name, FILE *fp, MARK *fm, recno_t *nlinesp,
    int silent)
{
	EX_PRIVATE *exp;
	GS *gp;
	recno_t lcnt, lno;
	size_t len;
	u_long ccnt;			/* XXX: can't print off_t portably. */
	int nf, rval;
	char *p;

	gp = sp->gp;
	exp = EXP(sp);

	/*
	 * Add in the lines from the output.  Insertion starts at the line
	 * following the address.
	 */
	ccnt = 0;
	lcnt = 0;
	p = "Reading...";
	for (lno = fm->lno; !ex_getline(sp, fp, &len); ++lno, ++lcnt) {
		if ((lcnt + 1) % INTERRUPT_CHECK == 0) {
			if (INTERRUPTED(sp))
				break;
			if (!silent) {
				gp->scr_busy(sp, p,
				    p == NULL ? BUSY_UPDATE : BUSY_ON);
				p = NULL;
			}
		}
		if (db_append(sp, 1, lno, exp->ibp, len))
			goto err;
		ccnt += len;
	}

	if (ferror(fp) || fclose(fp))
		goto err;

	/* Return the number of lines read in. */
	if (nlinesp != NULL)
		*nlinesp = lcnt;

	if (!silent) {
		p = msg_print(sp, name, &nf);
		msgq(sp, M_INFO,
		    "%s: %lu lines, %lu characters", p, lcnt, ccnt);
		if (nf)
			FREE_SPACE(sp, p, 0);
	}

	rval = 0;
	if (0) {
err:		msgq_str(sp, M_SYSERR, name, "%s");
		(void)fclose(fp);
		rval = 1;
	}

	if (!silent)
		gp->scr_busy(sp, NULL, BUSY_OFF);
	return (rval);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: ex_read.c,v 1.14 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			* See the LICENSE file for redistribution information.
10			*/
11
12			#include "config.h"
13
14			#include <sys/types.h>
15			#include <sys/queue.h>
16			#include <sys/stat.h>
17			#include <sys/time.h>
18
19			#include <bitstring.h>
20			#include <ctype.h>
21			#include <errno.h>
22			#include <limits.h>
23			#include <stdio.h>
24			#include <stdlib.h>
25			#include <string.h>
26
27			#include "../common/common.h"
28			#include "../vi/vi.h"
29
30			/*
31			* ex_read -- :read [file]
32			* :read [!cmd]
33			* Read from a file or utility.
34			*
35			* !!!
36			* Historical vi wouldn't undo a filter read, for no apparent reason.
37			*
38			* PUBLIC: int ex_read(SCR , EXCMD );
39			*/
40			int
41			ex_read(SCR sp, EXCMD cmdp)
42			{
43			enum { R_ARG, R_EXPANDARG, R_FILTER } which;
44			struct stat sb;
45			CHAR_T arg, name;
46			EX_PRIVATE *exp;
47			FILE *fp;
48			FREF *frp;
49			GS *gp;
50			MARK rm;
51			recno_t nlines;
52			size_t arglen;
53			int argc, rval;
54			char *p;
55
56			gp = sp->gp;
57
58			/*
59			* 0 args: read the current pathname.
60			* 1 args: check for "read !arg".
61			*/
62			switch (cmdp->argc) {
63			case 0:
64			which = R_ARG;
65			arg = NULL; /* unused */
66			arglen = 0; /* unused */
67			break;
68			case 1:
69			arg = cmdp->argv[0]->bp;
70			arglen = cmdp->argv[0]->len;
71			if (*arg == '!') {
72			++arg;
73			--arglen;
74			which = R_FILTER;
75
76			/* Secure means no shell access. */
77			if (O_ISSET(sp, O_SECURE)) {
78			ex_emsg(sp, cmdp->cmd->name, EXM_SECURE_F);
79			return (1);
80			}
81			} else
82			which = R_EXPANDARG;
83			break;
84			default:
85			abort();
86			/* NOTREACHED */
87			}
88
89			/* Load a temporary file if no file being edited. */
90			if (sp->ep == NULL) {
91			if ((frp = file_add(sp, NULL)) == NULL)
92			return (1);
93			if (file_init(sp, frp, NULL, 0))
94			return (1);
95			}
96
97			switch (which) {
98			case R_FILTER:
99			/*
100			* File name and bang expand the user's argument. If
101			* we don't get an additional argument, it's illegal.
102			*/
103			argc = cmdp->argc;
104			if (argv_exp1(sp, cmdp, arg, arglen, 1))
105			return (1);
106			if (argc == cmdp->argc) {
107			ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
108			return (1);
109			}
110			argc = cmdp->argc - 1;
111
112			/* Set the last bang command. */
113			exp = EXP(sp);
114			free(exp->lastbcomm);
115			if ((exp->lastbcomm =
116			strdup(cmdp->argv[argc]->bp)) == NULL) {
117			msgq(sp, M_SYSERR, NULL);
118			return (1);
119			}
120
121			/*
122			* Vi redisplayed the user's argument if it changed, ex
123			* always displayed a !, plus the user's argument if it
124			* changed.
125			*/
126			if (F_ISSET(sp, SC_VI)) {
127			if (F_ISSET(cmdp, E_MODIFY))
128			(void)vs_update(sp, "!", cmdp->argv[argc]->bp);
129			} else {
130			if (F_ISSET(cmdp, E_MODIFY))
131			(void)ex_printf(sp,
132			"!%s\n", cmdp->argv[argc]->bp);
133			else
134			(void)ex_puts(sp, "!\n");
135			(void)ex_fflush(sp);
136			}
137
138			/*
139			* Historically, filter reads as the first ex command didn't
140			* wait for the user. If SC_SCR_EXWROTE not already set, set
141			* the don't-wait flag.
142			*/
143			if (!F_ISSET(sp, SC_SCR_EXWROTE))
144			F_SET(sp, SC_EX_WAIT_NO);
145
146			/*
147			* Switch into ex canonical mode. The reason to restore the
148			* original terminal modes for read filters is so that users
149			* can do things like ":r! cat /dev/tty".
150			*
151			* !!!
152			* We do not output an extra <newline>, so that we don't touch
153			* the screen on a normal read.
154			*/
155			if (F_ISSET(sp, SC_VI)) {
156			if (gp->scr_screen(sp, SC_EX)) {
157			ex_emsg(sp, cmdp->cmd->name, EXM_NOCANON_F);
158			return (1);
159			}
160			/*
161			* !!!
162			* Historically, the read command doesn't switch to
163			* the alternate X11 xterm screen, if doing a filter
164			* read -- don't set SA_ALTERNATE.
165			*/
166			F_SET(sp, SC_SCR_EX \| SC_SCR_EXWROTE);
167			}
168
169			if (ex_filter(sp, cmdp, &cmdp->addr1,
170			NULL, &rm, cmdp->argv[argc]->bp, FILTER_READ))
171			return (1);
172
173			/* The filter version of read set the autoprint flag. */
174			F_SET(cmdp, E_AUTOPRINT);
175
176			/*
177			* If in vi mode, move to the first nonblank. Might have
178			* switched into ex mode, so saved the original SC_VI value.
179			*/
180			sp->lno = rm.lno;
181			if (F_ISSET(sp, SC_VI)) {
182			sp->cno = 0;
183			(void)nonblank(sp, sp->lno, &sp->cno);
184			}
185			return (0);
186			case R_ARG:
187			name = sp->frp->name;
188			break;
189			case R_EXPANDARG:
190			if (argv_exp2(sp, cmdp, arg, arglen))
191			return (1);
192			/*
193			* 0 args: impossible.
194			* 1 args: impossible (I hope).
195			* 2 args: read it.
196			* >2 args: object, too many args.
197			*
198			* The 1 args case depends on the argv_sexp() function refusing
199			* to return success without at least one non-blank character.
200			*/
201			switch (cmdp->argc) {
202			case 0:
203			case 1:
204			abort();
205			/* NOTREACHED */
206			case 2:
207			name = cmdp->argv[1]->bp;
208			/*
209			* !!!
210			* Historically, the read and write commands renamed
211			* "unnamed" files, or, if the file had a name, set
212			* the alternate file name.
213			*/
214			if (F_ISSET(sp->frp, FR_TMPFILE) &&
215			!F_ISSET(sp->frp, FR_EXNAMED)) {
216			if ((p = v_strdup(sp, cmdp->argv[1]->bp,
217			cmdp->argv[1]->len)) != NULL) {
218			free(sp->frp->name);
219			sp->frp->name = p;
220			}
221			/*
222			* The file has a real name, it's no longer a
223			* temporary, clear the temporary file flags.
224			*/
225			F_CLR(sp->frp, FR_TMPEXIT \| FR_TMPFILE);
226			F_SET(sp->frp, FR_NAMECHANGE \| FR_EXNAMED);
227
228			/* Notify the screen. */
229			(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
230			} else
231			set_alt_name(sp, name);
232			break;
233			default:
234			ex_emsg(sp, cmdp->argv[0]->bp, EXM_FILECOUNT);
235			return (1);
236
237			}
238			break;
239			default:
240			abort();
241			/* NOTREACHED */
242			}
243
244			/*
245			* !!!
246			* Historically, vi did not permit reads from non-regular files, nor
247			* did it distinguish between "read !" and "read!", so there was no
248			* way to "force" it. We permit reading from named pipes too, since
249			* they didn't exist when the original implementation of vi was done
250			* and they seem a reasonable addition.
251			*/
252			if ((fp = fopen(name, "r")) == NULL \|\| fstat(fileno(fp), &sb)) {
253			msgq_str(sp, M_SYSERR, name, "%s");
254			return (1);
255			}
256			if (!S_ISFIFO(sb.st_mode) && !S_ISREG(sb.st_mode)) {
257			(void)fclose(fp);
258			msgq(sp, M_ERR,
259			"Only regular files and named pipes may be read");
260			return (1);
261			}
262
263			/* Try and get a lock. */
264			if (file_lock(sp, NULL, NULL, fileno(fp), 0) == LOCK_UNAVAIL)
265			msgq(sp, M_ERR, "%s: read lock was unavailable", name);
266
267			rval = ex_readfp(sp, name, fp, &cmdp->addr1, &nlines, 0);
268
269			/*
270			* In vi, set the cursor to the first line read in, if anything read
271			* in, otherwise, the address. (Historic vi set it to the line after
272			* the address regardless, but since that line may not exist we don't
273			* bother.)
274			*
275			* In ex, set the cursor to the last line read in, if anything read in,
276			* otherwise, the address.
277			*/
278			if (F_ISSET(sp, SC_VI)) {
279			sp->lno = cmdp->addr1.lno;
280			if (nlines)
281			++sp->lno;
282			} else
283			sp->lno = cmdp->addr1.lno + nlines;
284			return (rval);
285			}
286
287			/*
288			* ex_readfp --
289			* Read lines into the file.
290			*
291			* PUBLIC: int ex_readfp(SCR , char , FILE , MARK , recno_t *, int);
292			*/
293			int
294			ex_readfp(SCR sp, char name, FILE fp, MARK fm, recno_t *nlinesp,
295			int silent)
296			{
297			EX_PRIVATE *exp;
298			GS *gp;
299			recno_t lcnt, lno;
300			size_t len;
301			u_long ccnt; /* XXX: can't print off_t portably. */
302			int nf, rval;
303			char *p;
304
305			gp = sp->gp;
306			exp = EXP(sp);
307
308			/*
309			* Add in the lines from the output. Insertion starts at the line
310			* following the address.
311			*/
312			ccnt = 0;
313			lcnt = 0;
314			p = "Reading...";
315			for (lno = fm->lno; !ex_getline(sp, fp, &len); ++lno, ++lcnt) {
316			if ((lcnt + 1) % INTERRUPT_CHECK == 0) {
317			if (INTERRUPTED(sp))
318			break;
319			if (!silent) {
320			gp->scr_busy(sp, p,
321			p == NULL ? BUSY_UPDATE : BUSY_ON);
322			p = NULL;
323			}
324			}
325			if (db_append(sp, 1, lno, exp->ibp, len))
326			goto err;
327			ccnt += len;
328			}
329
330			if (ferror(fp) \|\| fclose(fp))
331			goto err;
332
333			/* Return the number of lines read in. */
334			if (nlinesp != NULL)
335			*nlinesp = lcnt;
336
337			if (!silent) {
338			p = msg_print(sp, name, &nf);
339			msgq(sp, M_INFO,
340			"%s: %lu lines, %lu characters", p, lcnt, ccnt);
341			if (nf)
342			FREE_SPACE(sp, p, 0);
343			}
344
345			rval = 0;
346			if (0) {
347			err: msgq_str(sp, M_SYSERR, name, "%s");
348			(void)fclose(fp);
349			rval = 1;
350			}
351
352			if (!silent)
353			gp->scr_busy(sp, NULL, BUSY_OFF);
354			return (rval);
355			}