use stdio(3)
[st.git] / std.c
1 /* See LICENSE file for copyright and license details.
2  *
3  * Simple terminal daemon is a terminal emulator. It can be used in
4  * combination with simple terminal to emulate a mostly VT100-compatible
5  * terminal.
6  * 
7  * In this process std works like a filter. It reads data from a
8  * pseudo-terminal and parses the escape sequences and transforms
9  * them into an ed(1)-like. The resulting data is buffered and written
10  * to stdout.
11  * Parallely it reads data from stdin and parses and executes the
12  * commands. The resulting data is written to the pseudo-terminal.
13  */
14 #include <sys/types.h>
15 #include <sys/wait.h>
16 #include <ctype.h>
17 #include <err.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #if !(_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)
21 #include <pty.h>
22 #endif
23 #include <signal.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29
30 #define LENGTH(x)       (sizeof(x) / sizeof((x)[0]))
31 #define MAX(a,b)        (((a) > (b)) ? (a) : (b))
32 #define MIN(a,b)        (((a) < (b)) ? (a) : (b))
33
34 typedef struct {
35         unsigned char data[BUFSIZ];
36         int s, e;
37         int n;
38 } RingBuffer;
39
40 static void buffer(char c);
41 static void cmd(const char *cmdstr, ...);
42 static void getpty(void);
43 static void movea(int x, int y);
44 static void mover(int x, int y);
45 static void parsecmd(void);
46 static void parseesc(void);
47 static void scroll(int l);
48 static void shell(void);
49 static void sigchld(int n);
50 static char unbuffer(void);
51
52 static int cols = 80, lines = 25;
53 static int cx = 0, cy = 0;
54 static int c;
55 static int ptm, pts;
56 static _Bool bold, digit, qmark;
57 static pid_t pid;
58 static RingBuffer buf;
59 static FILE *fptm;
60
61 void
62 buffer(char c) {
63         if(buf.n < LENGTH(buf.data))
64                 buf.n++;
65         else
66                 buf.s = (buf.s + 1) % LENGTH(buf.data);
67         buf.data[buf.e++] = c;
68         buf.e %= LENGTH(buf.data);
69 }
70
71 void
72 cmd(const char *cmdstr, ...) {
73         va_list ap;
74
75         putchar('\n');
76         putchar(':');
77         va_start(ap, cmdstr);
78         vfprintf(stdout, cmdstr, ap);
79         va_end(ap);
80 }
81
82 void
83 movea(int x, int y) {
84         x = MAX(x, cols);
85         y = MAX(y, lines);
86         cx = x;
87         cy = y;
88         cmd("seek(%d,%d)", x, y);
89 }
90
91 void
92 mover(int x, int y) {
93         movea(cx + x, cy + y);
94 }
95
96 void
97 parsecmd(void) {
98 }
99
100 void
101 parseesc(void) {
102         int i, j;
103         int arg[16];
104
105         memset(arg, 0, LENGTH(arg));
106         c = getc(fptm);
107         switch(c) {
108         case '[':
109                 c = getc(fptm);
110                 for(j = 0; j < LENGTH(arg);) {
111                         if(isdigit(c)) {
112                                 digit = 1;
113                                 arg[j] *= 10;
114                                 arg[j] += c - '0';
115                         }
116                         else if(c == '?')
117                                 qmark = 1;
118                         else if(c == ';') {
119                                 if(!digit)
120                                         errx(EXIT_FAILURE, "syntax error");
121                                 digit = 0;
122                                 j++;
123                         }
124                         else {
125                                 if(digit) {
126                                         digit = 0;
127                                         j++;
128                                 }
129                                 break;
130                         }
131                         c = getc(fptm);
132                 }
133                 switch(c) {
134                 case '@':
135                         break;
136                 case 'A':
137                         mover(0, j ? arg[0] : 1);
138                         break;
139                 case 'B':
140                         mover(0, j ? -arg[0] : -1);
141                         break;
142                 case 'C':
143                         mover(j ? arg[0] : 1, 0);
144                         break;
145                 case 'D':
146                         mover(j ? -arg[0] : -1, 0);
147                         break;
148                 case 'E':
149                         /* movel(j ? arg[0] : 1); */
150                         break;
151                 case 'F':
152                         /* movel(j ? -arg[0] : -1); */
153                         break;
154                 case '`':
155                 case 'G':
156                         movea(j ? arg[0] : 1, cy);
157                         break;
158                 case 'f':
159                 case 'H':
160                         movea(arg[1] ? arg[1] : 1, arg[0] ? arg[0] : 1);
161                 case 'L':
162                         /* insline(j ? arg[0] : 1); */
163                         break;
164                 case 'M':
165                         /* delline(j ? arg[0] : 1); */
166                         break;
167                 case 'P':
168                         break;
169                 case 'S':
170                         scroll(j ? arg[0] : 1);
171                         break;
172                 case 'T':
173                         scroll(j ? -arg[0] : -1);
174                         break;
175                 case 'd':
176                         movea(cx, j ? arg[0] : 1);
177                         break;
178                 case 'm':
179                         for(i = 0; i < j; i++) {
180                                 if(arg[i] >= 30 && arg[i] <= 37)
181                                         cmd("#%d", arg[i] - 30);
182                                 if(arg[i] >= 40 && arg[i] <= 47)
183                                         cmd("|%d", arg[i] - 40);
184                                 /* xterm bright colors */
185                                 if(arg[i] >= 90 && arg[i] <= 97)
186                                         cmd("#%d", arg[i] - 90);
187                                 if(arg[i] >= 100 && arg[i] <= 107)
188                                         cmd("|%d", arg[i] - 100);
189                                 switch(arg[i]) {
190                                 case 0:
191                                 case 22:
192                                         if(bold)
193                                                 cmd("bold");
194                                 case 1:
195                                         if(!bold)
196                                                 cmd("bold");
197                                         break;
198                                 }
199                         }
200                         break;
201                 }
202                 break;
203         default:
204                 putchar('\033');
205                 ungetc(c, fptm);
206         }
207 }
208
209 void
210 scroll(int l) {
211         cmd("seek(%d,%d)", cx, cy + l);
212 }
213
214 void
215 getpty(void) {
216         char *ptsdev;
217
218 #if defined(_GNU_SOURCE)
219         ptm = getpt();
220 #elif _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
221         ptm = posix_openpt(O_RDWR);
222 #else
223         ptm = open("/dev/ptmx", O_RDWR);
224         if(ptm == -1)
225                 if(openpty(&ptm, &pts, NULL, NULL, NULL) == -1)
226                         err(EXIT_FAILURE, "cannot open pty");
227 #endif
228 #if defined(_XOPEN_SOURCE)
229         if(ptm != -1) {
230                 if(grantpt(ptm) == -1)
231                         err(EXIT_FAILURE, "cannot grant access to pty");
232                 if(unlockpt(ptm) == -1)
233                         err(EXIT_FAILURE, "cannot unlock pty");
234                 ptsdev = ptsname(ptm);
235                 if(!ptsdev)
236                         err(EXIT_FAILURE, "slave pty name undefined");
237                 pts = open(ptsdev, O_RDWR);
238                 if(pts == -1)
239                         err(EXIT_FAILURE, "cannot open slave pty");
240         }
241         else
242                 err(EXIT_FAILURE, "cannot open pty");
243 #endif
244 }
245
246 void
247 shell(void) {
248         static char *shell = NULL;
249
250         if(!shell && !(shell = getenv("SHELL")))
251                 shell = "/bin/sh";
252         pid = fork();
253         switch(pid) {
254         case -1:
255                 err(EXIT_FAILURE, "cannot fork");
256         case 0:
257                 setsid();
258                 dup2(pts, STDIN_FILENO);
259                 dup2(pts, STDOUT_FILENO);
260                 dup2(pts, STDERR_FILENO);
261                 close(ptm);
262                 putenv("TERM=vt102");
263                 execvp(shell, NULL);
264                 break;
265         default:
266                 close(pts);
267                 signal(SIGCHLD, sigchld);
268         }
269 }
270
271 void
272 sigchld(int n) {
273         int ret;
274
275         if(waitpid(pid, &ret, 0) == -1)
276                 err(EXIT_FAILURE, "waiting for child failed");
277         if(WIFEXITED(ret))
278                 exit(WEXITSTATUS(ret));
279         else
280                 exit(EXIT_SUCCESS);
281 }
282
283 char
284 unbuffer(void) {
285         char c;
286
287         c = buf.data[buf.s++];
288         buf.s %= LENGTH(buf.data);
289         buf.n--;
290         return c;
291 }
292
293 int
294 main(int argc, char *argv[]) {
295         fd_set rfds;
296
297         if(argc == 2 && !strcmp("-v", argv[1]))
298                 errx(EXIT_SUCCESS, "std-"VERSION", © 2008 Matthias-Christian Ott");
299         else if(argc == 1)
300                 errx(EXIT_FAILURE, "usage: std [-v]");
301         getpty();
302         shell();
303         FD_ZERO(&rfds);
304         FD_SET(STDIN_FILENO, &rfds);
305         FD_SET(ptm, &rfds);
306         if(!(fptm = fdopen(ptm, "r+")))
307                 err(EXIT_FAILURE, "cannot open pty");
308         if(fcntl(ptm, F_SETFL, O_NONBLOCK) == -1)
309                 err(EXIT_FAILURE, "cannot set pty to non-blocking mode");
310         if(fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK) == -1)
311                 err(EXIT_FAILURE, "cannot set stdin to non-blocking mode");
312         for(;;) {
313                 if(select(MAX(ptm, STDIN_FILENO) + 1, &rfds, NULL, NULL, NULL) == -1)
314                         err(EXIT_FAILURE, "cannot select");
315                 if(FD_ISSET(ptm, &rfds)) {
316                         for(;;) {
317                                 if((c = getc(fptm)) == EOF) {
318                                         if(feof(fptm)) {
319                                                 FD_CLR(ptm, &rfds);
320                                                 fflush(fptm);
321                                                 break;
322                                         }
323                                         if(errno != EAGAIN)
324                                                 err(EXIT_FAILURE, "cannot read from pty");
325                                         fflush(stdout);
326                                         break;
327                                 }
328                                 switch(c) {
329                                 case '\033':
330                                         parseesc();
331                                         break;
332                                 default:
333                                         putchar(c);
334                                 }
335                         }
336                         fflush(stdout);
337                 }
338                 if(FD_ISSET(STDIN_FILENO, &rfds)) {
339                         for(;;) {
340                                 if((c = getchar()) == EOF) {
341                                         if(feof(stdin)) {
342                                                 FD_CLR(STDIN_FILENO, &rfds);
343                                                 fflush(fptm);
344                                                 break;
345                                         }
346                                         if(errno != EAGAIN)
347                                                 err(EXIT_FAILURE, "cannot read from stdin");
348                                         fflush(fptm);
349                                         break;
350                                 }
351                                 switch(c) {
352                                 case ':':
353                                         parsecmd();
354                                         break;
355                                 default:
356                                         putc(c, fptm);
357                                 }
358                         }
359                         fflush(fptm);
360                 }
361         }
362         return 0;
363 }