/*

* 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];

}