contrib/nvi/ip/ip_read.c

   1 /*-
   2  * Copyright (c) 1996
   3  *      Keith Bostic.  All rights reserved.
   4  *
   5  * See the LICENSE file for redistribution information.
   6  */
   7
   8 #include "config.h"
   9
  10 #ifndef lint
  11 static const char sccsid[] = "@(#)ip_read.c     8.3 (Berkeley) 9/24/96";
  12 #endif /* not lint */
  13
  14 #include <sys/types.h>
  15 #include <sys/queue.h>
  16
  17 #include <bitstring.h>
  18 #include <stdio.h>
  19 #include <termios.h>
  20 #include <time.h>
  21
  22 #include "../common/common.h"
  23 #include "../ex/script.h"
  24 #include "ip.h"
  25
  26 extern GS *__global_list;
  27
  28 typedef enum { INP_OK=0, INP_EOF, INP_ERR, INP_TIMEOUT } input_t;
  29
  30 static input_t  ip_read __P((SCR *, IP_PRIVATE *, struct timeval *));
  31 static int      ip_resize __P((SCR *, size_t, size_t));
  32 static int      ip_trans __P((SCR *, IP_PRIVATE *, EVENT *));
  33
  34 /*
  35  * ip_event --
  36  *      Return a single event.
  37  *
  38  * PUBLIC: int ip_event __P((SCR *, EVENT *, u_int32_t, int));
  39  */
  40 int
  41 ip_event(sp, evp, flags, ms)
  42         SCR *sp;
  43         EVENT *evp;
  44         u_int32_t flags;
  45         int ms;
  46 {
  47         IP_PRIVATE *ipp;
  48         struct timeval t, *tp;
  49
  50         if (LF_ISSET(EC_INTERRUPT)) {           /* XXX */
  51                 evp->e_event = E_TIMEOUT;
  52                 return (0);
  53         }
  54
  55         ipp = sp == NULL ? GIPP(__global_list) : IPP(sp);
  56
  57         /* Discard the last command. */
  58         if (ipp->iskip != 0) {
  59                 ipp->iblen -= ipp->iskip;
  60                 memmove(ipp->ibuf, ipp->ibuf + ipp->iskip, ipp->iblen);
  61                 ipp->iskip = 0;
  62         }
  63
  64         /* Set timer. */
  65         if (ms == 0)
  66                 tp = NULL;
  67         else {
  68                 t.tv_sec = ms / 1000;
  69                 t.tv_usec = (ms % 1000) * 1000;
  70                 tp = &t;
  71         }
  72
  73         /* Read input events. */
  74         for (;;) {
  75                 switch (ip_read(sp, ipp, tp)) {
  76                 case INP_OK:
  77                         if (!ip_trans(sp, ipp, evp))
  78                                 continue;
  79                         break;
  80                 case INP_EOF:
  81                         evp->e_event = E_EOF;
  82                         break;
  83                 case INP_ERR:
  84                         evp->e_event = E_ERR;
  85                         break;
  86                 case INP_TIMEOUT:
  87                         evp->e_event = E_TIMEOUT;
  88                         break;
  89                 default:
  90                         abort();
  91                 }
  92                 break;
  93         }
  94         return (0);
  95 }
  96
  97 /*
  98  * ip_read --
  99  *      Read characters from the input.
 100  */
 101 static input_t
 102 ip_read(sp, ipp, tp)
 103         SCR *sp;
 104         IP_PRIVATE *ipp;
 105         struct timeval *tp;
 106 {
 107         struct timeval poll;
 108         GS *gp;
 109         SCR *tsp;
 110         fd_set rdfd;
 111         input_t rval;
 112         size_t blen;
 113         int maxfd, nr;
 114         char *bp;
 115
 116         gp = sp == NULL ? __global_list : sp->gp;
 117         bp = ipp->ibuf + ipp->iblen;
 118         blen = sizeof(ipp->ibuf) - ipp->iblen;
 119
 120         /*
 121          * 1: A read with an associated timeout, e.g., trying to complete
 122          *    a map sequence.  If input exists, we fall into #2.
 123          */
 124         FD_ZERO(&rdfd);
 125         poll.tv_sec = 0;
 126         poll.tv_usec = 0;
 127         if (tp != NULL) {
 128                 FD_SET(ipp->i_fd, &rdfd);
 129                 switch (select(ipp->i_fd + 1,
 130                     &rdfd, NULL, NULL, tp == NULL ? &poll : tp)) {
 131                 case 0:
 132                         return (INP_TIMEOUT);
 133                 case -1:
 134                         goto err;
 135                 default:
 136                         break;
 137                 }
 138         }
 139
 140         /*
 141          * 2: Wait for input.
 142          *
 143          * Select on the command input and scripting window file descriptors.
 144          * It's ugly that we wait on scripting file descriptors here, but it's
 145          * the only way to keep from locking out scripting windows.
 146          */
 147         if (sp != NULL && F_ISSET(gp, G_SCRWIN)) {
 148 loop:           FD_ZERO(&rdfd);
 149                 FD_SET(ipp->i_fd, &rdfd);
 150                 maxfd = ipp->i_fd;
 151                 for (tsp = gp->dq.cqh_first;
 152                     tsp != (void *)&gp->dq; tsp = tsp->q.cqe_next)
 153                         if (F_ISSET(sp, SC_SCRIPT)) {
 154                                 FD_SET(sp->script->sh_master, &rdfd);
 155                                 if (sp->script->sh_master > maxfd)
 156                                         maxfd = sp->script->sh_master;
 157                         }
 158                 switch (select(maxfd + 1, &rdfd, NULL, NULL, NULL)) {
 159                 case 0:
 160                         abort();
 161                 case -1:
 162                         goto err;
 163                 default:
 164                         break;
 165                 }
 166                 if (!FD_ISSET(ipp->i_fd, &rdfd)) {
 167                         if (sscr_input(sp))
 168                                 return (INP_ERR);
 169                         goto loop;
 170                 }
 171         }
 172
 173         /*
 174          * 3: Read the input.
 175          */
 176         switch (nr = read(ipp->i_fd, bp, blen)) {
 177         case  0:                                /* EOF. */
 178                 rval = INP_EOF;
 179                 break;
 180         case -1:                                /* Error or interrupt. */
 181 err:            rval = INP_ERR;
 182                 msgq(sp, M_SYSERR, "input");
 183                 break;
 184         default:                                /* Input characters. */
 185                 ipp->iblen += nr;
 186                 rval = INP_OK;
 187                 break;
 188         }
 189         return (rval);
 190 }
 191
 192 /*
 193  * ip_trans --
 194  *      Translate messages into events.
 195  */
 196 static int
 197 ip_trans(sp, ipp, evp)
 198         SCR *sp;
 199         IP_PRIVATE *ipp;
 200         EVENT *evp;
 201 {
 202         u_int32_t val1, val2;
 203
 204         switch (ipp->ibuf[0]) {
 205         case IPO_EOF:
 206                 evp->e_event = E_EOF;
 207                 ipp->iskip = IPO_CODE_LEN;
 208                 return (1);
 209         case IPO_ERR:
 210                 evp->e_event = E_ERR;
 211                 ipp->iskip = IPO_CODE_LEN;
 212                 return (1);
 213         case IPO_INTERRUPT:
 214                 evp->e_event = E_INTERRUPT;
 215                 ipp->iskip = IPO_CODE_LEN;
 216                 return (1);
 217         case IPO_QUIT:
 218                 evp->e_event = E_QUIT;
 219                 ipp->iskip = IPO_CODE_LEN;
 220                 return (1);
 221         case IPO_RESIZE:
 222                 if (ipp->iblen < IPO_CODE_LEN + IPO_INT_LEN * 2)
 223                         return (0);
 224                 evp->e_event = E_WRESIZE;
 225                 memcpy(&val1, ipp->ibuf + IPO_CODE_LEN, IPO_INT_LEN);
 226                 val1 = ntohl(val1);
 227                 memcpy(&val2,
 228                     ipp->ibuf + IPO_CODE_LEN + IPO_INT_LEN, IPO_INT_LEN);
 229                 val2 = ntohl(val2);
 230                 ip_resize(sp, val1, val2);
 231                 ipp->iskip = IPO_CODE_LEN + IPO_INT_LEN * 2;
 232                 return (1);
 233         case IPO_SIGHUP:
 234                 evp->e_event = E_SIGHUP;
 235                 ipp->iskip = IPO_CODE_LEN;
 236                 return (1);
 237         case IPO_SIGTERM:
 238                 evp->e_event = E_SIGTERM;
 239                 ipp->iskip = IPO_CODE_LEN;
 240                 return (1);
 241         case IPO_STRING:
 242                 evp->e_event = E_STRING;
 243 string:         if (ipp->iblen < IPO_CODE_LEN + IPO_INT_LEN)
 244                         return (0);
 245                 memcpy(&val1, ipp->ibuf + IPO_CODE_LEN, IPO_INT_LEN);
 246                 val1 = ntohl(val1);
 247                 if (ipp->iblen < IPO_CODE_LEN + IPO_INT_LEN + val1)
 248                         return (0);
 249                 ipp->iskip = IPO_CODE_LEN + IPO_INT_LEN + val1;
 250                 evp->e_csp = ipp->ibuf + IPO_CODE_LEN + IPO_INT_LEN;
 251                 evp->e_len = val1;
 252                 return (1);
 253         case IPO_WRITE:
 254                 evp->e_event = E_WRITE;
 255                 ipp->iskip = IPO_CODE_LEN;
 256                 return (1);
 257         default:
 258                 /*
 259                  * XXX: Protocol is out of sync?
 260                  */
 261                 abort();
 262         }
 263         /* NOTREACHED */
 264 }
 265
 266 /*
 267  * ip_resize --
 268  *      Reset the options for a resize event.
 269  */
 270 static int
 271 ip_resize(sp, lines, columns)
 272         SCR *sp;
 273         size_t lines, columns;
 274 {
 275         GS *gp;
 276         ARGS *argv[2], a, b;
 277         char b1[1024];
 278
 279         /*
 280          * XXX
 281          * The IP screen has to know the lines and columns before anything
 282          * else happens.  So, we may not have a valid SCR pointer, and we
 283          * have to deal with that.
 284          */
 285         if (sp == NULL) {
 286                 gp = __global_list;
 287                 OG_VAL(gp, GO_LINES) = OG_D_VAL(gp, GO_LINES) = lines;
 288                 OG_VAL(gp, GO_COLUMNS) = OG_D_VAL(gp, GO_COLUMNS) = columns;
 289                 return (0);
 290         }
 291
 292         a.bp = b1;
 293         b.bp = NULL;
 294         a.len = b.len = 0;
 295         argv[0] = &a;
 296         argv[1] = &b;
 297
 298         (void)snprintf(b1, sizeof(b1), "lines=%lu", (u_long)lines);
 299         a.len = strlen(b1);
 300         if (opts_set(sp, argv, NULL))
 301                 return (1);
 302         (void)snprintf(b1, sizeof(b1), "columns=%lu", (u_long)columns);
 303         a.len = strlen(b1);
 304         if (opts_set(sp, argv, NULL))
 305                 return (1);
 306         return (0);
 307 }