kernel: Restore prim_tty signals option to pass control bytes through in raw mode

Author: gilbertwong96

erts/emulator/nifs/common/prim_tty_nif.c

@@ -961,7 +961,7 @@ static ERL_NIF_TERM tty_create_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
 
 static ERL_NIF_TERM tty_init_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
 
-    ERL_NIF_TERM input;
+    ERL_NIF_TERM input, signals;
     TTYResource *tty;
 
     debug("tty_init_nif(%T,%T)\r\n", argv[0], argv[1]);
@@ -976,6 +976,14 @@ static ERL_NIF_TERM tty_init_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar
     if (!enif_get_map_value(env, argv[1], enif_make_atom(env, "input"), &input))
         return enif_make_badarg(env);
 
+    /* Whether signal and flow-control handling should stay enabled in
+       raw mode. Defaults to true to preserve the shell's ctrl+c break
+       behavior. When false, ISIG, IEXTEN and IXON are disabled so that
+       control bytes such as ctrl+o, ctrl+c and ctrl+s/ctrl+q reach the
+       application. */
+    if (!enif_get_map_value(env, argv[1], enif_make_atom(env, "signals"), &signals))
+        signals = atom_true;
+
     if (tty->tty == unavailable) {
         if (enif_is_identical(input, atom_raw))
             return make_enotsup(env);
@@ -1014,6 +1022,15 @@ static ERL_NIF_TERM tty_init_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar
             /* erts_fprintf(stderr,"echo %T\r\n", echo); */
             tty->tty_smode.c_lflag &= ~ECHO;
 
+            if (enif_is_identical(signals, atom_false)) {
+                /* Also disable signal and flow-control handling so that
+                   control bytes are passed through to the application.
+                   This restores the sig => false behavior that the
+                   prim_tty API had before the OTP 27 cleanup. */
+                tty->tty_smode.c_iflag &= ~(BRKINT|IGNPAR|IXON|IXANY);
+                tty->tty_smode.c_lflag &= ~(ISIG|IEXTEN);
+            }
+
         }
 
         if (tcsetattr(tty->ofd, TCSANOW, &tty->tty_smode) < 0) {

lib/kernel/src/prim_tty.erl

@@ -171,7 +171,8 @@
 
 -type options() :: #{ input := cooked | raw | disabled,
                       output := raw | cooked,
-                      ofd => stdout | stderr }.
+                      ofd => stdout | stderr,
+                      signals => boolean() }.
 -type request() ::
         {putc_raw, binary()} |
         {putc, unicode:unicode_binary()} |
@@ -352,7 +353,8 @@ reinit(State = #state{ options = OldOptions }, UserOptions) ->
     end.
 
 options(UserOptions) ->
-    maps:merge(#{ input => raw, output => cooked, ofd => stdout }, UserOptions).
+    maps:merge(#{ input => raw, output => cooked, ofd => stdout,
+                   signals => true }, UserOptions).
 
 init(State, ssh) ->
     State#state{ xn = true };

lib/kernel/test/interactive_shell_SUITE.erl

@@ -43,7 +43,7 @@
          init_per_testcase/2, end_per_testcase/2,
 	 get_columns_and_rows/1, exit_initial/1, job_control_local/1,
 	 job_control_remote/1,stop_during_init/1,wrap/1,
-         noshell_raw/1,
+         noshell_raw/1, raw_signals/1,
          shell_history/1, shell_history_resize/1, shell_history_eaccess/1,
          shell_history_repair/1, shell_history_repair_corrupt/1,
          shell_history_corrupt/1,
@@ -154,7 +154,8 @@ groups() ->
        external_editor,
        external_editor_visual,
        shell_ignore_pager_commands,
-       shell_help
+       shell_help,
+       raw_signals
       ]},
      {tty_unicode,[parallel],
       [{group,tty_tests},
@@ -2125,6 +2126,69 @@ noshell_raw(Config) ->
     end,
     ok.
 
+%% Verify that control bytes reach the application in raw mode when
+%% signal and flow-control handling is disabled. ctrl+o is VDISCARD on
+%% POSIX: while IEXTEN is set the terminal driver swallows the byte, so
+%% the reader would time out. Uses a noshell peer on a tmux pty so that
+%% prim_tty is the only reader of the terminal.
+raw_signals(Config) ->
+    Term = shell_test_lib:setup_tty(
+             [{args, ["-noshell", "-noinput"]} | Config]),
+
+    try
+        %% Init the terminal in raw mode with signals disabled and start
+        %% a reader that reports the first byte it receives.
+        ok = shell_test_lib:rpc(Term, fun() ->
+            Self = self(),
+            spawn(fun() ->
+                %% prim_tty names its reader and writer processes after
+                %% the parent, so the parent must be registered.
+                register(raw_signals_probe, self()),
+                ok = prim_tty:load(),
+                TTY = prim_tty:init(#{input => raw, output => cooked,
+                                      signals => false}),
+                #{read := Ref} = prim_tty:handles(TTY),
+                Self ! ready,
+                ok = prim_tty:read(TTY, 1),
+                Res = receive
+                          {Ref, {data, Data}} -> {ok, Data};
+                          {Ref, eof} -> eof
+                      after 5000 -> timeout
+                      end,
+                persistent_term:put({?MODULE, raw_signals}, Res)
+            end),
+            receive ready -> ok after 10000 -> timeout end
+        end),
+
+        %% Send ctrl+o (0x0f) through the pty. With signals enabled this
+        %% byte is consumed by the terminal driver's discard function
+        %% and never reaches the application. tmux send-keys writes to
+        %% the master side, so the byte passes through the line
+        %% discipline of the pane.
+        shell_test_lib:send_tty(Term, "C-o"),
+
+        %% The byte must be delivered to the reader.
+        {ok, <<$\^o>>} = await_raw_signals(Term)
+    after
+        shell_test_lib:stop_tty(Term)
+    end.
+
+await_raw_signals(Term) ->
+    await_raw_signals(Term, 50).
+
+await_raw_signals(_Term, 0) ->
+    not_set;
+await_raw_signals(Term, N) ->
+    case shell_test_lib:rpc(Term, fun() ->
+        persistent_term:get({?MODULE, raw_signals}, not_set)
+    end) of
+        not_set ->
+            timer:sleep(100),
+            await_raw_signals(Term, N - 1);
+        Res ->
+            Res
+    end.
+
 get_until(start, NewChars) ->
     get_until([], NewChars);
 get_until(State, NewChars) ->