How to prevent random console output from breaking the terminal

escape-charactersoutputterminal

There are many questions on SE that show how to recover from terminal broken by cat /dev/urandom. For those that are unfamiliar with this issue – here what it is about:

You execute cat /dev/urandom or equivalent (for example, cat binary_file.dat).
Garbage is printed.
That would be okay… except your terminal continues to print garbage even after the command has finished! Here's a screenshot of a misrendered text that is in fact g++ output:

I guess people were right about C++ errors sometimes being too cryptic!

The usual solution is to run stty sane && reset, although it's kind of annoying to run it every time this happens.

Because of that, what I want to focus on in this question is the original reason why this happens, and how to prevent the terminal from breaking after such command is issued. I'm not looking for solutions such as piping the offending commands to tr or xxd, because this requires you to know that the program/file outputs binary before you actually run/print it, and needs to be remembered each time you happen to output such data.

I noticed the same behavior in URxvt, PuTTY and Linux frame buffer so I don't think this is terminal-specific problem. My primary suspect is that the random output contains some ANSI escape code that flips the character encoding (in fact, if you run cat /dev/urandom again, chances are it will unbreak the terminal, which seems to confirm this theory). If this is right, what is this escape code? Are there any standard ways to disable it?

Best Answer

No:

there is no standard way to "disable it", and
the details of breakage are actually terminal-specific, but
there are some commonly-implemented features for which you can get misbehavior.

For commonly-implemented features, look to the VT100-style alternate character set, which is activated by ^N and ^O (enable/disable). That may be suppressed in some terminals when using UTF-8 mode, but the same terminals have ample opportunity for trashing your screen (talking about GNU screen, Linux console, PuTTY here) with the escape sequences they do recognize.

Some of the other escape sequences for instance rely upon responses from the terminal to a query (escape sequence) by the host. If the host does not expect it, the result is trash on the screen.

In other cases (seen for instance in network devices with hardcoded escape sequences for the Linux console), other terminals will see that as miscoded, and seem to freeze.

So... you could focus on just one terminal, prune out whatever looks like a nuisance (as for instance, some suggest removing the ability to use the mouse for positioning in editors), and you might get something which has no apparent holes. But that's only one terminal.

Related Solutions

Programmatically detect the ANSI escape code supported by terminal

Have you got specific operations in mind?

Here is an example of using standout mode, which on many terminals will give a strong visible result:

tput smso; echo hello, world; tput rmso

The tput tool uses the value of the $TERM environment variable to determine which escape sequences to output - if any. For example

TERM=xterm
( tput smso; echo hello, world; tput rmso ) | hexdump -C
00000000  1b 5b 37 6d 68 65 6c 6c  6f 2c 20 77 6f 72 6c 64  |.[7mhello, world|
00000010  0a 1b 5b 32 37 6d                                 |..[27m|

TERM=dumb
( tput smso; echo hello, world; tput rmso ) | hexdump -C
00000000  68 65 6c 6c 6f 2c 20 77  6f 72 6c 64 0a           |hello, world.|

Interesting characteristic pairs can be found in man 5 terminfo, some of which are as follows:

Standout: smso and rmso
Underline: smul and rmul
Blink (yes!): blink
Doublewide: swidm and rwidm
Reverse: rev
Cancel all: sgr0

If you want to write bold text, but only if the terminal understands it, then a snippet like this will work

boldOn=$(tput smso)
boldOff=$(tput rmso)
# ...
printf "%s%s%s\n" "$boldOn" 'This message will be in bold, when available' "$boldOff"

Linux – Keep terminal input line at the top of the terminal

Perhaps someone has done this (perhaps not). It would have to be done by a shell which knows how to collect the output of commands and update the screen. By itself, a regular terminal will not do this.

Supposing there were a program doing this, on each command

it would accept your input command (possibly multiple lines). To keep it simple, start by limiting inputs to a single line.
having gotten the text, the shell would run the command, collecting one line at a time from the command's standard output and error.
as it acquires a new line of output, it has to insert that line on the screen, pushing down the existing text. The insertion point moves down as more output is read. (Terminals provide low-level operations to help, but that's a long way from making it work).
if there is more output than will fit on the screen, the user likely expects the output to start scrolling up when the insertion point reaches the bottom of the screen.
when there is no more output (the command stops) the shell moves the cursor back to the top of the screen.

All of that is doable in a simple program. What is hard is if the command wants to take over the screen for itself. Programs which do this write — you guess it — to the standard output and the standard error. And they do not write plain text: they use escape sequences for moving around the screen.

If you limit this to the well-behaved applications which send a terminal initialization sequence, your shell could (in principle) detect this and give up for the time being, allowing the command to write to the screen. But well-behaved applications are not the majority, and you will have lots of interesting special cases to deal with.

Best Answer

Related Solutions

Programmatically detect the ANSI escape code supported by terminal

Linux – Keep terminal input line at the top of the terminal

Related Question