1 #include "git-compat-util.h"
2 #include "compat/terminal.h"
6 #include "run-command.h"
7 #include "string-list.h"
11 #if defined(HAVE_DEV_TTY) || defined(GIT_WINDOWS_NATIVE)
13 static void restore_term_on_signal(int sig
)
16 /* restore_term calls sigchain_pop_common */
22 #define INPUT_PATH "/dev/tty"
23 #define OUTPUT_PATH "/dev/tty"
25 static volatile sig_atomic_t term_fd_needs_closing
;
26 static int term_fd
= -1;
27 static struct termios old_term
;
29 static const char *background_resume_msg
;
30 static const char *restore_error_msg
;
31 static volatile sig_atomic_t ttou_received
;
33 /* async safe error function for use by signal handlers. */
34 static void write_err(const char *msg
)
36 write_in_full(2, "error: ", strlen("error: "));
37 write_in_full(2, msg
, strlen(msg
));
38 write_in_full(2, "\n", 1);
41 static void print_background_resume_msg(int signo
)
43 int saved_errno
= errno
;
45 struct sigaction old_sa
;
46 struct sigaction sa
= { .sa_handler
= SIG_DFL
};
49 write_err(background_resume_msg
);
50 sigaction(signo
, &sa
, &old_sa
);
53 sigaddset(&mask
, signo
);
54 sigprocmask(SIG_UNBLOCK
, &mask
, NULL
);
56 sigprocmask(SIG_BLOCK
, &mask
, NULL
);
57 sigaction(signo
, &old_sa
, NULL
);
61 static void restore_terminal_on_suspend(int signo
)
63 int saved_errno
= errno
;
67 struct sigaction old_sa
;
68 struct sigaction sa
= { .sa_handler
= SIG_DFL
};
71 if (tcgetattr(term_fd
, &t
) < 0)
74 if (tcsetattr(term_fd
, TCSAFLUSH
, &old_term
) < 0)
75 write_err(restore_error_msg
);
77 sigaction(signo
, &sa
, &old_sa
);
80 sigaddset(&mask
, signo
);
81 sigprocmask(SIG_UNBLOCK
, &mask
, NULL
);
83 sigprocmask(SIG_BLOCK
, &mask
, NULL
);
84 sigaction(signo
, &old_sa
, NULL
);
86 write_err(restore_error_msg
);
90 * If we resume in the background then we receive SIGTTOU when calling
91 * tcsetattr() below. Set up a handler to print an error message in that
95 sigaddset(&mask
, SIGTTOU
);
96 sa
.sa_mask
= old_sa
.sa_mask
;
97 sa
.sa_handler
= print_background_resume_msg
;
98 sa
.sa_flags
= SA_RESTART
;
99 sigaction(SIGTTOU
, &sa
, &old_sa
);
102 sigprocmask(SIG_UNBLOCK
, &mask
, NULL
);
103 res
= tcsetattr(term_fd
, TCSAFLUSH
, &t
);
104 sigprocmask(SIG_BLOCK
, &mask
, NULL
);
108 write_err(restore_error_msg
);
109 sigaction(SIGTTOU
, &old_sa
, NULL
);
114 static void reset_job_signals(void)
116 if (restore_error_msg
) {
117 signal(SIGTTIN
, SIG_DFL
);
118 signal(SIGTTOU
, SIG_DFL
);
119 signal(SIGTSTP
, SIG_DFL
);
120 restore_error_msg
= NULL
;
121 background_resume_msg
= NULL
;
125 static void close_term_fd(void)
127 if (term_fd_needs_closing
)
129 term_fd_needs_closing
= 0;
133 void restore_term(void)
138 tcsetattr(term_fd
, TCSAFLUSH
, &old_term
);
140 sigchain_pop_common();
144 int save_term(enum save_term_flags flags
)
149 term_fd
= ((flags
& SAVE_TERM_STDIN
)
151 : open("/dev/tty", O_RDWR
));
154 term_fd_needs_closing
= !(flags
& SAVE_TERM_STDIN
);
155 if (tcgetattr(term_fd
, &old_term
) < 0) {
159 sigchain_push_common(restore_term_on_signal
);
161 * If job control is disabled then the shell will have set the
162 * disposition of SIGTSTP to SIG_IGN.
164 sigaction(SIGTSTP
, NULL
, &sa
);
165 if (sa
.sa_handler
== SIG_IGN
)
168 /* avoid calling gettext() from signal handler */
169 background_resume_msg
= _("cannot resume in the background, please use 'fg' to resume");
170 restore_error_msg
= _("cannot restore terminal settings");
171 sa
.sa_handler
= restore_terminal_on_suspend
;
172 sa
.sa_flags
= SA_RESTART
;
173 sigemptyset(&sa
.sa_mask
);
174 sigaddset(&sa
.sa_mask
, SIGTSTP
);
175 sigaddset(&sa
.sa_mask
, SIGTTIN
);
176 sigaddset(&sa
.sa_mask
, SIGTTOU
);
177 sigaction(SIGTSTP
, &sa
, NULL
);
178 sigaction(SIGTTIN
, &sa
, NULL
);
179 sigaction(SIGTTOU
, &sa
, NULL
);
184 static int disable_bits(enum save_term_flags flags
, tcflag_t bits
)
188 if (save_term(flags
) < 0)
198 if (!tcsetattr(term_fd
, TCSAFLUSH
, &t
))
201 sigchain_pop_common();
207 static int disable_echo(enum save_term_flags flags
)
209 return disable_bits(flags
, ECHO
);
212 static int enable_non_canonical(enum save_term_flags flags
)
214 return disable_bits(flags
, ICANON
| ECHO
);
218 * On macos it is not possible to use poll() with a terminal so use select
221 static int getchar_with_timeout(int timeout
)
223 struct timeval tv
, *tvp
= NULL
;
229 tv
.tv_sec
= timeout
/ 1000;
230 tv
.tv_usec
= (timeout
% 1000) * 1000;
236 res
= select(1, &readfds
, NULL
, NULL
, tvp
);
248 #elif defined(GIT_WINDOWS_NATIVE)
250 #define INPUT_PATH "CONIN$"
251 #define OUTPUT_PATH "CONOUT$"
252 #define FORCE_TEXT "t"
254 static int use_stty
= 1;
255 static struct string_list stty_restore
= STRING_LIST_INIT_DUP
;
256 static HANDLE hconin
= INVALID_HANDLE_VALUE
;
257 static HANDLE hconout
= INVALID_HANDLE_VALUE
;
258 static DWORD cmode_in
, cmode_out
;
260 void restore_term(void)
264 struct child_process cp
= CHILD_PROCESS_INIT
;
266 if (stty_restore
.nr
== 0)
269 strvec_push(&cp
.args
, "stty");
270 for (i
= 0; i
< stty_restore
.nr
; i
++)
271 strvec_push(&cp
.args
, stty_restore
.items
[i
].string
);
273 string_list_clear(&stty_restore
, 0);
277 sigchain_pop_common();
279 if (hconin
== INVALID_HANDLE_VALUE
)
282 SetConsoleMode(hconin
, cmode_in
);
285 assert(hconout
!= INVALID_HANDLE_VALUE
);
286 SetConsoleMode(hconout
, cmode_out
);
287 CloseHandle(hconout
);
290 hconin
= hconout
= INVALID_HANDLE_VALUE
;
293 int save_term(enum save_term_flags flags
)
295 hconin
= CreateFileA("CONIN$", GENERIC_READ
| GENERIC_WRITE
,
296 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
297 FILE_ATTRIBUTE_NORMAL
, NULL
);
298 if (hconin
== INVALID_HANDLE_VALUE
)
301 if (flags
& SAVE_TERM_DUPLEX
) {
302 hconout
= CreateFileA("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
303 FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
,
304 FILE_ATTRIBUTE_NORMAL
, NULL
);
305 if (hconout
== INVALID_HANDLE_VALUE
)
308 GetConsoleMode(hconout
, &cmode_out
);
311 GetConsoleMode(hconin
, &cmode_in
);
313 sigchain_push_common(restore_term_on_signal
);
317 hconin
= INVALID_HANDLE_VALUE
;
321 static int disable_bits(enum save_term_flags flags
, DWORD bits
)
324 struct child_process cp
= CHILD_PROCESS_INIT
;
326 strvec_push(&cp
.args
, "stty");
328 if (bits
& ENABLE_LINE_INPUT
) {
329 string_list_append(&stty_restore
, "icanon");
331 * POSIX allows VMIN and VTIME to overlap with VEOF and
332 * VEOL - let's hope that is not the case on windows.
334 strvec_pushl(&cp
.args
, "-icanon", "min", "1", "time", "0", NULL
);
337 if (bits
& ENABLE_ECHO_INPUT
) {
338 string_list_append(&stty_restore
, "echo");
339 strvec_push(&cp
.args
, "-echo");
342 if (bits
& ENABLE_PROCESSED_INPUT
) {
343 string_list_append(&stty_restore
, "-ignbrk");
344 string_list_append(&stty_restore
, "intr");
345 string_list_append(&stty_restore
, "^c");
346 strvec_push(&cp
.args
, "ignbrk");
347 strvec_push(&cp
.args
, "intr");
348 strvec_push(&cp
.args
, "");
351 if (run_command(&cp
) == 0)
354 /* `stty` could not be executed; access the Console directly */
358 if (save_term(flags
) < 0)
361 if (!SetConsoleMode(hconin
, cmode_in
& ~bits
)) {
363 hconin
= INVALID_HANDLE_VALUE
;
364 sigchain_pop_common();
371 static int disable_echo(enum save_term_flags flags
)
373 return disable_bits(flags
, ENABLE_ECHO_INPUT
);
376 static int enable_non_canonical(enum save_term_flags flags
)
378 return disable_bits(flags
,
379 ENABLE_ECHO_INPUT
| ENABLE_LINE_INPUT
| ENABLE_PROCESSED_INPUT
);
383 * Override `getchar()`, as the default implementation does not use
386 * This poses a problem when we want to see whether the standard
387 * input has more characters, as the default of Git for Windows is to start the
388 * Bash in a MinTTY, which uses a named pipe to emulate a pty, in which case
389 * our `poll()` emulation calls `PeekNamedPipe()`, which seems to require
390 * `ReadFile()` to be called first to work properly (it only reports 0
391 * available bytes, otherwise).
393 * So let's just override `getchar()` with a version backed by `ReadFile()` and
394 * go our merry ways from here.
396 static int mingw_getchar(void)
401 if (!ReadFile(GetStdHandle(STD_INPUT_HANDLE
), &ch
, 1, &read
, NULL
))
405 error("Unexpected 0 read");
411 #define getchar mingw_getchar
413 static int getchar_with_timeout(int timeout
)
415 struct pollfd pfd
= { .fd
= 0, .events
= POLLIN
};
417 if (poll(&pfd
, 1, timeout
) < 1)
429 char *git_terminal_prompt(const char *prompt
, int echo
)
431 static struct strbuf buf
= STRBUF_INIT
;
433 FILE *input_fh
, *output_fh
;
435 input_fh
= fopen(INPUT_PATH
, "r" FORCE_TEXT
);
439 output_fh
= fopen(OUTPUT_PATH
, "w" FORCE_TEXT
);
445 if (!echo
&& disable_echo(0)) {
451 fputs(prompt
, output_fh
);
454 r
= strbuf_getline_lf(&buf
, input_fh
);
456 putc('\n', output_fh
);
470 * The `is_known_escape_sequence()` function returns 1 if the passed string
471 * corresponds to an Escape sequence that the terminal capabilities contains.
473 * To avoid depending on ncurses or other platform-specific libraries, we rely
474 * on the presence of the `infocmp` executable to do the job for us (failing
475 * silently if the program is not available or refused to run).
477 struct escape_sequence_entry
{
478 struct hashmap_entry entry
;
479 char sequence
[FLEX_ARRAY
];
482 static int sequence_entry_cmp(const void *hashmap_cmp_fn_data UNUSED
,
483 const struct escape_sequence_entry
*e1
,
484 const struct escape_sequence_entry
*e2
,
487 return strcmp(e1
->sequence
, keydata
? keydata
: e2
->sequence
);
490 static int is_known_escape_sequence(const char *sequence
)
492 static struct hashmap sequences
;
493 static int initialized
;
496 struct child_process cp
= CHILD_PROCESS_INIT
;
497 struct strbuf buf
= STRBUF_INIT
;
500 hashmap_init(&sequences
, (hashmap_cmp_fn
)sequence_entry_cmp
,
503 strvec_pushl(&cp
.args
, "infocmp", "-L", "-1", NULL
);
504 if (pipe_command(&cp
, NULL
, 0, &buf
, 0, NULL
, 0))
505 strbuf_setlen(&buf
, 0);
507 for (eol
= p
= buf
.buf
; *p
; p
= eol
+ 1) {
512 eol
= strchrnul(p
, '\n');
514 if (starts_with(p
, "\\E")) {
515 char *comma
= memchr(p
, ',', eol
- p
);
516 struct escape_sequence_entry
*e
;
520 FLEX_ALLOC_MEM(e
, sequence
, p
, comma
- p
);
521 hashmap_entry_init(&e
->entry
,
522 strhash(e
->sequence
));
523 hashmap_add(&sequences
, &e
->entry
);
531 return !!hashmap_get_from_hash(&sequences
, strhash(sequence
), sequence
);
534 int read_key_without_echo(struct strbuf
*buf
)
536 static int warning_displayed
;
539 if (warning_displayed
|| enable_non_canonical(SAVE_TERM_STDIN
) < 0) {
540 if (!warning_displayed
) {
541 warning("reading single keystrokes not supported on "
542 "this platform; reading line instead");
543 warning_displayed
= 1;
546 return strbuf_getline(buf
, stdin
);
555 strbuf_addch(buf
, ch
);
557 if (ch
== '\033' /* ESC */) {
559 * We are most likely looking at an Escape sequence. Let's try
560 * to read more bytes, waiting at most half a second, assuming
561 * that the sequence is complete if we did not receive any byte
564 * Start by replacing the Escape byte with ^[ */
565 strbuf_splice(buf
, buf
->len
- 1, 1, "^[", 2);
568 * Query the terminal capabilities once about all the Escape
569 * sequences it knows about, so that we can avoid waiting for
570 * half a second when we know that the sequence is complete.
572 while (!is_known_escape_sequence(buf
->buf
)) {
573 ch
= getchar_with_timeout(500);
576 strbuf_addch(buf
, ch
);
586 int save_term(enum save_term_flags flags
)
588 /* no duplex support available */
589 return -!!(flags
& SAVE_TERM_DUPLEX
);
592 void restore_term(void)
596 char *git_terminal_prompt(const char *prompt
, int echo
)
598 return getpass(prompt
);
601 int read_key_without_echo(struct strbuf
*buf
)
603 static int warning_displayed
;
606 if (!warning_displayed
) {
607 warning("reading single keystrokes not supported on this "
608 "platform; reading line instead");
609 warning_displayed
= 1;
616 strbuf_addstr(buf
, res
);