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