1 /* ----------------------------------------------------------------------- *
3 * Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
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
14 * The above copyright notice and this permission notice shall
15 * be included in all copies or substantial portions of the Software.
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.
26 * ----------------------------------------------------------------------- */
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.
41 #include <sys/times.h>
49 const unsigned char *seq;
52 #define CODE(x,y) { x, (sizeof y)-1, (const unsigned char *)(y) }
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"),
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"),
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~"),
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~"),
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"),
142 #define NCODES ((int)(sizeof keycodes/sizeof(struct keycode)))
144 #define KEY_TIMEOUT ((CLK_TCK+9)/10)
147 * Attempt to decode the key sequence in 'buffer'.
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
155 int get_key_decode(char *buffer, int nc, int *code)
157 const struct keycode *kc;
161 for (i = 0, kc = keycodes; i < NCODES; i++, kc++) {
162 if (nc == kc->seqlen && !memcmp(buffer, kc->seq, nc)) {
166 } else if (nc < kc->seqlen && !memcmp(buffer, kc->seq, nc)) {
176 extern ssize_t __rawcon_read(struct file_info *fp, void *buf, size_t count);
178 int raw_read(int fd, void *buf, size_t count)
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.
188 return __rawcon_read(NULL, buf, count);
191 extern int raw_read(int fd, void *buf, size_t count);
194 __export int get_key(FILE * f, clock_t timeout)
196 char buffer[KEY_MAXLEN];
203 /* We typically start in the middle of a clock tick */
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) {
215 return (unsigned char)buffer[0]; /* timeout */
216 else if (timeout && lateness > timeout)
218 } else if (!nc && timeout && lateness > timeout)
219 return KEY_NONE; /* timeout before sequence */
232 rv = get_key_decode(buffer, nc, &code);
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];