* st + patches and config
       
   URI git clone git://git.codevoid.de/st-sdk
   DIR Log
   DIR Files
   DIR Refs
   DIR README
   DIR LICENSE
       ---
       st.c (57387B)
       ---
            1 /* See LICENSE for license details. */
            2 #include <ctype.h>
            3 #include <errno.h>
            4 #include <fcntl.h>
            5 #include <limits.h>
            6 #include <pwd.h>
            7 #include <stdarg.h>
            8 #include <stdio.h>
            9 #include <stdlib.h>
           10 #include <string.h>
           11 #include <signal.h>
           12 #include <sys/ioctl.h>
           13 #include <sys/select.h>
           14 #include <sys/types.h>
           15 #include <sys/wait.h>
           16 #include <termios.h>
           17 #include <unistd.h>
           18 #include <wchar.h>
           19 
           20 #include "st.h"
           21 #include "win.h"
           22 
           23 #if   defined(__linux)
           24  #include <pty.h>
           25 #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
           26  #include <util.h>
           27 #elif defined(__FreeBSD__) || defined(__DragonFly__)
           28  #include <libutil.h>
           29 #endif
           30 
           31 /* Arbitrary sizes */
           32 #define UTF_INVALID   0xFFFD
           33 #define UTF_SIZ       4
           34 #define ESC_BUF_SIZ   (128*UTF_SIZ)
           35 #define ESC_ARG_SIZ   16
           36 #define STR_BUF_SIZ   ESC_BUF_SIZ
           37 #define STR_ARG_SIZ   ESC_ARG_SIZ
           38 #define HISTSIZE      2000
           39 
           40 /* macros */
           41 #define IS_SET(flag)                ((term.mode & (flag)) != 0)
           42 #define ISCONTROLC0(c)                (BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
           43 #define ISCONTROLC1(c)                (BETWEEN(c, 0x80, 0x9f))
           44 #define ISCONTROL(c)                (ISCONTROLC0(c) || ISCONTROLC1(c))
           45 #define ISDELIM(u)                (u && wcschr(worddelimiters, u))
           46 #define TLINE(y)                ((y) < term.scr ? term.hist[((y) + term.histi - \
           47                                 term.scr + HISTSIZE + 1) % HISTSIZE] : \
           48                                 term.line[(y) - term.scr])
           49 
           50 enum term_mode {
           51         MODE_WRAP        = 1 << 0,
           52         MODE_INSERT      = 1 << 1,
           53         MODE_ALTSCREEN   = 1 << 2,
           54         MODE_CRLF        = 1 << 3,
           55         MODE_ECHO        = 1 << 4,
           56         MODE_PRINT       = 1 << 5,
           57         MODE_UTF8        = 1 << 6,
           58 };
           59 
           60 enum cursor_movement {
           61         CURSOR_SAVE,
           62         CURSOR_LOAD
           63 };
           64 
           65 enum cursor_state {
           66         CURSOR_DEFAULT  = 0,
           67         CURSOR_WRAPNEXT = 1,
           68         CURSOR_ORIGIN   = 2
           69 };
           70 
           71 enum charset {
           72         CS_GRAPHIC0,
           73         CS_GRAPHIC1,
           74         CS_UK,
           75         CS_USA,
           76         CS_MULTI,
           77         CS_GER,
           78         CS_FIN
           79 };
           80 
           81 enum escape_state {
           82         ESC_START      = 1,
           83         ESC_CSI        = 2,
           84         ESC_STR        = 4,  /* DCS, OSC, PM, APC */
           85         ESC_ALTCHARSET = 8,
           86         ESC_STR_END    = 16, /* a final string was encountered */
           87         ESC_TEST       = 32, /* Enter in test mode */
           88         ESC_UTF8       = 64,
           89 };
           90 
           91 typedef struct {
           92         Glyph attr; /* current char attributes */
           93         int x;
           94         int y;
           95         char state;
           96 } TCursor;
           97 
           98 typedef struct {
           99         int mode;
          100         int type;
          101         int snap;
          102         /*
          103          * Selection variables:
          104          * nb – normalized coordinates of the beginning of the selection
          105          * ne – normalized coordinates of the end of the selection
          106          * ob – original coordinates of the beginning of the selection
          107          * oe – original coordinates of the end of the selection
          108          */
          109         struct {
          110                 int x, y;
          111         } nb, ne, ob, oe;
          112 
          113         int alt;
          114 } Selection;
          115 
          116 /* Internal representation of the screen */
          117 typedef struct {
          118         int row;      /* nb row */
          119         int col;      /* nb col */
          120         Line *line;   /* screen */
          121         Line *alt;    /* alternate screen */
          122         Line hist[HISTSIZE]; /* history buffer */
          123         int histi;    /* history index */
          124         int scr;      /* scroll back */
          125         int *dirty;   /* dirtyness of lines */
          126         TCursor c;    /* cursor */
          127         int ocx;      /* old cursor col */
          128         int ocy;      /* old cursor row */
          129         int top;      /* top    scroll limit */
          130         int bot;      /* bottom scroll limit */
          131         int mode;     /* terminal mode flags */
          132         int esc;      /* escape state flags */
          133         char trantbl[4]; /* charset table translation */
          134         int charset;  /* current charset */
          135         int icharset; /* selected charset for sequence */
          136         int *tabs;
          137         Rune lastc;   /* last printed char outside of sequence, 0 if control */
          138 } Term;
          139 
          140 /* CSI Escape sequence structs */
          141 /* ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]] */
          142 typedef struct {
          143         char buf[ESC_BUF_SIZ]; /* raw string */
          144         size_t len;            /* raw string length */
          145         char priv;
          146         int arg[ESC_ARG_SIZ];
          147         int narg;              /* nb of args */
          148         char mode[2];
          149 } CSIEscape;
          150 
          151 /* STR Escape sequence structs */
          152 /* ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\' */
          153 typedef struct {
          154         char type;             /* ESC type ... */
          155         char *buf;             /* allocated raw string */
          156         size_t siz;            /* allocation size */
          157         size_t len;            /* raw string length */
          158         char *args[STR_ARG_SIZ];
          159         int narg;              /* nb of args */
          160 } STREscape;
          161 
          162 static void execsh(char *, char **);
          163 static void stty(char **);
          164 static void sigchld(int);
          165 static void ttywriteraw(const char *, size_t);
          166 
          167 static void csidump(void);
          168 static void csihandle(void);
          169 static void csiparse(void);
          170 static void csireset(void);
          171 static int eschandle(uchar);
          172 static void strdump(void);
          173 static void strhandle(void);
          174 static void strparse(void);
          175 static void strreset(void);
          176 
          177 static void tprinter(char *, size_t);
          178 static void tdumpsel(void);
          179 static void tdumpline(int);
          180 static void tdump(void);
          181 static void tclearregion(int, int, int, int);
          182 static void tcursor(int);
          183 static void tdeletechar(int);
          184 static void tdeleteline(int);
          185 static void tinsertblank(int);
          186 static void tinsertblankline(int);
          187 static int tlinelen(int);
          188 static void tmoveto(int, int);
          189 static void tmoveato(int, int);
          190 static void tnewline(int);
          191 static void tputtab(int);
          192 static void tputc(Rune);
          193 static void treset(void);
          194 static void tscrollup(int, int, int);
          195 static void tscrolldown(int, int, int);
          196 static void tsetattr(int *, int);
          197 static void tsetchar(Rune, Glyph *, int, int);
          198 static void tsetdirt(int, int);
          199 static void tsetscroll(int, int);
          200 static void tswapscreen(void);
          201 static void tsetmode(int, int, int *, int);
          202 static int twrite(const char *, int, int);
          203 static void tfulldirt(void);
          204 static void tcontrolcode(uchar );
          205 static void tdectest(char );
          206 static void tdefutf8(char);
          207 static int32_t tdefcolor(int *, int *, int);
          208 static void tdeftran(char);
          209 static void tstrsequence(uchar);
          210 
          211 static void drawregion(int, int, int, int);
          212 
          213 static void selnormalize(void);
          214 static void selscroll(int, int);
          215 static void selsnap(int *, int *, int);
          216 
          217 static size_t utf8decode(const char *, Rune *, size_t);
          218 static Rune utf8decodebyte(char, size_t *);
          219 static char utf8encodebyte(Rune, size_t);
          220 static size_t utf8validate(Rune *, size_t);
          221 
          222 static char *base64dec(const char *);
          223 static char base64dec_getc(const char **);
          224 
          225 static ssize_t xwrite(int, const char *, size_t);
          226 
          227 /* Globals */
          228 static Term term;
          229 static Selection sel;
          230 static CSIEscape csiescseq;
          231 static STREscape strescseq;
          232 static int iofd = 1;
          233 static int cmdfd;
          234 static pid_t pid;
          235 
          236 static uchar utfbyte[UTF_SIZ + 1] = {0x80,    0, 0xC0, 0xE0, 0xF0};
          237 static uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
          238 static Rune utfmin[UTF_SIZ + 1] = {       0,    0,  0x80,  0x800,  0x10000};
          239 static Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
          240 
          241 ssize_t
          242 xwrite(int fd, const char *s, size_t len)
          243 {
          244         size_t aux = len;
          245         ssize_t r;
          246 
          247         while (len > 0) {
          248                 r = write(fd, s, len);
          249                 if (r < 0)
          250                         return r;
          251                 len -= r;
          252                 s += r;
          253         }
          254 
          255         return aux;
          256 }
          257 
          258 void *
          259 xmalloc(size_t len)
          260 {
          261         void *p;
          262 
          263         if (!(p = malloc(len)))
          264                 die("malloc: %s\n", strerror(errno));
          265 
          266         return p;
          267 }
          268 
          269 void *
          270 xrealloc(void *p, size_t len)
          271 {
          272         if ((p = realloc(p, len)) == NULL)
          273                 die("realloc: %s\n", strerror(errno));
          274 
          275         return p;
          276 }
          277 
          278 char *
          279 xstrdup(char *s)
          280 {
          281         if ((s = strdup(s)) == NULL)
          282                 die("strdup: %s\n", strerror(errno));
          283 
          284         return s;
          285 }
          286 
          287 size_t
          288 utf8decode(const char *c, Rune *u, size_t clen)
          289 {
          290         size_t i, j, len, type;
          291         Rune udecoded;
          292 
          293         *u = UTF_INVALID;
          294         if (!clen)
          295                 return 0;
          296         udecoded = utf8decodebyte(c[0], &len);
          297         if (!BETWEEN(len, 1, UTF_SIZ))
          298                 return 1;
          299         for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
          300                 udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
          301                 if (type != 0)
          302                         return j;
          303         }
          304         if (j < len)
          305                 return 0;
          306         *u = udecoded;
          307         utf8validate(u, len);
          308 
          309         return len;
          310 }
          311 
          312 Rune
          313 utf8decodebyte(char c, size_t *i)
          314 {
          315         for (*i = 0; *i < LEN(utfmask); ++(*i))
          316                 if (((uchar)c & utfmask[*i]) == utfbyte[*i])
          317                         return (uchar)c & ~utfmask[*i];
          318 
          319         return 0;
          320 }
          321 
          322 size_t
          323 utf8encode(Rune u, char *c)
          324 {
          325         size_t len, i;
          326 
          327         len = utf8validate(&u, 0);
          328         if (len > UTF_SIZ)
          329                 return 0;
          330 
          331         for (i = len - 1; i != 0; --i) {
          332                 c[i] = utf8encodebyte(u, 0);
          333                 u >>= 6;
          334         }
          335         c[0] = utf8encodebyte(u, len);
          336 
          337         return len;
          338 }
          339 
          340 char
          341 utf8encodebyte(Rune u, size_t i)
          342 {
          343         return utfbyte[i] | (u & ~utfmask[i]);
          344 }
          345 
          346 size_t
          347 utf8validate(Rune *u, size_t i)
          348 {
          349         if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
          350                 *u = UTF_INVALID;
          351         for (i = 1; *u > utfmax[i]; ++i)
          352                 ;
          353 
          354         return i;
          355 }
          356 
          357 static const char base64_digits[] = {
          358         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          359         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0,
          360         63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, -1, 0, 0, 0, 0, 1,
          361         2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
          362         22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34,
          363         35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0,
          364         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          365         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          366         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          367         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          368         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          369         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
          370 };
          371 
          372 char
          373 base64dec_getc(const char **src)
          374 {
          375         while (**src && !isprint(**src))
          376                 (*src)++;
          377         return **src ? *((*src)++) : '=';  /* emulate padding if string ends */
          378 }
          379 
          380 char *
          381 base64dec(const char *src)
          382 {
          383         size_t in_len = strlen(src);
          384         char *result, *dst;
          385 
          386         if (in_len % 4)
          387                 in_len += 4 - (in_len % 4);
          388         result = dst = xmalloc(in_len / 4 * 3 + 1);
          389         while (*src) {
          390                 int a = base64_digits[(unsigned char) base64dec_getc(&src)];
          391                 int b = base64_digits[(unsigned char) base64dec_getc(&src)];
          392                 int c = base64_digits[(unsigned char) base64dec_getc(&src)];
          393                 int d = base64_digits[(unsigned char) base64dec_getc(&src)];
          394 
          395                 /* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
          396                 if (a == -1 || b == -1)
          397                         break;
          398 
          399                 *dst++ = (a << 2) | ((b & 0x30) >> 4);
          400                 if (c == -1)
          401                         break;
          402                 *dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
          403                 if (d == -1)
          404                         break;
          405                 *dst++ = ((c & 0x03) << 6) | d;
          406         }
          407         *dst = '\0';
          408         return result;
          409 }
          410 
          411 void
          412 selinit(void)
          413 {
          414         sel.mode = SEL_IDLE;
          415         sel.snap = 0;
          416         sel.ob.x = -1;
          417 }
          418 
          419 int
          420 tlinelen(int y)
          421 {
          422         int i = term.col;
          423 
          424         if (TLINE(y)[i - 1].mode & ATTR_WRAP)
          425                 return i;
          426 
          427         while (i > 0 && TLINE(y)[i - 1].u == ' ')
          428                 --i;
          429 
          430         return i;
          431 }
          432 
          433 void
          434 selstart(int col, int row, int snap)
          435 {
          436         selclear();
          437         sel.mode = SEL_EMPTY;
          438         sel.type = SEL_REGULAR;
          439         sel.alt = IS_SET(MODE_ALTSCREEN);
          440         sel.snap = snap;
          441         sel.oe.x = sel.ob.x = col;
          442         sel.oe.y = sel.ob.y = row;
          443         selnormalize();
          444 
          445         if (sel.snap != 0)
          446                 sel.mode = SEL_READY;
          447         tsetdirt(sel.nb.y, sel.ne.y);
          448 }
          449 
          450 void
          451 selextend(int col, int row, int type, int done)
          452 {
          453         int oldey, oldex, oldsby, oldsey, oldtype;
          454 
          455         if (sel.mode == SEL_IDLE)
          456                 return;
          457         if (done && sel.mode == SEL_EMPTY) {
          458                 selclear();
          459                 return;
          460         }
          461 
          462         oldey = sel.oe.y;
          463         oldex = sel.oe.x;
          464         oldsby = sel.nb.y;
          465         oldsey = sel.ne.y;
          466         oldtype = sel.type;
          467 
          468         sel.oe.x = col;
          469         sel.oe.y = row;
          470         selnormalize();
          471         sel.type = type;
          472 
          473         if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
          474                 tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
          475 
          476         sel.mode = done ? SEL_IDLE : SEL_READY;
          477 }
          478 
          479 void
          480 selnormalize(void)
          481 {
          482         int i;
          483 
          484         if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
          485                 sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
          486                 sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
          487         } else {
          488                 sel.nb.x = MIN(sel.ob.x, sel.oe.x);
          489                 sel.ne.x = MAX(sel.ob.x, sel.oe.x);
          490         }
          491         sel.nb.y = MIN(sel.ob.y, sel.oe.y);
          492         sel.ne.y = MAX(sel.ob.y, sel.oe.y);
          493 
          494         selsnap(&sel.nb.x, &sel.nb.y, -1);
          495         selsnap(&sel.ne.x, &sel.ne.y, +1);
          496 
          497         /* expand selection over line breaks */
          498         if (sel.type == SEL_RECTANGULAR)
          499                 return;
          500         i = tlinelen(sel.nb.y);
          501         if (i < sel.nb.x)
          502                 sel.nb.x = i;
          503         if (tlinelen(sel.ne.y) <= sel.ne.x)
          504                 sel.ne.x = term.col - 1;
          505 }
          506 
          507 int
          508 selected(int x, int y)
          509 {
          510         if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
          511                         sel.alt != IS_SET(MODE_ALTSCREEN))
          512                 return 0;
          513 
          514         if (sel.type == SEL_RECTANGULAR)
          515                 return BETWEEN(y, sel.nb.y, sel.ne.y)
          516                     && BETWEEN(x, sel.nb.x, sel.ne.x);
          517 
          518         return BETWEEN(y, sel.nb.y, sel.ne.y)
          519             && (y != sel.nb.y || x >= sel.nb.x)
          520             && (y != sel.ne.y || x <= sel.ne.x);
          521 }
          522 
          523 void
          524 selsnap(int *x, int *y, int direction)
          525 {
          526         int newx, newy, xt, yt;
          527         int delim, prevdelim;
          528         Glyph *gp, *prevgp;
          529 
          530         switch (sel.snap) {
          531         case SNAP_WORD:
          532                 /*
          533                  * Snap around if the word wraps around at the end or
          534                  * beginning of a line.
          535                  */
          536                 prevgp = &TLINE(*y)[*x];
          537                 prevdelim = ISDELIM(prevgp->u);
          538                 for (;;) {
          539                         newx = *x + direction;
          540                         newy = *y;
          541                         if (!BETWEEN(newx, 0, term.col - 1)) {
          542                                 newy += direction;
          543                                 newx = (newx + term.col) % term.col;
          544                                 if (!BETWEEN(newy, 0, term.row - 1))
          545                                         break;
          546 
          547                                 if (direction > 0)
          548                                         yt = *y, xt = *x;
          549                                 else
          550                                         yt = newy, xt = newx;
          551                                 if (!(TLINE(yt)[xt].mode & ATTR_WRAP))
          552                                         break;
          553                         }
          554 
          555                         if (newx >= tlinelen(newy))
          556                                 break;
          557 
          558                         gp = &TLINE(newy)[newx];
          559                         delim = ISDELIM(gp->u);
          560                         if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
          561                                         || (delim && gp->u != prevgp->u)))
          562                                 break;
          563 
          564                         *x = newx;
          565                         *y = newy;
          566                         prevgp = gp;
          567                         prevdelim = delim;
          568                 }
          569                 break;
          570         case SNAP_LINE:
          571                 /*
          572                  * Snap around if the the previous line or the current one
          573                  * has set ATTR_WRAP at its end. Then the whole next or
          574                  * previous line will be selected.
          575                  */
          576                 *x = (direction < 0) ? 0 : term.col - 1;
          577                 if (direction < 0) {
          578                         for (; *y > 0; *y += direction) {
          579                                 if (!(TLINE(*y-1)[term.col-1].mode
          580                                                 & ATTR_WRAP)) {
          581                                         break;
          582                                 }
          583                         }
          584                 } else if (direction > 0) {
          585                         for (; *y < term.row-1; *y += direction) {
          586                                 if (!(TLINE(*y)[term.col-1].mode
          587                                                 & ATTR_WRAP)) {
          588                                         break;
          589                                 }
          590                         }
          591                 }
          592                 break;
          593         }
          594 }
          595 
          596 char *
          597 getsel(void)
          598 {
          599         char *str, *ptr;
          600         int y, bufsize, lastx, linelen;
          601         Glyph *gp, *last;
          602 
          603         if (sel.ob.x == -1)
          604                 return NULL;
          605 
          606         bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ;
          607         ptr = str = xmalloc(bufsize);
          608 
          609         /* append every set & selected glyph to the selection */
          610         for (y = sel.nb.y; y <= sel.ne.y; y++) {
          611                 if ((linelen = tlinelen(y)) == 0) {
          612                         *ptr++ = '\n';
          613                         continue;
          614                 }
          615 
          616                 if (sel.type == SEL_RECTANGULAR) {
          617                         gp = &TLINE(y)[sel.nb.x];
          618                         lastx = sel.ne.x;
          619                 } else {
          620                         gp = &TLINE(y)[sel.nb.y == y ? sel.nb.x : 0];
          621                         lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
          622                 }
          623                 last = &TLINE(y)[MIN(lastx, linelen-1)];
          624                 while (last >= gp && last->u == ' ')
          625                         --last;
          626 
          627                 for ( ; gp <= last; ++gp) {
          628                         if (gp->mode & ATTR_WDUMMY)
          629                                 continue;
          630 
          631                         ptr += utf8encode(gp->u, ptr);
          632                 }
          633 
          634                 /*
          635                  * Copy and pasting of line endings is inconsistent
          636                  * in the inconsistent terminal and GUI world.
          637                  * The best solution seems like to produce '\n' when
          638                  * something is copied from st and convert '\n' to
          639                  * '\r', when something to be pasted is received by
          640                  * st.
          641                  * FIXME: Fix the computer world.
          642                  */
          643                 if ((y < sel.ne.y || lastx >= linelen) &&
          644                     (!(last->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
          645                         *ptr++ = '\n';
          646         }
          647         *ptr = 0;
          648         return str;
          649 }
          650 
          651 void
          652 selclear(void)
          653 {
          654         if (sel.ob.x == -1)
          655                 return;
          656         sel.mode = SEL_IDLE;
          657         sel.ob.x = -1;
          658         tsetdirt(sel.nb.y, sel.ne.y);
          659 }
          660 
          661 void
          662 die(const char *errstr, ...)
          663 {
          664         va_list ap;
          665 
          666         va_start(ap, errstr);
          667         vfprintf(stderr, errstr, ap);
          668         va_end(ap);
          669         exit(1);
          670 }
          671 
          672 void
          673 execsh(char *cmd, char **args)
          674 {
          675         char *sh, *prog, *arg;
          676         const struct passwd *pw;
          677 
          678         errno = 0;
          679         if ((pw = getpwuid(getuid())) == NULL) {
          680                 if (errno)
          681                         die("getpwuid: %s\n", strerror(errno));
          682                 else
          683                         die("who are you?\n");
          684         }
          685 
          686         if ((sh = getenv("SHELL")) == NULL)
          687                 sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd;
          688 
          689         if (args) {
          690                 prog = args[0];
          691                 arg = NULL;
          692         } else if (scroll) {
          693                 prog = scroll;
          694                 arg = utmp ? utmp : sh;
          695         } else if (utmp) {
          696                 prog = utmp;
          697                 arg = NULL;
          698         } else {
          699                 prog = sh;
          700                 arg = NULL;
          701         }
          702         DEFAULT(args, ((char *[]) {prog, arg, NULL}));
          703 
          704         unsetenv("COLUMNS");
          705         unsetenv("LINES");
          706         unsetenv("TERMCAP");
          707         setenv("LOGNAME", pw->pw_name, 1);
          708         setenv("USER", pw->pw_name, 1);
          709         setenv("SHELL", sh, 1);
          710         setenv("HOME", pw->pw_dir, 1);
          711         setenv("TERM", termname, 1);
          712 
          713         signal(SIGCHLD, SIG_DFL);
          714         signal(SIGHUP, SIG_DFL);
          715         signal(SIGINT, SIG_DFL);
          716         signal(SIGQUIT, SIG_DFL);
          717         signal(SIGTERM, SIG_DFL);
          718         signal(SIGALRM, SIG_DFL);
          719 
          720         execvp(prog, args);
          721         _exit(1);
          722 }
          723 
          724 void
          725 sigchld(int a)
          726 {
          727         int stat;
          728         pid_t p;
          729 
          730         if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
          731                 die("waiting for pid %hd failed: %s\n", pid, strerror(errno));
          732 
          733         if (pid != p)
          734                 return;
          735 
          736         if (WIFEXITED(stat) && WEXITSTATUS(stat))
          737                 die("child exited with status %d\n", WEXITSTATUS(stat));
          738         else if (WIFSIGNALED(stat))
          739                 die("child terminated due to signal %d\n", WTERMSIG(stat));
          740         _exit(0);
          741 }
          742 
          743 void
          744 stty(char **args)
          745 {
          746         char cmd[_POSIX_ARG_MAX], **p, *q, *s;
          747         size_t n, siz;
          748 
          749         if ((n = strlen(stty_args)) > sizeof(cmd)-1)
          750                 die("incorrect stty parameters\n");
          751         memcpy(cmd, stty_args, n);
          752         q = cmd + n;
          753         siz = sizeof(cmd) - n;
          754         for (p = args; p && (s = *p); ++p) {
          755                 if ((n = strlen(s)) > siz-1)
          756                         die("stty parameter length too long\n");
          757                 *q++ = ' ';
          758                 memcpy(q, s, n);
          759                 q += n;
          760                 siz -= n + 1;
          761         }
          762         *q = '\0';
          763         if (system(cmd) != 0)
          764                 perror("Couldn't call stty");
          765 }
          766 
          767 int
          768 ttynew(char *line, char *cmd, char *out, char **args)
          769 {
          770         int m, s;
          771 
          772         if (out) {
          773                 term.mode |= MODE_PRINT;
          774                 iofd = (!strcmp(out, "-")) ?
          775                           1 : open(out, O_WRONLY | O_CREAT, 0666);
          776                 if (iofd < 0) {
          777                         fprintf(stderr, "Error opening %s:%s\n",
          778                                 out, strerror(errno));
          779                 }
          780         }
          781 
          782         if (line) {
          783                 if ((cmdfd = open(line, O_RDWR)) < 0)
          784                         die("open line '%s' failed: %s\n",
          785                             line, strerror(errno));
          786                 dup2(cmdfd, 0);
          787                 stty(args);
          788                 return cmdfd;
          789         }
          790 
          791         /* seems to work fine on linux, openbsd and freebsd */
          792         if (openpty(&m, &s, NULL, NULL, NULL) < 0)
          793                 die("openpty failed: %s\n", strerror(errno));
          794 
          795         switch (pid = fork()) {
          796         case -1:
          797                 die("fork failed: %s\n", strerror(errno));
          798                 break;
          799         case 0:
          800                 close(iofd);
          801                 setsid(); /* create a new process group */
          802                 dup2(s, 0);
          803                 dup2(s, 1);
          804                 dup2(s, 2);
          805                 if (ioctl(s, TIOCSCTTY, NULL) < 0)
          806                         die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
          807                 close(s);
          808                 close(m);
          809 #ifdef __OpenBSD__
          810                 if (pledge("stdio getpw proc exec", NULL) == -1)
          811                         die("pledge\n");
          812 #endif
          813                 execsh(cmd, args);
          814                 break;
          815         default:
          816 #ifdef __OpenBSD__
          817                 if (pledge("stdio rpath tty proc", NULL) == -1)
          818                         die("pledge\n");
          819 #endif
          820                 close(s);
          821                 cmdfd = m;
          822                 signal(SIGCHLD, sigchld);
          823                 break;
          824         }
          825         return cmdfd;
          826 }
          827 
          828 size_t
          829 ttyread(void)
          830 {
          831         static char buf[BUFSIZ];
          832         static int buflen = 0;
          833         int ret, written;
          834 
          835         /* append read bytes to unprocessed bytes */
          836         ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);
          837 
          838         switch (ret) {
          839         case 0:
          840                 exit(0);
          841         case -1:
          842                 die("couldn't read from shell: %s\n", strerror(errno));
          843         default:
          844                 buflen += ret;
          845                 written = twrite(buf, buflen, 0);
          846                 buflen -= written;
          847                 /* keep any incomplete UTF-8 byte sequence for the next call */
          848                 if (buflen > 0)
          849                         memmove(buf, buf + written, buflen);
          850                 return ret;
          851         }
          852 }
          853 
          854 void
          855 ttywrite(const char *s, size_t n, int may_echo)
          856 {
          857         const char *next;
          858         Arg arg = (Arg) { .i = term.scr };
          859 
          860         kscrolldown(&arg);
          861 
          862         if (may_echo && IS_SET(MODE_ECHO))
          863                 twrite(s, n, 1);
          864 
          865         if (!IS_SET(MODE_CRLF)) {
          866                 ttywriteraw(s, n);
          867                 return;
          868         }
          869 
          870         /* This is similar to how the kernel handles ONLCR for ttys */
          871         while (n > 0) {
          872                 if (*s == '\r') {
          873                         next = s + 1;
          874                         ttywriteraw("\r\n", 2);
          875                 } else {
          876                         next = memchr(s, '\r', n);
          877                         DEFAULT(next, s + n);
          878                         ttywriteraw(s, next - s);
          879                 }
          880                 n -= next - s;
          881                 s = next;
          882         }
          883 }
          884 
          885 void
          886 ttywriteraw(const char *s, size_t n)
          887 {
          888         fd_set wfd, rfd;
          889         ssize_t r;
          890         size_t lim = 256;
          891 
          892         /*
          893          * Remember that we are using a pty, which might be a modem line.
          894          * Writing too much will clog the line. That's why we are doing this
          895          * dance.
          896          * FIXME: Migrate the world to Plan 9.
          897          */
          898         while (n > 0) {
          899                 FD_ZERO(&wfd);
          900                 FD_ZERO(&rfd);
          901                 FD_SET(cmdfd, &wfd);
          902                 FD_SET(cmdfd, &rfd);
          903 
          904                 /* Check if we can write. */
          905                 if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
          906                         if (errno == EINTR)
          907                                 continue;
          908