st/std.c

364 lines
6.9 KiB
C
Raw Normal View History

2008-08-25 15:29:37 +01:00
/* See LICENSE file for copyright and license details.
*
* Simple terminal daemon is a terminal emulator. It can be used in
* combination with simple terminal to emulate a mostly VT100-compatible
* terminal.
*
* In this process std works like a filter. It reads data from a
2008-09-05 19:25:34 +01:00
* pseudo-terminal and parses the escape sequences and transforms them
* into an ed(1)-like language. The resulting data is buffered and
* written to stdout.
2008-08-25 15:29:37 +01:00
* Parallely it reads data from stdin and parses and executes the
* commands. The resulting data is written to the pseudo-terminal.
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
#include <err.h>
2008-08-25 16:56:00 +01:00
#include <errno.h>
2008-07-21 09:34:02 +01:00
#include <fcntl.h>
#if !(_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)
#include <pty.h>
#endif
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
2008-06-02 19:15:52 +01:00
#define LENGTH(x) (sizeof(x) / sizeof((x)[0]))
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
typedef struct {
unsigned char data[BUFSIZ];
int s, e;
int n;
} RingBuffer;
2008-08-07 09:38:54 +01:00
static void buffer(char c);
static void cmd(const char *cmdstr, ...);
static void getpty(void);
static void movea(int x, int y);
static void mover(int x, int y);
static void parsecmd(void);
static void parseesc(void);
static void scroll(int l);
static void shell(void);
static void sigchld(int n);
static char unbuffer(void);
static int cols = 80, lines = 25;
static int cx = 0, cy = 0;
static int c;
2008-07-21 09:34:02 +01:00
static int ptm, pts;
static _Bool bold, digit, qmark;
static pid_t pid;
static RingBuffer buf;
2008-08-25 16:56:00 +01:00
static FILE *fptm;
void
buffer(char c) {
if(buf.n < LENGTH(buf.data))
buf.n++;
else
buf.s = (buf.s + 1) % LENGTH(buf.data);
buf.data[buf.e++] = c;
buf.e %= LENGTH(buf.data);
}
void
cmd(const char *cmdstr, ...) {
va_list ap;
putchar('\n');
putchar(':');
va_start(ap, cmdstr);
vfprintf(stdout, cmdstr, ap);
va_end(ap);
}
void
movea(int x, int y) {
x = MAX(x, cols);
y = MAX(y, lines);
cx = x;
cy = y;
2008-06-15 08:19:22 +01:00
cmd("seek(%d,%d)", x, y);
}
void
mover(int x, int y) {
movea(cx + x, cy + y);
}
2008-08-07 09:38:54 +01:00
void
parsecmd(void) {
}
void
parseesc(void) {
int i, j;
int arg[16];
memset(arg, 0, LENGTH(arg));
2008-08-25 16:56:00 +01:00
c = getc(fptm);
switch(c) {
case '[':
2008-08-25 16:56:00 +01:00
c = getc(fptm);
for(j = 0; j < LENGTH(arg);) {
if(isdigit(c)) {
2008-06-08 19:47:08 +01:00
digit = 1;
arg[j] *= 10;
arg[j] += c - '0';
}
else if(c == '?')
2008-06-08 19:47:08 +01:00
qmark = 1;
else if(c == ';') {
2008-06-08 19:47:08 +01:00
if(!digit)
errx(EXIT_FAILURE, "syntax error");
2008-06-08 19:47:08 +01:00
digit = 0;
j++;
}
else {
2008-06-08 19:47:08 +01:00
if(digit) {
digit = 0;
j++;
}
break;
}
2008-08-25 16:56:00 +01:00
c = getc(fptm);
}
switch(c) {
case '@':
break;
case 'A':
mover(0, j ? arg[0] : 1);
break;
case 'B':
mover(0, j ? -arg[0] : -1);
break;
case 'C':
mover(j ? arg[0] : 1, 0);
break;
case 'D':
mover(j ? -arg[0] : -1, 0);
break;
case 'E':
/* movel(j ? arg[0] : 1); */
break;
case 'F':
/* movel(j ? -arg[0] : -1); */
break;
case '`':
case 'G':
movea(j ? arg[0] : 1, cy);
break;
case 'f':
case 'H':
movea(arg[1] ? arg[1] : 1, arg[0] ? arg[0] : 1);
case 'L':
/* insline(j ? arg[0] : 1); */
break;
case 'M':
/* delline(j ? arg[0] : 1); */
break;
case 'P':
break;
case 'S':
scroll(j ? arg[0] : 1);
break;
case 'T':
scroll(j ? -arg[0] : -1);
break;
case 'd':
movea(cx, j ? arg[0] : 1);
break;
case 'm':
for(i = 0; i < j; i++) {
if(arg[i] >= 30 && arg[i] <= 37)
cmd("#%d", arg[i] - 30);
if(arg[i] >= 40 && arg[i] <= 47)
cmd("|%d", arg[i] - 40);
/* xterm bright colors */
if(arg[i] >= 90 && arg[i] <= 97)
cmd("#%d", arg[i] - 90);
if(arg[i] >= 100 && arg[i] <= 107)
cmd("|%d", arg[i] - 100);
switch(arg[i]) {
case 0:
case 22:
if(bold)
2008-06-15 08:19:22 +01:00
cmd("bold");
case 1:
if(!bold)
2008-06-15 08:19:22 +01:00
cmd("bold");
break;
}
}
break;
}
break;
default:
putchar('\033');
2008-08-25 16:56:00 +01:00
ungetc(c, fptm);
}
}
void
scroll(int l) {
2008-06-15 08:19:22 +01:00
cmd("seek(%d,%d)", cx, cy + l);
}
2008-07-21 09:34:02 +01:00
void
getpty(void) {
char *ptsdev;
#if defined(_GNU_SOURCE)
ptm = getpt();
#elif _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
ptm = posix_openpt(O_RDWR);
#else
ptm = open("/dev/ptmx", O_RDWR);
if(ptm == -1)
if(openpty(&ptm, &pts, NULL, NULL, NULL) == -1)
err(EXIT_FAILURE, "cannot open pty");
#endif
#if defined(_XOPEN_SOURCE)
if(ptm != -1) {
if(grantpt(ptm) == -1)
err(EXIT_FAILURE, "cannot grant access to pty");
if(unlockpt(ptm) == -1)
err(EXIT_FAILURE, "cannot unlock pty");
ptsdev = ptsname(ptm);
if(!ptsdev)
err(EXIT_FAILURE, "slave pty name undefined");
pts = open(ptsdev, O_RDWR);
if(pts == -1)
err(EXIT_FAILURE, "cannot open slave pty");
}
else
err(EXIT_FAILURE, "cannot open pty");
#endif
}
void
shell(void) {
static char *shell = NULL;
if(!shell && !(shell = getenv("SHELL")))
shell = "/bin/sh";
pid = fork();
switch(pid) {
case -1:
err(EXIT_FAILURE, "cannot fork");
case 0:
setsid();
dup2(pts, STDIN_FILENO);
dup2(pts, STDOUT_FILENO);
dup2(pts, STDERR_FILENO);
close(ptm);
putenv("TERM=vt102");
execvp(shell, NULL);
break;
default:
close(pts);
signal(SIGCHLD, sigchld);
}
}
void
sigchld(int n) {
int ret;
if(waitpid(pid, &ret, 0) == -1)
err(EXIT_FAILURE, "waiting for child failed");
if(WIFEXITED(ret))
exit(WEXITSTATUS(ret));
else
exit(EXIT_SUCCESS);
}
char
unbuffer(void) {
char c;
c = buf.data[buf.s++];
buf.s %= LENGTH(buf.data);
buf.n--;
return c;
}
int
main(int argc, char *argv[]) {
2008-06-14 22:24:12 +01:00
fd_set rfds;
if(argc == 2 && !strcmp("-v", argv[1]))
errx(EXIT_SUCCESS, "std-"VERSION", © 2008 Matthias-Christian Ott");
else if(argc == 1)
2008-07-21 08:25:47 +01:00
errx(EXIT_FAILURE, "usage: std [-v]");
getpty();
shell();
2008-06-14 22:24:12 +01:00
FD_ZERO(&rfds);
FD_SET(STDIN_FILENO, &rfds);
FD_SET(ptm, &rfds);
2008-08-25 16:56:00 +01:00
if(!(fptm = fdopen(ptm, "r+")))
err(EXIT_FAILURE, "cannot open pty");
if(fcntl(ptm, F_SETFL, O_NONBLOCK) == -1)
err(EXIT_FAILURE, "cannot set pty to non-blocking mode");
if(fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK) == -1)
err(EXIT_FAILURE, "cannot set stdin to non-blocking mode");
2008-06-08 20:17:02 +01:00
for(;;) {
2008-08-25 16:56:00 +01:00
if(select(MAX(ptm, STDIN_FILENO) + 1, &rfds, NULL, NULL, NULL) == -1)
err(EXIT_FAILURE, "cannot select");
2008-08-25 16:56:00 +01:00
if(FD_ISSET(ptm, &rfds)) {
for(;;) {
if((c = getc(fptm)) == EOF) {
if(feof(fptm)) {
FD_CLR(ptm, &rfds);
fflush(fptm);
break;
}
if(errno != EAGAIN)
err(EXIT_FAILURE, "cannot read from pty");
fflush(stdout);
2008-08-07 09:38:54 +01:00
break;
}
2008-06-15 08:19:22 +01:00
switch(c) {
case '\033':
parseesc();
break;
default:
putchar(c);
}
2008-08-25 16:56:00 +01:00
}
2008-06-15 16:31:24 +01:00
fflush(stdout);
}
2008-08-25 16:56:00 +01:00
if(FD_ISSET(STDIN_FILENO, &rfds)) {
for(;;) {
if((c = getchar()) == EOF) {
if(feof(stdin)) {
FD_CLR(STDIN_FILENO, &rfds);
fflush(fptm);
break;
}
if(errno != EAGAIN)
err(EXIT_FAILURE, "cannot read from stdin");
fflush(fptm);
break;
}
switch(c) {
case ':':
parsecmd();
break;
default:
putc(c, fptm);
}
}
fflush(fptm);
}
2008-06-08 20:17:02 +01:00
}
return 0;
}