blob: ace23defb88a5f70cadff88e2acb1713f935519e
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * Utility routines. |
4 | * |
5 | * Copyright (C) 2008 Rob Landley <rob@landley.net> |
6 | * Copyright (C) 2008 Denys Vlasenko <vda.linux@googlemail.com> |
7 | * |
8 | * Licensed under GPLv2, see file LICENSE in this source tree. |
9 | */ |
10 | #include "libbb.h" |
11 | |
12 | int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout) |
13 | { |
14 | struct pollfd pfd; |
15 | const char *seq; |
16 | int n; |
17 | |
18 | /* Known escape sequences for cursor and function keys. |
19 | * See "Xterm Control Sequences" |
20 | * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html |
21 | */ |
22 | static const char esccmds[] ALIGN1 = { |
23 | 'O','A' |0x80,KEYCODE_UP , |
24 | 'O','B' |0x80,KEYCODE_DOWN , |
25 | 'O','C' |0x80,KEYCODE_RIGHT , |
26 | 'O','D' |0x80,KEYCODE_LEFT , |
27 | 'O','H' |0x80,KEYCODE_HOME , |
28 | 'O','F' |0x80,KEYCODE_END , |
29 | #if 0 |
30 | 'O','P' |0x80,KEYCODE_FUN1 , |
31 | /* [ESC] ESC O [2] P - [Alt-][Shift-]F1 */ |
32 | /* ESC [ O 1 ; 2 P - Shift-F1 */ |
33 | /* ESC [ O 1 ; 3 P - Alt-F1 */ |
34 | /* ESC [ O 1 ; 4 P - Alt-Shift-F1 */ |
35 | /* ESC [ O 1 ; 5 P - Ctrl-F1 */ |
36 | /* ESC [ O 1 ; 6 P - Ctrl-Shift-F1 */ |
37 | 'O','Q' |0x80,KEYCODE_FUN2 , |
38 | 'O','R' |0x80,KEYCODE_FUN3 , |
39 | 'O','S' |0x80,KEYCODE_FUN4 , |
40 | #endif |
41 | '[','A' |0x80,KEYCODE_UP , |
42 | '[','B' |0x80,KEYCODE_DOWN , |
43 | '[','C' |0x80,KEYCODE_RIGHT , |
44 | '[','D' |0x80,KEYCODE_LEFT , |
45 | /* ESC [ 1 ; 2 x, where x = A/B/C/D: Shift-<arrow> */ |
46 | /* ESC [ 1 ; 3 x, where x = A/B/C/D: Alt-<arrow> - implemented below */ |
47 | /* ESC [ 1 ; 4 x, where x = A/B/C/D: Alt-Shift-<arrow> */ |
48 | /* ESC [ 1 ; 5 x, where x = A/B/C/D: Ctrl-<arrow> - implemented below */ |
49 | /* ESC [ 1 ; 6 x, where x = A/B/C/D: Ctrl-Shift-<arrow> */ |
50 | /* ESC [ 1 ; 7 x, where x = A/B/C/D: Ctrl-Alt-<arrow> */ |
51 | /* ESC [ 1 ; 8 x, where x = A/B/C/D: Ctrl-Alt-Shift-<arrow> */ |
52 | '[','H' |0x80,KEYCODE_HOME , /* xterm */ |
53 | '[','F' |0x80,KEYCODE_END , /* xterm */ |
54 | /* [ESC] ESC [ [2] H - [Alt-][Shift-]Home (End similarly?) */ |
55 | /* '[','Z' |0x80,KEYCODE_SHIFT_TAB, */ |
56 | '[','1','~' |0x80,KEYCODE_HOME , /* vt100? linux vt? or what? */ |
57 | '[','2','~' |0x80,KEYCODE_INSERT , |
58 | /* ESC [ 2 ; 3 ~ - Alt-Insert */ |
59 | '[','3','~' |0x80,KEYCODE_DELETE , |
60 | /* [ESC] ESC [ 3 [;2] ~ - [Alt-][Shift-]Delete */ |
61 | /* ESC [ 3 ; 3 ~ - Alt-Delete */ |
62 | /* ESC [ 3 ; 5 ~ - Ctrl-Delete */ |
63 | '[','4','~' |0x80,KEYCODE_END , /* vt100? linux vt? or what? */ |
64 | '[','5','~' |0x80,KEYCODE_PAGEUP , |
65 | /* ESC [ 5 ; 3 ~ - Alt-PgUp */ |
66 | /* ESC [ 5 ; 5 ~ - Ctrl-PgUp */ |
67 | /* ESC [ 5 ; 7 ~ - Ctrl-Alt-PgUp */ |
68 | '[','6','~' |0x80,KEYCODE_PAGEDOWN, |
69 | '[','7','~' |0x80,KEYCODE_HOME , /* vt100? linux vt? or what? */ |
70 | '[','8','~' |0x80,KEYCODE_END , /* vt100? linux vt? or what? */ |
71 | #if 0 |
72 | '[','1','1','~'|0x80,KEYCODE_FUN1 , /* old xterm, deprecated by ESC O P */ |
73 | '[','1','2','~'|0x80,KEYCODE_FUN2 , /* old xterm... */ |
74 | '[','1','3','~'|0x80,KEYCODE_FUN3 , /* old xterm... */ |
75 | '[','1','4','~'|0x80,KEYCODE_FUN4 , /* old xterm... */ |
76 | '[','1','5','~'|0x80,KEYCODE_FUN5 , |
77 | /* [ESC] ESC [ 1 5 [;2] ~ - [Alt-][Shift-]F5 */ |
78 | '[','1','7','~'|0x80,KEYCODE_FUN6 , |
79 | '[','1','8','~'|0x80,KEYCODE_FUN7 , |
80 | '[','1','9','~'|0x80,KEYCODE_FUN8 , |
81 | '[','2','0','~'|0x80,KEYCODE_FUN9 , |
82 | '[','2','1','~'|0x80,KEYCODE_FUN10 , |
83 | '[','2','3','~'|0x80,KEYCODE_FUN11 , |
84 | '[','2','4','~'|0x80,KEYCODE_FUN12 , |
85 | /* ESC [ 2 4 ; 2 ~ - Shift-F12 */ |
86 | /* ESC [ 2 4 ; 3 ~ - Alt-F12 */ |
87 | /* ESC [ 2 4 ; 4 ~ - Alt-Shift-F12 */ |
88 | /* ESC [ 2 4 ; 5 ~ - Ctrl-F12 */ |
89 | /* ESC [ 2 4 ; 6 ~ - Ctrl-Shift-F12 */ |
90 | #endif |
91 | /* '[','1',';','5','A' |0x80,KEYCODE_CTRL_UP , - unused */ |
92 | /* '[','1',';','5','B' |0x80,KEYCODE_CTRL_DOWN , - unused */ |
93 | '[','1',';','5','C' |0x80,KEYCODE_CTRL_RIGHT, |
94 | '[','1',';','5','D' |0x80,KEYCODE_CTRL_LEFT , |
95 | /* '[','1',';','3','A' |0x80,KEYCODE_ALT_UP , - unused */ |
96 | /* '[','1',';','3','B' |0x80,KEYCODE_ALT_DOWN , - unused */ |
97 | '[','1',';','3','C' |0x80,KEYCODE_ALT_RIGHT, |
98 | '[','1',';','3','D' |0x80,KEYCODE_ALT_LEFT , |
99 | /* '[','3',';','3','~' |0x80,KEYCODE_ALT_DELETE, - unused */ |
100 | 0 |
101 | }; |
102 | |
103 | pfd.fd = fd; |
104 | pfd.events = POLLIN; |
105 | |
106 | buffer++; /* saved chars counter is in buffer[-1] now */ |
107 | |
108 | start_over: |
109 | errno = 0; |
110 | n = (unsigned char)buffer[-1]; |
111 | if (n == 0) { |
112 | /* If no data, wait for input. |
113 | * If requested, wait TIMEOUT ms. TIMEOUT = -1 is useful |
114 | * if fd can be in non-blocking mode. |
115 | */ |
116 | if (timeout >= -1) { |
117 | if (safe_poll(&pfd, 1, timeout) == 0) { |
118 | /* Timed out */ |
119 | errno = EAGAIN; |
120 | return -1; |
121 | } |
122 | } |
123 | /* It is tempting to read more than one byte here, |
124 | * but it breaks pasting. Example: at shell prompt, |
125 | * user presses "c","a","t" and then pastes "\nline\n". |
126 | * When we were reading 3 bytes here, we were eating |
127 | * "li" too, and cat was getting wrong input. |
128 | */ |
129 | n = safe_read(fd, buffer, 1); |
130 | if (n <= 0) |
131 | return -1; |
132 | } |
133 | |
134 | { |
135 | unsigned char c = buffer[0]; |
136 | n--; |
137 | if (n) |
138 | memmove(buffer, buffer + 1, n); |
139 | /* Only ESC starts ESC sequences */ |
140 | if (c != 27) { |
141 | buffer[-1] = n; |
142 | return c; |
143 | } |
144 | } |
145 | |
146 | /* Loop through known ESC sequences */ |
147 | seq = esccmds; |
148 | while (*seq != '\0') { |
149 | /* n - position in sequence we did not read yet */ |
150 | int i = 0; /* position in sequence to compare */ |
151 | |
152 | /* Loop through chars in this sequence */ |
153 | while (1) { |
154 | /* So far escape sequence matched up to [i-1] */ |
155 | if (n <= i) { |
156 | /* Need more chars, read another one if it wouldn't block. |
157 | * Note that escape sequences come in as a unit, |
158 | * so if we block for long it's not really an escape sequence. |
159 | * Timeout is needed to reconnect escape sequences |
160 | * split up by transmission over a serial console. */ |
161 | if (safe_poll(&pfd, 1, 50) == 0) { |
162 | /* No more data! |
163 | * Array is sorted from shortest to longest, |
164 | * we can't match anything later in array - |
165 | * anything later is longer than this seq. |
166 | * Break out of both loops. */ |
167 | goto got_all; |
168 | } |
169 | errno = 0; |
170 | if (safe_read(fd, buffer + n, 1) <= 0) { |
171 | /* If EAGAIN, then fd is O_NONBLOCK and poll lied: |
172 | * in fact, there is no data. */ |
173 | if (errno != EAGAIN) { |
174 | /* otherwise: it's EOF/error */ |
175 | buffer[-1] = 0; |
176 | return -1; |
177 | } |
178 | goto got_all; |
179 | } |
180 | n++; |
181 | } |
182 | if (buffer[i] != (seq[i] & 0x7f)) { |
183 | /* This seq doesn't match, go to next */ |
184 | seq += i; |
185 | /* Forward to last char */ |
186 | while (!(*seq & 0x80)) |
187 | seq++; |
188 | /* Skip it and the keycode which follows */ |
189 | seq += 2; |
190 | break; |
191 | } |
192 | if (seq[i] & 0x80) { |
193 | /* Entire seq matched */ |
194 | n = 0; |
195 | /* n -= i; memmove(...); |
196 | * would be more correct, |
197 | * but we never read ahead that much, |
198 | * and n == i here. */ |
199 | buffer[-1] = 0; |
200 | return (signed char)seq[i+1]; |
201 | } |
202 | i++; |
203 | } |
204 | } |
205 | /* We did not find matching sequence. |
206 | * We possibly read and stored more input in buffer[] by now. |
207 | * n = bytes read. Try to read more until we time out. |
208 | */ |
209 | while (n < KEYCODE_BUFFER_SIZE-1) { /* 1 for count byte at buffer[-1] */ |
210 | if (safe_poll(&pfd, 1, 50) == 0) { |
211 | /* No more data! */ |
212 | break; |
213 | } |
214 | errno = 0; |
215 | if (safe_read(fd, buffer + n, 1) <= 0) { |
216 | /* If EAGAIN, then fd is O_NONBLOCK and poll lied: |
217 | * in fact, there is no data. */ |
218 | if (errno != EAGAIN) { |
219 | /* otherwise: it's EOF/error */ |
220 | buffer[-1] = 0; |
221 | return -1; |
222 | } |
223 | break; |
224 | } |
225 | n++; |
226 | /* Try to decipher "ESC [ NNN ; NNN R" sequence */ |
227 | if ((ENABLE_FEATURE_EDITING_ASK_TERMINAL |
228 | || ENABLE_FEATURE_VI_ASK_TERMINAL |
229 | || ENABLE_FEATURE_LESS_ASK_TERMINAL |
230 | ) |
231 | && n >= 5 |
232 | && buffer[0] == '[' |
233 | && buffer[n-1] == 'R' |
234 | && isdigit(buffer[1]) |
235 | ) { |
236 | char *end; |
237 | unsigned long row, col; |
238 | |
239 | row = strtoul(buffer + 1, &end, 10); |
240 | if (*end != ';' || !isdigit(end[1])) |
241 | continue; |
242 | col = strtoul(end + 1, &end, 10); |
243 | if (*end != 'R') |
244 | continue; |
245 | if (row < 1 || col < 1 || (row | col) > 0x7fff) |
246 | continue; |
247 | |
248 | buffer[-1] = 0; |
249 | /* Pack into "1 <row15bits> <col16bits>" 32-bit sequence */ |
250 | col |= (((-1 << 15) | row) << 16); |
251 | /* Return it in high-order word */ |
252 | return ((int64_t) col << 32) | (uint32_t)KEYCODE_CURSOR_POS; |
253 | } |
254 | } |
255 | got_all: |
256 | |
257 | if (n <= 1) { |
258 | /* Alt-x is usually returned as ESC x. |
259 | * Report ESC, x is remembered for the next call. |
260 | */ |
261 | buffer[-1] = n; |
262 | return 27; |
263 | } |
264 | |
265 | /* We were doing "buffer[-1] = n; return c;" here, but this results |
266 | * in unknown key sequences being interpreted as ESC + garbage. |
267 | * This was not useful. Pretend there was no key pressed, |
268 | * go and wait for a new keypress: |
269 | */ |
270 | buffer[-1] = 0; |
271 | goto start_over; |
272 | } |
273 | |
274 | void FAST_FUNC read_key_ungets(char *buffer, const char *str, unsigned len) |
275 | { |
276 | unsigned cur_len = (unsigned char)buffer[0]; |
277 | if (len > KEYCODE_BUFFER_SIZE-1 - cur_len) |
278 | len = KEYCODE_BUFFER_SIZE-1 - cur_len; |
279 | memcpy(buffer + 1 + cur_len, str, len); |
280 | buffer[0] += len; |
281 | } |
282 |