Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/vi/build/../cl/cl_read.c	Lines:	0	97	0.0 %
Date:	2017-11-07	Branches:	0	67	0.0 %


/*	$OpenBSD: cl_read.c,v 1.21 2016/05/27 09:18:11 martijn Exp $	*/

/*-
 * Copyright (c) 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 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/time.h>

#include <bitstring.h>
#include <curses.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

#include "../common/common.h"
#include "../ex/script.h"
#include "cl.h"

static input_t	cl_read(SCR *,
		    u_int32_t, CHAR_T *, size_t, int *, struct timeval *);
static int	cl_resize(SCR *, size_t, size_t);

/*
 * cl_event --
 *	Return a single event.
 *
 * PUBLIC: int cl_event(SCR *, EVENT *, u_int32_t, int);
 */
int
cl_event(SCR *sp, EVENT *evp, u_int32_t flags, int ms)
{
	struct timeval t, *tp;
	CL_PRIVATE *clp;
	size_t lines, columns;
	int changed, nr;

	/*
	 * Queue signal based events.  We never clear SIGHUP or SIGTERM events,
	 * so that we just keep returning them until the editor dies.
	 */
	clp = CLP(sp);
retest:	if (LF_ISSET(EC_INTERRUPT) || F_ISSET(clp, CL_SIGINT)) {
		if (F_ISSET(clp, CL_SIGINT)) {
			F_CLR(clp, CL_SIGINT);
			evp->e_event = E_INTERRUPT;
		} else
			evp->e_event = E_TIMEOUT;
		return (0);
	}
	if (F_ISSET(clp, CL_SIGHUP | CL_SIGTERM | CL_SIGWINCH)) {
		if (F_ISSET(clp, CL_SIGHUP)) {
			evp->e_event = E_SIGHUP;
			return (0);
		}
		if (F_ISSET(clp, CL_SIGTERM)) {
			evp->e_event = E_SIGTERM;
			return (0);
		}
		if (F_ISSET(clp, CL_SIGWINCH)) {
			F_CLR(clp, CL_SIGWINCH);
			if (cl_ssize(sp, 1, &lines, &columns, &changed))
				return (1);
			if (changed) {
				(void)cl_resize(sp, lines, columns);
				evp->e_event = E_WRESIZE;
				return (0);
			}
			/* No real change, ignore the signal. */
		}
	}

	/* Set timer. */
	if (ms == 0)
		tp = NULL;
	else {
		t.tv_sec = ms / 1000;
		t.tv_usec = (ms % 1000) * 1000;
		tp = &t;
	}

	/* Read input characters. */
	switch (cl_read(sp, LF_ISSET(EC_QUOTED | EC_RAW),
	    clp->ibuf, sizeof(clp->ibuf), &nr, tp)) {
	case INP_OK:
		evp->e_csp = clp->ibuf;
		evp->e_len = nr;
		evp->e_event = E_STRING;
		break;
	case INP_EOF:
		evp->e_event = E_EOF;
		break;
	case INP_ERR:
		evp->e_event = E_ERR;
		break;
	case INP_INTR:
		goto retest;
	case INP_TIMEOUT:
		evp->e_event = E_TIMEOUT;
		break;
	default:
		abort();
	}
	return (0);
}

/*
 * cl_read --
 *	Read characters from the input.
 */
static input_t
cl_read(SCR *sp, u_int32_t flags, CHAR_T *bp, size_t blen, int *nrp,
    struct timeval *tp)
{
	struct termios term1, term2;
	CL_PRIVATE *clp;
	GS *gp;
	struct pollfd pfd[1];
	input_t rval;
	int nr, term_reset, timeout;

	gp = sp->gp;
	clp = CLP(sp);
	term_reset = 0;

	/*
	 * 1: A read from a file or a pipe.  In this case, the reads
	 *    never timeout regardless.  This means that we can hang
	 *    when trying to complete a map, but we're going to hang
	 *    on the next read anyway.
	 */
	if (!F_ISSET(clp, CL_STDIN_TTY)) {
		switch (nr = read(STDIN_FILENO, bp, blen)) {
		case 0:
			return (INP_EOF);
		case -1:
			goto err;
		default:
			*nrp = nr;
			return (INP_OK);
		}
		/* NOTREACHED */
	}

	/*
	 * 2: A read with an associated timeout, e.g., trying to complete
	 *    a map sequence.  If input exists, we fall into #3.
	 */
tty_retry:
	if (tp != NULL) {
		pfd[0].fd = STDIN_FILENO;
		pfd[0].events = POLLIN;
		timeout = tp ? (tp->tv_sec * 1000) + (tp->tv_usec / 1000) : 0;
		switch (poll(pfd, 1, timeout)) {
		case 0:
			return (INP_TIMEOUT);
		case -1:
			goto err;
		default:
			break;
		}
	}

	/*
	 * The user can enter a key in the editor to quote a character.  If we
	 * get here and the next key is supposed to be quoted, do what we can.
	 * Reset the tty so that the user can enter a ^C, ^Q, ^S.  There's an
	 * obvious race here, when the key has already been entered, but there's
	 * nothing that we can do to fix that problem.
	 *
	 * The editor can ask for the next literal character even thought it's
	 * generally running in line-at-a-time mode.  Do what we can.
	 */
	if (LF_ISSET(EC_QUOTED | EC_RAW) && !tcgetattr(STDIN_FILENO, &term1)) {
		term_reset = 1;
		if (LF_ISSET(EC_QUOTED)) {
			term2 = term1;
			term2.c_lflag &= ~ISIG;
			term2.c_iflag &= ~(IXON | IXOFF);
			(void)tcsetattr(STDIN_FILENO,
			    TCSASOFT | TCSADRAIN, &term2);
		} else
			(void)tcsetattr(STDIN_FILENO,
			    TCSASOFT | TCSADRAIN, &clp->vi_enter);
	}

	/*
	 * 3: Wait for input.
	 *
	 * Select on the command input and scripting window file descriptors.
	 * It's ugly that we wait on scripting file descriptors here, but it's
	 * the only way to keep from locking out scripting windows.
	 */
	if (F_ISSET(gp, G_SCRWIN)) {
		if (sscr_check_input(sp))
			goto err;
	}

	/*
	 * 4: Read the input.
	 *
	 * !!!
	 * What's going on here is some scary stuff.  Ex runs the terminal in
	 * canonical mode.  So, the <newline> character terminating a line of
	 * input is returned in the buffer, but a trailing <EOF> character is
	 * not similarly included.  As ex uses 0<EOF> and ^<EOF> as autoindent
	 * commands, it has to see the trailing <EOF> characters to determine
	 * the difference between the user entering "0ab" and "0<EOF>ab".  We
	 * leave an extra slot in the buffer, so that we can add a trailing
	 * <EOF> character if the buffer isn't terminated by a <newline>.  We
	 * lose if the buffer is too small for the line and exactly N characters
	 * are entered followed by an <EOF> character.
	 */
#define	ONE_FOR_EOF	1
	switch (nr = read(STDIN_FILENO, bp, blen - ONE_FOR_EOF)) {
	case  0:				/* EOF. */
		/*
		 * ^D in canonical mode returns a read of 0, i.e. EOF.  EOF is
		 * a valid command, but we don't want to loop forever because
		 * the terminal driver is returning EOF because the user has
		 * disconnected. The editor will almost certainly try to write
		 * something before this fires, which should kill us, but You
		 * Never Know.
		 */
		if (++clp->eof_count < 50) {
			bp[0] = clp->orig.c_cc[VEOF];
			*nrp = 1;
			rval = INP_OK;

		} else
			rval = INP_EOF;
		break;
	case -1:				/* Error or interrupt. */
err:		if (errno == EINTR)
			rval = INP_INTR;
		else if (errno == EAGAIN)
			goto tty_retry;
		else {
			rval = INP_ERR;
			msgq(sp, M_SYSERR, "input");
		}
		break;
	default:				/* Input characters. */
		if (F_ISSET(sp, SC_EX) && bp[nr - 1] != '\n')
			bp[nr++] = clp->orig.c_cc[VEOF];
		*nrp = nr;
		clp->eof_count = 0;
		rval = INP_OK;
		break;
	}

	/* Restore the terminal state if it was modified. */
	if (term_reset)
		(void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &term1);
	return (rval);
}

/*
 * cl_resize --
 *	Reset the options for a resize event.
 */
static int
cl_resize(SCR *sp, size_t lines, size_t columns)
{
	ARGS *argv[2], a, b;
	char b1[1024];

	a.bp = b1;
	b.bp = NULL;
	a.len = b.len = 0;
	argv[0] = &a;
	argv[1] = &b;

	(void)snprintf(b1, sizeof(b1), "lines=%lu", (u_long)lines);
	a.len = strlen(b1);
	if (opts_set(sp, argv, NULL))
		return (1);
	(void)snprintf(b1, sizeof(b1), "columns=%lu", (u_long)columns);
	a.len = strlen(b1);
	if (opts_set(sp, argv, NULL))
		return (1);
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: cl_read.c,v 1.21 2016/05/27 09:18:11 martijn Exp $ */
2
3			/*-
4			* Copyright (c) 1993, 1994
5			* The Regents of the University of California. All rights reserved.
6			* Copyright (c) 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/time.h>
17
18			#include <bitstring.h>
19			#include <curses.h>
20			#include <errno.h>
21			#include <fcntl.h>
22			#include <poll.h>
23			#include <signal.h>
24			#include <stdio.h>
25			#include <stdlib.h>
26			#include <string.h>
27			#include <termios.h>
28			#include <unistd.h>
29
30			#include "../common/common.h"
31			#include "../ex/script.h"
32			#include "cl.h"
33
34			static input_t cl_read(SCR *,
35			u_int32_t, CHAR_T , size_t, int , struct timeval *);
36			static int cl_resize(SCR *, size_t, size_t);
37
38			/*
39			* cl_event --
40			* Return a single event.
41			*
42			* PUBLIC: int cl_event(SCR , EVENT , u_int32_t, int);
43			*/
44			int
45			cl_event(SCR sp, EVENT evp, u_int32_t flags, int ms)
46			{
47			struct timeval t, *tp;
48			CL_PRIVATE *clp;
49			size_t lines, columns;
50			int changed, nr;
51
52			/*
53			* Queue signal based events. We never clear SIGHUP or SIGTERM events,
54			* so that we just keep returning them until the editor dies.
55			*/
56			clp = CLP(sp);
57			retest: if (LF_ISSET(EC_INTERRUPT) \|\| F_ISSET(clp, CL_SIGINT)) {
58			if (F_ISSET(clp, CL_SIGINT)) {
59			F_CLR(clp, CL_SIGINT);
60			evp->e_event = E_INTERRUPT;
61			} else
62			evp->e_event = E_TIMEOUT;
63			return (0);
64			}
65			if (F_ISSET(clp, CL_SIGHUP \| CL_SIGTERM \| CL_SIGWINCH)) {
66			if (F_ISSET(clp, CL_SIGHUP)) {
67			evp->e_event = E_SIGHUP;
68			return (0);
69			}
70			if (F_ISSET(clp, CL_SIGTERM)) {
71			evp->e_event = E_SIGTERM;
72			return (0);
73			}
74			if (F_ISSET(clp, CL_SIGWINCH)) {
75			F_CLR(clp, CL_SIGWINCH);
76			if (cl_ssize(sp, 1, &lines, &columns, &changed))
77			return (1);
78			if (changed) {
79			(void)cl_resize(sp, lines, columns);
80			evp->e_event = E_WRESIZE;
81			return (0);
82			}
83			/* No real change, ignore the signal. */
84			}
85			}
86
87			/* Set timer. */
88			if (ms == 0)
89			tp = NULL;
90			else {
91			t.tv_sec = ms / 1000;
92			t.tv_usec = (ms % 1000) * 1000;
93			tp = &t;
94			}
95
96			/* Read input characters. */
97			switch (cl_read(sp, LF_ISSET(EC_QUOTED \| EC_RAW),
98			clp->ibuf, sizeof(clp->ibuf), &nr, tp)) {
99			case INP_OK:
100			evp->e_csp = clp->ibuf;
101			evp->e_len = nr;
102			evp->e_event = E_STRING;
103			break;
104			case INP_EOF:
105			evp->e_event = E_EOF;
106			break;
107			case INP_ERR:
108			evp->e_event = E_ERR;
109			break;
110			case INP_INTR:
111			goto retest;
112			case INP_TIMEOUT:
113			evp->e_event = E_TIMEOUT;
114			break;
115			default:
116			abort();
117			}
118			return (0);
119			}
120
121			/*
122			* cl_read --
123			* Read characters from the input.
124			*/
125			static input_t
126			cl_read(SCR sp, u_int32_t flags, CHAR_T bp, size_t blen, int *nrp,
127			struct timeval *tp)
128			{
129			struct termios term1, term2;
130			CL_PRIVATE *clp;
131			GS *gp;
132			struct pollfd pfd[1];
133			input_t rval;
134			int nr, term_reset, timeout;
135
136			gp = sp->gp;
137			clp = CLP(sp);
138			term_reset = 0;
139
140			/*
141			* 1: A read from a file or a pipe. In this case, the reads
142			* never timeout regardless. This means that we can hang
143			* when trying to complete a map, but we're going to hang
144			* on the next read anyway.
145			*/
146			if (!F_ISSET(clp, CL_STDIN_TTY)) {
147			switch (nr = read(STDIN_FILENO, bp, blen)) {
148			case 0:
149			return (INP_EOF);
150			case -1:
151			goto err;
152			default:
153			*nrp = nr;
154			return (INP_OK);
155			}
156			/* NOTREACHED */
157			}
158
159			/*
160			* 2: A read with an associated timeout, e.g., trying to complete
161			* a map sequence. If input exists, we fall into #3.
162			*/
163			tty_retry:
164			if (tp != NULL) {
165			pfd[0].fd = STDIN_FILENO;
166			pfd[0].events = POLLIN;
167			timeout = tp ? (tp->tv_sec * 1000) + (tp->tv_usec / 1000) : 0;
168			switch (poll(pfd, 1, timeout)) {
169			case 0:
170			return (INP_TIMEOUT);
171			case -1:
172			goto err;
173			default:
174			break;
175			}
176			}
177
178			/*
179			* The user can enter a key in the editor to quote a character. If we
180			* get here and the next key is supposed to be quoted, do what we can.
181			* Reset the tty so that the user can enter a ^C, ^Q, ^S. There's an
182			* obvious race here, when the key has already been entered, but there's
183			* nothing that we can do to fix that problem.
184			*
185			* The editor can ask for the next literal character even thought it's
186			* generally running in line-at-a-time mode. Do what we can.
187			*/
188			if (LF_ISSET(EC_QUOTED \| EC_RAW) && !tcgetattr(STDIN_FILENO, &term1)) {
189			term_reset = 1;
190			if (LF_ISSET(EC_QUOTED)) {
191			term2 = term1;
192			term2.c_lflag &= ~ISIG;
193			term2.c_iflag &= ~(IXON \| IXOFF);
194			(void)tcsetattr(STDIN_FILENO,
195			TCSASOFT \| TCSADRAIN, &term2);
196			} else
197			(void)tcsetattr(STDIN_FILENO,
198			TCSASOFT \| TCSADRAIN, &clp->vi_enter);
199			}
200
201			/*
202			* 3: Wait for input.
203			*
204			* Select on the command input and scripting window file descriptors.
205			* It's ugly that we wait on scripting file descriptors here, but it's
206			* the only way to keep from locking out scripting windows.
207			*/
208			if (F_ISSET(gp, G_SCRWIN)) {
209			if (sscr_check_input(sp))
210			goto err;
211			}
212
213			/*
214			* 4: Read the input.
215			*
216			* !!!
217			* What's going on here is some scary stuff. Ex runs the terminal in
218			* canonical mode. So, the <newline> character terminating a line of
219			* input is returned in the buffer, but a trailing <EOF> character is
220			* not similarly included. As ex uses 0<EOF> and ^<EOF> as autoindent
221			* commands, it has to see the trailing <EOF> characters to determine
222			* the difference between the user entering "0ab" and "0<EOF>ab". We
223			* leave an extra slot in the buffer, so that we can add a trailing
224			* <EOF> character if the buffer isn't terminated by a <newline>. We
225			* lose if the buffer is too small for the line and exactly N characters
226			* are entered followed by an <EOF> character.
227			*/
228			#define ONE_FOR_EOF 1
229			switch (nr = read(STDIN_FILENO, bp, blen - ONE_FOR_EOF)) {
230			case 0: /* EOF. */
231			/*
232			* ^D in canonical mode returns a read of 0, i.e. EOF. EOF is
233			* a valid command, but we don't want to loop forever because
234			* the terminal driver is returning EOF because the user has
235			* disconnected. The editor will almost certainly try to write
236			* something before this fires, which should kill us, but You
237			* Never Know.
238			*/
239			if (++clp->eof_count < 50) {
240			bp[0] = clp->orig.c_cc[VEOF];
241			*nrp = 1;
242			rval = INP_OK;
243
244			} else
245			rval = INP_EOF;
246			break;
247			case -1: /* Error or interrupt. */
248			err: if (errno == EINTR)
249			rval = INP_INTR;
250			else if (errno == EAGAIN)
251			goto tty_retry;
252			else {
253			rval = INP_ERR;
254			msgq(sp, M_SYSERR, "input");
255			}
256			break;
257			default: /* Input characters. */
258			if (F_ISSET(sp, SC_EX) && bp[nr - 1] != '\n')
259			bp[nr++] = clp->orig.c_cc[VEOF];
260			*nrp = nr;
261			clp->eof_count = 0;
262			rval = INP_OK;
263			break;
264			}
265
266			/* Restore the terminal state if it was modified. */
267			if (term_reset)
268			(void)tcsetattr(STDIN_FILENO, TCSASOFT \| TCSADRAIN, &term1);
269			return (rval);
270			}
271
272			/*
273			* cl_resize --
274			* Reset the options for a resize event.
275			*/
276			static int
277			cl_resize(SCR *sp, size_t lines, size_t columns)
278			{
279			ARGS *argv[2], a, b;
280			char b1[1024];
281
282			a.bp = b1;
283			b.bp = NULL;
284			a.len = b.len = 0;
285			argv[0] = &a;
286			argv[1] = &b;
287
288			(void)snprintf(b1, sizeof(b1), "lines=%lu", (u_long)lines);
289			a.len = strlen(b1);
290			if (opts_set(sp, argv, NULL))
291			return (1);
292			(void)snprintf(b1, sizeof(b1), "columns=%lu", (u_long)columns);
293			a.len = strlen(b1);
294			if (opts_set(sp, argv, NULL))
295			return (1);
296			return (0);
297			}