[2725] | 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 |
|
---|
[3232] | 18 | /* Known escape sequences for cursor and function keys.
|
---|
| 19 | * See "Xterm Control Sequences"
|
---|
| 20 | * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
|
---|
| 21 | */
|
---|
[2725] | 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> */
|
---|
[3232] | 46 | /* ESC [ 1 ; 3 x, where x = A/B/C/D: Alt-<arrow> - implemented below */
|
---|
[2725] | 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> */
|
---|
[3232] | 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> */
|
---|
[2725] | 52 | '[','H' |0x80,KEYCODE_HOME , /* xterm */
|
---|
| 53 | '[','F' |0x80,KEYCODE_END , /* xterm */
|
---|
[3232] | 54 | /* [ESC] ESC [ [2] H - [Alt-][Shift-]Home (End similarly?) */
|
---|
| 55 | /* '[','Z' |0x80,KEYCODE_SHIFT_TAB, */
|
---|
[2725] | 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
|
---|
[3232] | 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... */
|
---|
[2725] | 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 ,
|
---|
[3232] | 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 */
|
---|
[2725] | 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 */
|
---|
[3232] | 227 | if ((ENABLE_FEATURE_EDITING_ASK_TERMINAL
|
---|
| 228 | || ENABLE_FEATURE_VI_ASK_TERMINAL
|
---|
| 229 | || ENABLE_FEATURE_LESS_ASK_TERMINAL
|
---|
| 230 | )
|
---|
[2725] | 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 | }
|
---|