/* ----------------------------------------------------------------------- * * * 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 #include #include #include #include #include #include #include #include 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]; }