com32/elflink/ldlinux/get_key.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
   4  *
   5  *   Permission is hereby granted, free of charge, to any person
   6  *   obtaining a copy of this software and associated documentation
   7  *   files (the "Software"), to deal in the Software without
   8  *   restriction, including without limitation the rights to use,
   9  *   copy, modify, merge, publish, distribute, sublicense, and/or
  10  *   sell copies of the Software, and to permit persons to whom
  11  *   the Software is furnished to do so, subject to the following
  12  *   conditions:
  13  *
  14  *   The above copyright notice and this permission notice shall
  15  *   be included in all copies or substantial portions of the Software.
  16  *
  17  *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  19  *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21  *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24  *   OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * ----------------------------------------------------------------------- */
  27
  28 /*
  29  * get_key.c
  30  *
  31  * Get a single key, and try to pick apart function key codes.
  32  * This doesn't decode anywhere close to all possiblities, but
  33  * hopefully is enough to be useful.
  34  */
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <unistd.h>
  40 #include <time.h>
  41 #include <sys/times.h>
  42 #include <getkey.h>
  43 #include <libutil.h>
  44 #include <sys/file.h>
  45
  46 struct keycode {
  47     int code;
  48     int seqlen;
  49     const unsigned char *seq;
  50 };
  51
  52 #define CODE(x,y) { x, (sizeof y)-1, (const unsigned char *)(y) }
  53
  54 static const struct keycode keycodes[] = {
  55     /* First, the BIOS combined codes */
  56     CODE(KEY_F1, "\0\x3B"),
  57     CODE(KEY_F2, "\0\x3C"),
  58     CODE(KEY_F3, "\0\x3D"),
  59     CODE(KEY_F4, "\0\x3E"),
  60     CODE(KEY_F5, "\0\x3F"),
  61     CODE(KEY_F6, "\0\x40"),
  62     CODE(KEY_F7, "\0\x41"),
  63     CODE(KEY_F8, "\0\x42"),
  64     CODE(KEY_F9, "\0\x43"),
  65     CODE(KEY_F10, "\0\x44"),
  66     CODE(KEY_F11, "\0\x85"),
  67     CODE(KEY_F12, "\0\x86"),
  68
  69     CODE(KEY_UP, "\0\x48"),
  70     CODE(KEY_DOWN, "\0\x50"),
  71     CODE(KEY_LEFT, "\0\x4B"),
  72     CODE(KEY_RIGHT, "\0\x4D"),
  73     CODE(KEY_PGUP, "\0\x49"),
  74     CODE(KEY_PGDN, "\0\x51"),
  75     CODE(KEY_HOME, "\0\x47"),
  76     CODE(KEY_END, "\0\x4F"),
  77     CODE(KEY_INSERT, "\0\x52"),
  78     CODE(KEY_DELETE, "\0\x53"),
  79
  80     /* Now, VT/xterm/Linux codes */
  81     CODE(KEY_F1, "\033[[A"),
  82     CODE(KEY_F1, "\033OP"),
  83     CODE(KEY_F2, "\033[[B"),
  84     CODE(KEY_F2, "\033OQ"),
  85     CODE(KEY_F3, "\033[[C"),
  86     CODE(KEY_F3, "\033OR"),
  87     CODE(KEY_F4, "\033[[D"),
  88     CODE(KEY_F4, "\033OS"),
  89     CODE(KEY_F5, "\033[[E"),
  90     CODE(KEY_F5, "\033[15~"),
  91     CODE(KEY_F6, "\033[17~"),
  92     CODE(KEY_F7, "\033[18~"),
  93     CODE(KEY_F8, "\033[19~"),
  94     CODE(KEY_F9, "\033[20~"),
  95     CODE(KEY_F10, "\033[21~"),
  96     CODE(KEY_F11, "\033[23~"),
  97     CODE(KEY_F12, "\033[24~"),
  98
  99     CODE(KEY_UP, "\033[A"),
 100     CODE(KEY_DOWN, "\033[B"),
 101     CODE(KEY_LEFT, "\033[D"),
 102     CODE(KEY_RIGHT, "\033[C"),
 103     CODE(KEY_PGUP, "\033[5~"),
 104     CODE(KEY_PGUP, "\033[V"),
 105     CODE(KEY_PGDN, "\033[6~"),
 106     CODE(KEY_PGDN, "\033[U"),
 107     CODE(KEY_HOME, "\033[1~"),
 108     CODE(KEY_HOME, "\033[H"),
 109     CODE(KEY_END, "\033[4~"),
 110     CODE(KEY_END, "\033[F"),
 111     CODE(KEY_END, "\033OF"),
 112     CODE(KEY_INSERT, "\033[2~"),
 113     CODE(KEY_INSERT, "\033[@"),
 114     CODE(KEY_DELETE, "\033[3~"),
 115
 116     /* EFI scan codes */
 117     CODE(KEY_UP, "\0\x01"),
 118     CODE(KEY_DOWN, "\0\x02"),
 119     CODE(KEY_RIGHT, "\0\x03"),
 120     CODE(KEY_LEFT, "\0\x04"),
 121     CODE(KEY_HOME, "\0\x05"),
 122     CODE(KEY_END, "\0\x06"),
 123     CODE(KEY_INSERT, "\0\x07"),
 124     CODE(KEY_DELETE, "\0\x08"),
 125     CODE(KEY_PGUP, "\0\x09"),
 126     CODE(KEY_PGDN, "\0\x0a"),
 127     CODE(KEY_F1, "\0\x0b"),
 128     CODE(KEY_F2, "\0\x0c"),
 129     CODE(KEY_F3, "\0\x0d"),
 130     CODE(KEY_F4, "\0\x0e"),
 131     CODE(KEY_F5, "\0\x0f"),
 132     CODE(KEY_F6, "\0\x10"),
 133     CODE(KEY_F7, "\0\x11"),
 134     CODE(KEY_F8, "\0\x12"),
 135     CODE(KEY_F9, "\0\x13"),
 136     CODE(KEY_F10, "\0\x14"),
 137     CODE(KEY_F11, "\0\x15"),
 138     CODE(KEY_F12, "\0\x16"),
 139     CODE(KEY_ESC, "\0\x17"),
 140 };
 141
 142 #define NCODES ((int)(sizeof keycodes/sizeof(struct keycode)))
 143
 144 #define KEY_TIMEOUT ((CLK_TCK+9)/10)
 145
 146 /*
 147  * Attempt to decode the key sequence in 'buffer'.
 148  *
 149  * On success (the data in 'buffer' matches a key code) put the
 150  * corresponding key code in 'code' and return 0. Return 1 if 'buffer'
 151  * partially matches a key code, i.e. we need more data before we can
 152  * make an unambiguous match. Return -1 if the buffer does not contain
 153  * a key code.
 154  */
 155 int get_key_decode(char *buffer, int nc, int *code)
 156 {
 157     const struct keycode *kc;
 158     int i, rv;
 159
 160     rv = -1;
 161     for (i = 0, kc = keycodes; i < NCODES; i++, kc++) {
 162         if (nc == kc->seqlen && !memcmp(buffer, kc->seq, nc)) {
 163             *code = kc->code;
 164             rv = 0;
 165             break;
 166         } else if (nc < kc->seqlen && !memcmp(buffer, kc->seq, nc)) {
 167             rv = 1;
 168             break;
 169         }
 170     }
 171
 172     return rv;
 173 }
 174
 175 #ifdef __COM32__
 176 extern ssize_t __rawcon_read(struct file_info *fp, void *buf, size_t count);
 177
 178 int raw_read(int fd, void *buf, size_t count)
 179 {
 180         (void)fd;
 181
 182         /*
 183          * Instead of using the read(2) stdlib function use
 184          * __rawcon_read() directly since we want a single key and
 185          * don't want any processing/batching of the user input to
 186          * occur - we want the raw data.
 187          */
 188         return __rawcon_read(NULL, buf, count);
 189 }
 190 #else
 191 extern int raw_read(int fd, void *buf, size_t count);
 192 #endif
 193
 194 __export int get_key(FILE * f, clock_t timeout)
 195 {
 196     char buffer[KEY_MAXLEN];
 197     int nc, rv;
 198     int another;
 199     char ch;
 200     clock_t start;
 201     int code;
 202
 203     /* We typically start in the middle of a clock tick */
 204     if (timeout)
 205         timeout++;
 206
 207     nc = 0;
 208     start = times(NULL);
 209     do {
 210         rv = raw_read(fileno(f), &ch, 1);
 211         if (rv == 0 || (rv == -1 && errno == EAGAIN)) {
 212             clock_t lateness = times(NULL) - start;
 213             if (nc && lateness > 1 + KEY_TIMEOUT) {
 214                 if (nc == 1)
 215                     return (unsigned char)buffer[0];    /* timeout */
 216                 else if (timeout && lateness > timeout)
 217                     return KEY_NONE;
 218             } else if (!nc && timeout && lateness > timeout)
 219                 return KEY_NONE;        /* timeout before sequence */
 220
 221             do_idle();
 222
 223             another = 1;
 224             continue;
 225         }
 226
 227         start = times(NULL);
 228
 229         buffer[nc++] = ch;
 230
 231         another = 0;
 232         rv = get_key_decode(buffer, nc, &code);
 233         if (!rv)
 234                 return code;
 235         else if (rv == 1)
 236                 another = 1;
 237
 238     } while (another);
 239
 240     /* We got an unrecognized sequence; return the first character */
 241     /* We really should remember this and return subsequent characters later */
 242     return (unsigned char)buffer[0];
 243 }