/* ----------------------------------------------------------------------- *
*
* Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall
* be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* ----------------------------------------------------------------------- */
/*
* get_key.c
*
* Get a single key, and try to pick apart function key codes.
* This doesn't decode anywhere close to all possiblities, but
* hopefully is enough to be useful.
*/
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <sys/times.h>
#include <getkey.h>
#include <libutil.h>
#include <sys/file.h>
struct keycode {
int code;
int seqlen;
const unsigned char *seq;
};
#define CODE(x,y) { x, (sizeof y)-1, (const unsigned char *)(y) }
static const struct keycode keycodes[] = {
/* First, the BIOS combined codes */
CODE(KEY_F1, "\0\x3B"),
CODE(KEY_F2, "\0\x3C"),
CODE(KEY_F3, "\0\x3D"),
CODE(KEY_F4, "\0\x3E"),
CODE(KEY_F5, "\0\x3F"),
CODE(KEY_F6, "\0\x40"),
CODE(KEY_F7, "\0\x41"),
CODE(KEY_F8, "\0\x42"),
CODE(KEY_F9, "\0\x43"),
CODE(KEY_F10, "\0\x44"),
CODE(KEY_F11, "\0\x85"),
CODE(KEY_F12, "\0\x86"),
CODE(KEY_UP, "\0\x48"),
CODE(KEY_DOWN, "\0\x50"),
CODE(KEY_LEFT, "\0\x4B"),
CODE(KEY_RIGHT, "\0\x4D"),
CODE(KEY_PGUP, "\0\x49"),
CODE(KEY_PGDN, "\0\x51"),
CODE(KEY_HOME, "\0\x47"),
CODE(KEY_END, "\0\x4F"),
CODE(KEY_INSERT, "\0\x52"),
CODE(KEY_DELETE, "\0\x53"),
/* Now, VT/xterm/Linux codes */
CODE(KEY_F1, "\033[[A"),
CODE(KEY_F1, "\033OP"),
CODE(KEY_F2, "\033[[B"),
CODE(KEY_F2, "\033OQ"),
CODE(KEY_F3, "\033[[C"),
CODE(KEY_F3, "\033OR"),
CODE(KEY_F4, "\033[[D"),
CODE(KEY_F4, "\033OS"),
CODE(KEY_F5, "\033[[E"),
CODE(KEY_F5, "\033[15~"),
CODE(KEY_F6, "\033[17~"),
CODE(KEY_F7, "\033[18~"),
CODE(KEY_F8, "\033[19~"),
CODE(KEY_F9, "\033[20~"),
CODE(KEY_F10, "\033[21~"),
CODE(KEY_F11, "\033[23~"),
CODE(KEY_F12, "\033[24~"),
CODE(KEY_UP, "\033[A"),
CODE(KEY_DOWN, "\033[B"),
CODE(KEY_LEFT, "\033[D"),
CODE(KEY_RIGHT, "\033[C"),
CODE(KEY_PGUP, "\033[5~"),
CODE(KEY_PGUP, "\033[V"),
CODE(KEY_PGDN, "\033[6~"),
CODE(KEY_PGDN, "\033[U"),
CODE(KEY_HOME, "\033[1~"),
CODE(KEY_HOME, "\033[H"),
CODE(KEY_END, "\033[4~"),
CODE(KEY_END, "\033[F"),
CODE(KEY_END, "\033OF"),
CODE(KEY_INSERT, "\033[2~"),
CODE(KEY_INSERT, "\033[@"),
CODE(KEY_DELETE, "\033[3~"),
/* EFI scan codes */
CODE(KEY_UP, "\0\x01"),
CODE(KEY_DOWN, "\0\x02"),
CODE(KEY_RIGHT, "\0\x03"),
CODE(KEY_LEFT, "\0\x04"),
CODE(KEY_HOME, "\0\x05"),
CODE(KEY_END, "\0\x06"),
CODE(KEY_INSERT, "\0\x07"),
CODE(KEY_DELETE, "\0\x08"),
CODE(KEY_PGUP, "\0\x09"),
CODE(KEY_PGDN, "\0\x0a"),
CODE(KEY_F1, "\0\x0b"),
CODE(KEY_F2, "\0\x0c"),
CODE(KEY_F3, "\0\x0d"),
CODE(KEY_F4, "\0\x0e"),
CODE(KEY_F5, "\0\x0f"),
CODE(KEY_F6, "\0\x10"),
CODE(KEY_F7, "\0\x11"),
CODE(KEY_F8, "\0\x12"),
CODE(KEY_F9, "\0\x13"),
CODE(KEY_F10, "\0\x14"),
CODE(KEY_F11, "\0\x15"),
CODE(KEY_F12, "\0\x16"),
CODE(KEY_ESC, "\0\x17"),
};
#define NCODES ((int)(sizeof keycodes/sizeof(struct keycode)))
#define KEY_TIMEOUT ((CLK_TCK+9)/10)
/*
* Attempt to decode the key sequence in 'buffer'.
*
* On success (the data in 'buffer' matches a key code) put the
* corresponding key code in 'code' and return 0. Return 1 if 'buffer'
* partially matches a key code, i.e. we need more data before we can
* make an unambiguous match. Return -1 if the buffer does not contain
* a key code.
*/
int get_key_decode(char *buffer, int nc, int *code)
{
const struct keycode *kc;
int i, rv;
rv = -1;
for (i = 0, kc = keycodes; i < NCODES; i++, kc++) {
if (nc == kc->seqlen && !memcmp(buffer, kc->seq, nc)) {
*code = kc->code;
rv = 0;
break;
} else if (nc < kc->seqlen && !memcmp(buffer, kc->seq, nc)) {
rv = 1;
break;
}
}
return rv;
}
#ifdef __COM32__
extern ssize_t __rawcon_read(struct file_info *fp, void *buf, size_t count);
int raw_read(int fd, void *buf, size_t count)
{
(void)fd;
/*
* Instead of using the read(2) stdlib function use
* __rawcon_read() directly since we want a single key and
* don't want any processing/batching of the user input to
* occur - we want the raw data.
*/
return __rawcon_read(NULL, buf, count);
}
#else
extern int raw_read(int fd, void *buf, size_t count);
#endif
__export int get_key(FILE * f, clock_t timeout)
{
char buffer[KEY_MAXLEN];
int nc, rv;
int another;
char ch;
clock_t start;
int code;
/* We typically start in the middle of a clock tick */
if (timeout)
timeout++;
nc = 0;
start = times(NULL);
do {
rv = raw_read(fileno(f), &ch, 1);
if (rv == 0 || (rv == -1 && errno == EAGAIN)) {
clock_t lateness = times(NULL) - start;
if (nc && lateness > 1 + KEY_TIMEOUT) {
if (nc == 1)
return (unsigned char)buffer[0]; /* timeout */
else if (timeout && lateness > timeout)
return KEY_NONE;
} else if (!nc && timeout && lateness > timeout)
return KEY_NONE; /* timeout before sequence */
do_idle();
another = 1;
continue;
}
start = times(NULL);
buffer[nc++] = ch;
another = 0;
rv = get_key_decode(buffer, nc, &code);
if (!rv)
return code;
else if (rv == 1)
another = 1;
} while (another);
/* We got an unrecognized sequence; return the first character */
/* We really should remember this and return subsequent characters later */
return (unsigned char)buffer[0];
}