source: branches/3.2/mindi-busybox/libbb/read_key.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 5 years ago
  • Update mindi-busybox to 1.21.1
  • Property svn:eol-style set to native
File size: 8.6 KB
Line 
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
12int64_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
274void 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}
Note: See TracBrowser for help on using the repository browser.