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