/*
* wkeys.c Read a keypress from the standard input. If it is an escape
* code, return a special value.
*
* WARNING: possibly the most ugly code in this package!
*
* This file is part of the minicom communications package,
* Copyright 1991-1995 Miquel van Smoorenburg.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <strings.h>
#include "port.h"
#include "minicom.h"
#include "intl.h"
#if KEY_KLUDGE && defined(linux)
# include <sys/kd.h>
# include <sys/ioctl.h>
#endif
/* If enabled, this will cause minicom to treat ESC [ A and
* ESC O A the same (stupid VT100 two mode keyboards).
*/
#define VT_KLUDGE 0
static struct key _keys[NUM_KEYS];
static int keys_in_buf;
static char erasechar;
static int gotalrm;
int pendingkeys = 0;
int io_pending = 0;
#ifndef NCURSES_CONST
#define NCURSES_CONST
#endif
static NCURSES_CONST char *func_key[] = {
"", "k1", "k2", "k3", "k4", "k5", "k6", "k7", "k8", "k9", "k0",
"kh", "kP", "ku", "kl", "kr", "kd", "kH", "kN", "kI", "kD",
"F1", "F2", NULL };
#if KEY_KLUDGE
/*
* A VERY DIRTY HACK FOLLOWS:
* This routine figures out if the tty we're using is a serial
* device OR an IBM PC console. If we're using a console, we can
* easily reckognize single escape-keys since escape sequences
* always return > 1 characters from a read()
*/
static int isconsole;
static int testconsole(void)
{
/* For Linux it's easy to see if this is a VC. */
int info;
return ioctl(0, KDGETLED, &info) == 0;
}
/*
* Function to read chunks of data from fd 0 all at once
*/
static int cread(char *c)
{
static char buf[32];
static int idx = 0;
static int lastread = 0;
if (idx > 0 && idx < lastread) {
*c = buf[idx++];
keys_in_buf--;
if (keys_in_buf == 0 && pendingkeys == 0)
io_pending = 0;
return lastread;
}
idx = 0;
do {
lastread = read(0, buf, 32);
keys_in_buf = lastread - 1;
} while (lastread < 0 && errno == EINTR);
*c = buf[0];
if (lastread > 1) {
idx = 1;
io_pending++;
}
return lastread;
}
#endif
static void _initkeys(void)
{
int i;
static char *cbuf, *tbuf;
char *term;
if (_tptr == NULL) {
if ((tbuf = (char *)malloc(512)) == NULL ||
(cbuf = (char *)malloc(2048)) == NULL) {
fprintf(stderr, _("Out of memory.\n"));
exit(1);
}
term = getenv("TERM");
switch (tgetent(cbuf, term)) {
case 0:
fprintf(stderr, _("No termcap entry.\n"));
exit(1);
case -1:
fprintf(stderr, _("No /etc/termcap present!\n"));
exit(1);
default:
break;
}
_tptr = tbuf;
}
/* Initialize codes for special keys */
for (i = 0; func_key[i]; i++) {
if ((_keys[i].cap = tgetstr(func_key[i], &_tptr)) == NULL)
_keys[i].cap = "";
_keys[i].len = strlen(_keys[i].cap);
}
#if KEY_KLUDGE
isconsole = testconsole();
#endif
}
/*
* Read a character from the keyboard.
* Handle special characters too!
*/
int wxgetch(void)
{
int f, g;
int match = 1;
int len;
char c;
static unsigned char mem[8];
static int leftmem = 0;
static int init = 0;
int nfound = 0;
int start_match;
#if VT_KLUDGE
char temp[8];
#endif
struct timeval timeout;
fd_set readfds;
if (init == 0) {
_initkeys();
init++;
erasechar = setcbreak(3);
}
/* Some sequence still in memory ? */
if (leftmem > 0) {
leftmem--;
if (leftmem == 0)
pendingkeys = 0;
if (pendingkeys == 0 && keys_in_buf == 0)
io_pending = 0;
return mem[leftmem];
}
gotalrm = 0;
pendingkeys = 0;
for (len = 1; len < 8 && match; len++) {
#if KEY_KLUDGE
if (len > 1 && keys_in_buf == 0)
#else
if (len > 1)
#endif
{
timeout.tv_sec = 0;
timeout.tv_usec = 400000; /* 400 ms */
FD_ZERO(&readfds);
FD_SET(0, &readfds);
if (!(nfound = select(1, &readfds, NULL, NULL, &timeout)))
break;
}
#if KEY_KLUDGE
while ((nfound = cread(&c)) < 0 && (errno == EINTR && !gotalrm))
;
#else
while ((nfound = read(0, &c, 1)) < 0 && (errno == EINTR && !gotalrm))
;
#endif
if (nfound < 1)
return EOF;
if (len == 1) {
/* Enter and erase have precedence over anything else */
if (c == '\n')
return c;
if (c == erasechar)
return K_ERA;
}
#if KEY_KLUDGE
/* Return single characters immideately */
if (isconsole && nfound == 1 && len == 1)
return c;
/* Another hack - detect the Meta Key. */
if (isconsole && nfound == 2 && len == 1 && c == 27 && escape == 27) {
cread(&c);
return c + K_META;
}
#endif
mem[len - 1] = c;
match = 0;
#if VT_KLUDGE
/* Oh boy. Stupid vt100 2 mode keyboard. */
strncpy(temp, mem, len);
if (len > 1 && temp[0] == 27) {
if (temp[1] == '[')
temp[1] = 'O';
else if (temp[1] == 'O')
temp[1] = '[';
}
/* We now have an alternate string to check. */
#endif
start_match = 0;
for (f = 0; f < NUM_KEYS; f++) {
#if VT_KLUDGE
if (_keys[f].len >= len &&
(strncmp(_keys[f].cap, (char *)mem, len) == 0 ||
strncmp(_keys[f].cap, (char *)temp, len) == 0))
#else
if (_keys[f].len >= len &&
strncmp(_keys[f].cap, (char *)mem, len) == 0)
#endif
{
match++;
if (_keys[f].len == len) {
return f + KEY_OFFS;
}
}
/* Does it match on first two chars? */
if (_keys[f].len > 1 && len == 2 &&
strncmp(_keys[f].cap, (char *)mem, 2) == 0)
start_match++;
}
#if KEY_KLUDGE
if (!isconsole)
#endif
#ifndef _MINIX /* Minix doesn't have ESC-c meta mode */
/* See if this _might_ be a meta-key. */
if (escape == 27 && !start_match && len == 2 && mem[0] == 27)
return c + K_META;
#endif
}
/* No match. in len we have the number of characters + 1 */
len--; /* for convenience */
if (len == 1)
return mem[0];
/* Remember there are more keys waiting in the buffer */
pendingkeys++;
io_pending++;
/* Reverse the "mem" array */
for (f = 0; f < len / 2; f++) {
g = mem[f];
mem[f] = mem[len - f - 1];
mem[len - f - 1] = g;
}
leftmem = len - 1;
return mem[leftmem];
}