read_key: ignore unknown keys (do not return them to caller byte-by-byte)

function                                             old     new   delta
read_key                                             568     601     +33

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 74 insertions, 50 deletions

diff --git a/libbb/read_key.c b/libbb/read_key.c
index 02c381dd5..ec1b3a4a8 100644
--- a/libbb/read_key.c
+++ b/libbb/read_key.c
@@ -14,7 +14,6 @@ int64_t FAST_FUNC read_key(int fd, char *buffer)
 	struct pollfd pfd;
 	const char *seq;
 	int n;
-	int c;
 
 	/* Known escape sequences for cursor and function keys */
 	static const char esccmds[] ALIGN1 = {
@@ -91,8 +90,11 @@ int64_t FAST_FUNC read_key(int fd, char *buffer)
 		/* ESC [ Z - Shift-Tab */
 	};
 
+	buffer++; /* saved chars counter is in buffer[-1] now */
+
+ start_over:
 	errno = 0;
-	n = (unsigned char) *buffer++;
+	n = (unsigned char)buffer[-1];
 	if (n == 0) {
 		/* If no data, block waiting for input.
 		 * It is tempting to read more than one byte here,
@@ -106,15 +108,17 @@ int64_t FAST_FUNC read_key(int fd, char *buffer)
 			return -1;
 	}
 
-	/* Grab character to return from buffer */
-	c = (unsigned char)buffer[0];
-	n--;
-	if (n)
-		memmove(buffer, buffer + 1, n);
-
-	/* Only ESC starts ESC sequences */
-	if (c != 27)
-		goto ret;
+	{
+		unsigned char c = buffer[0];
+		n--;
+		if (n)
+			memmove(buffer, buffer + 1, n);
+		/* Only ESC starts ESC sequences */
+		if (c != 27) {
+			buffer[-1] = n;
+			return c;
+		}
+	}
 
 	/* Loop through known ESC sequences */
 	pfd.fd = fd;
@@ -136,17 +140,21 @@ int64_t FAST_FUNC read_key(int fd, char *buffer)
 				if (safe_poll(&pfd, 1, 50) == 0) {
 					/* No more data!
 					 * Array is sorted from shortest to longest,
-					 * we can't match anything later in array,
-					 * break out of both loops. */
-					goto ret;
+					 * we can't match anything later in array -
+					 * anything later is longer than this seq.
+					 * Break out of both loops. */
+					goto got_all;
 				}
 				errno = 0;
 				if (safe_read(fd, buffer + n, 1) <= 0) {
 					/* If EAGAIN, then fd is O_NONBLOCK and poll lied:
 					 * in fact, there is no data. */
-					if (errno != EAGAIN)
-						c = -1; /* otherwise it's EOF/error */
-					goto ret;
+					if (errno != EAGAIN) {
+						/* otherwise: it's EOF/error */
+						buffer[-1] = 0;
+						return -1;
+					}
+					goto got_all;
 				}
 				n++;
 			}
@@ -162,66 +170,82 @@ int64_t FAST_FUNC read_key(int fd, char *buffer)
 			}
 			if (seq[i] & 0x80) {
 				/* Entire seq matched */
-				c = (signed char)seq[i+1];
 				n = 0;
 				/* n -= i; memmove(...);
 				 * would be more correct,
 				 * but we never read ahead that much,
 				 * and n == i here. */
-				goto ret;
+				buffer[-1] = 0;
+				return (signed char)seq[i+1];
 			}
 			i++;
 		}
 	}
-	/* We did not find matching sequence, it was a bare ESC.
-	 * We possibly read and stored more input in buffer[] by now. */
+	/* We did not find matching sequence.
+	 * We possibly read and stored more input in buffer[] by now.
+	 * n = bytes read. Try to read more until we time out.
+	 */
+	while (n < KEYCODE_BUFFER_SIZE-1) { /* 1 for count byte at buffer[-1] */
+		if (safe_poll(&pfd, 1, 50) == 0) {
+			/* No more data! */
+			break;
+		}
+		errno = 0;
+		if (safe_read(fd, buffer + n, 1) <= 0) {
+			/* If EAGAIN, then fd is O_NONBLOCK and poll lied:
+			 * in fact, there is no data. */
+			if (errno != EAGAIN) {
+				/* otherwise: it's EOF/error */
+				buffer[-1] = 0;
+				return -1;
+			}
+			break;
+		}
+		n++;
+	}
+ got_all:
+
+	if (n <= 1) {
+		/* Alt-x is usually returned as ESC x.
+		 * Report ESC, x is remembered for the next call.
+		 */
+		buffer[-1] = n;
+		return 27;
+	}
 
 	/* Try to decipher "ESC [ NNN ; NNN R" sequence */
 	if (ENABLE_FEATURE_EDITING_ASK_TERMINAL
-	 && n != 0
+	 && n >= 5
 	 && buffer[0] == '['
+	 && isdigit(buffer[1])
+	 && buffer[n-1] == 'R'
 	) {
 		char *end;
 		unsigned long row, col;
 
-		while (n < KEYCODE_BUFFER_SIZE-1) { /* 1 for cnt */
-			if (safe_poll(&pfd, 1, 50) == 0) {
-				/* No more data! */
-				break;
-			}
-			errno = 0;
-			if (safe_read(fd, buffer + n, 1) <= 0) {
-				/* If EAGAIN, then fd is O_NONBLOCK and poll lied:
-				 * in fact, there is no data. */
-				if (errno != EAGAIN)
-					c = -1; /* otherwise it's EOF/error */
-				goto ret;
-			}
-			if (buffer[n++] == 'R')
-				goto got_R;
-		}
-		goto ret;
- got_R:
-		if (!isdigit(buffer[1]))
-			goto ret;
 		row = strtoul(buffer + 1, &end, 10);
 		if (*end != ';' || !isdigit(end[1]))
-			goto ret;
+			goto not_R;
 		col = strtoul(end + 1, &end, 10);
 		if (*end != 'R')
-			goto ret;
+			goto not_R;
 		if (row < 1 || col < 1 || (row | col) > 0x7fff)
-			goto ret;
+			goto not_R;
 
 		buffer[-1] = 0;
 
 		/* Pack into "1 <row15bits> <col16bits>" 32-bit sequence */
-		c = (((-1 << 15) | row) << 16) | col;
+		col |= (((-1 << 15) | row) << 16);
 		/* Return it in high-order word */
-		return ((int64_t) c << 32) | (uint32_t)KEYCODE_CURSOR_POS;
+		return ((int64_t) col << 32) | (uint32_t)KEYCODE_CURSOR_POS;
 	}
+ not_R:
 
- ret:
-	buffer[-1] = n;
-	return c;
+	/* We were doing "buffer[-1] = n; return c;" here, but this results
+	 * in unknown key sequences being interpreted as ESC + garbage.
+	 * This was not useful. Pretend there was no key pressed,
+	 * go and wait for a new keypress:
+	 */
+	buffer[-1] = 0;
+	goto start_over;
 }