| #include "cache.h" |
| #include "compat/terminal.h" |
| #include "sigchain.h" |
| #include "strbuf.h" |
| #include "run-command.h" |
| #include "string-list.h" |
| #include "hashmap.h" |
| |
| #if defined(HAVE_DEV_TTY) || defined(GIT_WINDOWS_NATIVE) |
| |
| static void restore_term_on_signal(int sig) |
| { |
| restore_term(); |
| /* restore_term calls sigchain_pop_common */ |
| raise(sig); |
| } |
| |
| #ifdef HAVE_DEV_TTY |
| |
| #define INPUT_PATH "/dev/tty" |
| #define OUTPUT_PATH "/dev/tty" |
| |
| static volatile sig_atomic_t term_fd_needs_closing; |
| static int term_fd = -1; |
| static struct termios old_term; |
| |
| static const char *background_resume_msg; |
| static const char *restore_error_msg; |
| static volatile sig_atomic_t ttou_received; |
| |
| /* async safe error function for use by signal handlers. */ |
| static void write_err(const char *msg) |
| { |
| write_in_full(2, "error: ", strlen("error: ")); |
| write_in_full(2, msg, strlen(msg)); |
| write_in_full(2, "\n", 1); |
| } |
| |
| static void print_background_resume_msg(int signo) |
| { |
| int saved_errno = errno; |
| sigset_t mask; |
| struct sigaction old_sa; |
| struct sigaction sa = { .sa_handler = SIG_DFL }; |
| |
| ttou_received = 1; |
| write_err(background_resume_msg); |
| sigaction(signo, &sa, &old_sa); |
| raise(signo); |
| sigemptyset(&mask); |
| sigaddset(&mask, signo); |
| sigprocmask(SIG_UNBLOCK, &mask, NULL); |
| /* Stopped here */ |
| sigprocmask(SIG_BLOCK, &mask, NULL); |
| sigaction(signo, &old_sa, NULL); |
| errno = saved_errno; |
| } |
| |
| static void restore_terminal_on_suspend(int signo) |
| { |
| int saved_errno = errno; |
| int res; |
| struct termios t; |
| sigset_t mask; |
| struct sigaction old_sa; |
| struct sigaction sa = { .sa_handler = SIG_DFL }; |
| int can_restore = 1; |
| |
| if (tcgetattr(term_fd, &t) < 0) |
| can_restore = 0; |
| |
| if (tcsetattr(term_fd, TCSAFLUSH, &old_term) < 0) |
| write_err(restore_error_msg); |
| |
| sigaction(signo, &sa, &old_sa); |
| raise(signo); |
| sigemptyset(&mask); |
| sigaddset(&mask, signo); |
| sigprocmask(SIG_UNBLOCK, &mask, NULL); |
| /* Stopped here */ |
| sigprocmask(SIG_BLOCK, &mask, NULL); |
| sigaction(signo, &old_sa, NULL); |
| if (!can_restore) { |
| write_err(restore_error_msg); |
| goto out; |
| } |
| /* |
| * If we resume in the background then we receive SIGTTOU when calling |
| * tcsetattr() below. Set up a handler to print an error message in that |
| * case. |
| */ |
| sigemptyset(&mask); |
| sigaddset(&mask, SIGTTOU); |
| sa.sa_mask = old_sa.sa_mask; |
| sa.sa_handler = print_background_resume_msg; |
| sa.sa_flags = SA_RESTART; |
| sigaction(SIGTTOU, &sa, &old_sa); |
| again: |
| ttou_received = 0; |
| sigprocmask(SIG_UNBLOCK, &mask, NULL); |
| res = tcsetattr(term_fd, TCSAFLUSH, &t); |
| sigprocmask(SIG_BLOCK, &mask, NULL); |
| if (ttou_received) |
| goto again; |
| else if (res < 0) |
| write_err(restore_error_msg); |
| sigaction(SIGTTOU, &old_sa, NULL); |
| out: |
| errno = saved_errno; |
| } |
| |
| static void reset_job_signals(void) |
| { |
| if (restore_error_msg) { |
| signal(SIGTTIN, SIG_DFL); |
| signal(SIGTTOU, SIG_DFL); |
| signal(SIGTSTP, SIG_DFL); |
| restore_error_msg = NULL; |
| background_resume_msg = NULL; |
| } |
| } |
| |
| static void close_term_fd(void) |
| { |
| if (term_fd_needs_closing) |
| close(term_fd); |
| term_fd_needs_closing = 0; |
| term_fd = -1; |
| } |
| |
| void restore_term(void) |
| { |
| if (term_fd < 0) |
| return; |
| |
| tcsetattr(term_fd, TCSAFLUSH, &old_term); |
| close_term_fd(); |
| sigchain_pop_common(); |
| reset_job_signals(); |
| } |
| |
| int save_term(enum save_term_flags flags) |
| { |
| struct sigaction sa; |
| |
| if (term_fd < 0) |
| term_fd = ((flags & SAVE_TERM_STDIN) |
| ? 0 |
| : open("/dev/tty", O_RDWR)); |
| if (term_fd < 0) |
| return -1; |
| term_fd_needs_closing = !(flags & SAVE_TERM_STDIN); |
| if (tcgetattr(term_fd, &old_term) < 0) { |
| close_term_fd(); |
| return -1; |
| } |
| sigchain_push_common(restore_term_on_signal); |
| /* |
| * If job control is disabled then the shell will have set the |
| * disposition of SIGTSTP to SIG_IGN. |
| */ |
| sigaction(SIGTSTP, NULL, &sa); |
| if (sa.sa_handler == SIG_IGN) |
| return 0; |
| |
| /* avoid calling gettext() from signal handler */ |
| background_resume_msg = _("cannot resume in the background, please use 'fg' to resume"); |
| restore_error_msg = _("cannot restore terminal settings"); |
| sa.sa_handler = restore_terminal_on_suspend; |
| sa.sa_flags = SA_RESTART; |
| sigemptyset(&sa.sa_mask); |
| sigaddset(&sa.sa_mask, SIGTSTP); |
| sigaddset(&sa.sa_mask, SIGTTIN); |
| sigaddset(&sa.sa_mask, SIGTTOU); |
| sigaction(SIGTSTP, &sa, NULL); |
| sigaction(SIGTTIN, &sa, NULL); |
| sigaction(SIGTTOU, &sa, NULL); |
| |
| return 0; |
| } |
| |
| static int disable_bits(enum save_term_flags flags, tcflag_t bits) |
| { |
| struct termios t; |
| |
| if (save_term(flags) < 0) |
| return -1; |
| |
| t = old_term; |
| |
| t.c_lflag &= ~bits; |
| if (bits & ICANON) { |
| t.c_cc[VMIN] = 1; |
| t.c_cc[VTIME] = 0; |
| } |
| if (!tcsetattr(term_fd, TCSAFLUSH, &t)) |
| return 0; |
| |
| sigchain_pop_common(); |
| reset_job_signals(); |
| close_term_fd(); |
| return -1; |
| } |
| |
| static int disable_echo(enum save_term_flags flags) |
| { |
| return disable_bits(flags, ECHO); |
| } |
| |
| static int enable_non_canonical(enum save_term_flags flags) |
| { |
| return disable_bits(flags, ICANON | ECHO); |
| } |
| |
| /* |
| * On macos it is not possible to use poll() with a terminal so use select |
| * instead. |
| */ |
| static int getchar_with_timeout(int timeout) |
| { |
| struct timeval tv, *tvp = NULL; |
| fd_set readfds; |
| int res; |
| |
| again: |
| if (timeout >= 0) { |
| tv.tv_sec = timeout / 1000; |
| tv.tv_usec = (timeout % 1000) * 1000; |
| tvp = &tv; |
| } |
| |
| FD_ZERO(&readfds); |
| FD_SET(0, &readfds); |
| res = select(1, &readfds, NULL, NULL, tvp); |
| if (!res) |
| return EOF; |
| if (res < 0) { |
| if (errno == EINTR) |
| goto again; |
| else |
| return EOF; |
| } |
| return getchar(); |
| } |
| |
| #elif defined(GIT_WINDOWS_NATIVE) |
| |
| #define INPUT_PATH "CONIN$" |
| #define OUTPUT_PATH "CONOUT$" |
| #define FORCE_TEXT "t" |
| |
| static int use_stty = 1; |
| static struct string_list stty_restore = STRING_LIST_INIT_DUP; |
| static HANDLE hconin = INVALID_HANDLE_VALUE; |
| static HANDLE hconout = INVALID_HANDLE_VALUE; |
| static DWORD cmode_in, cmode_out; |
| |
| void restore_term(void) |
| { |
| if (use_stty) { |
| int i; |
| struct child_process cp = CHILD_PROCESS_INIT; |
| |
| if (stty_restore.nr == 0) |
| return; |
| |
| strvec_push(&cp.args, "stty"); |
| for (i = 0; i < stty_restore.nr; i++) |
| strvec_push(&cp.args, stty_restore.items[i].string); |
| run_command(&cp); |
| string_list_clear(&stty_restore, 0); |
| return; |
| } |
| |
| sigchain_pop_common(); |
| |
| if (hconin == INVALID_HANDLE_VALUE) |
| return; |
| |
| SetConsoleMode(hconin, cmode_in); |
| CloseHandle(hconin); |
| if (cmode_out) { |
| assert(hconout != INVALID_HANDLE_VALUE); |
| SetConsoleMode(hconout, cmode_out); |
| CloseHandle(hconout); |
| } |
| |
| hconin = hconout = INVALID_HANDLE_VALUE; |
| } |
| |
| int save_term(enum save_term_flags flags) |
| { |
| hconin = CreateFileA("CONIN$", GENERIC_READ | GENERIC_WRITE, |
| FILE_SHARE_READ, NULL, OPEN_EXISTING, |
| FILE_ATTRIBUTE_NORMAL, NULL); |
| if (hconin == INVALID_HANDLE_VALUE) |
| return -1; |
| |
| if (flags & SAVE_TERM_DUPLEX) { |
| hconout = CreateFileA("CONOUT$", GENERIC_READ | GENERIC_WRITE, |
| FILE_SHARE_WRITE, NULL, OPEN_EXISTING, |
| FILE_ATTRIBUTE_NORMAL, NULL); |
| if (hconout == INVALID_HANDLE_VALUE) |
| goto error; |
| |
| GetConsoleMode(hconout, &cmode_out); |
| } |
| |
| GetConsoleMode(hconin, &cmode_in); |
| use_stty = 0; |
| sigchain_push_common(restore_term_on_signal); |
| return 0; |
| error: |
| CloseHandle(hconin); |
| hconin = INVALID_HANDLE_VALUE; |
| return -1; |
| } |
| |
| static int disable_bits(enum save_term_flags flags, DWORD bits) |
| { |
| if (use_stty) { |
| struct child_process cp = CHILD_PROCESS_INIT; |
| |
| strvec_push(&cp.args, "stty"); |
| |
| if (bits & ENABLE_LINE_INPUT) { |
| string_list_append(&stty_restore, "icanon"); |
| /* |
| * POSIX allows VMIN and VTIME to overlap with VEOF and |
| * VEOL - let's hope that is not the case on windows. |
| */ |
| strvec_pushl(&cp.args, "-icanon", "min", "1", "time", "0", NULL); |
| } |
| |
| if (bits & ENABLE_ECHO_INPUT) { |
| string_list_append(&stty_restore, "echo"); |
| strvec_push(&cp.args, "-echo"); |
| } |
| |
| if (bits & ENABLE_PROCESSED_INPUT) { |
| string_list_append(&stty_restore, "-ignbrk"); |
| string_list_append(&stty_restore, "intr"); |
| string_list_append(&stty_restore, "^c"); |
| strvec_push(&cp.args, "ignbrk"); |
| strvec_push(&cp.args, "intr"); |
| strvec_push(&cp.args, ""); |
| } |
| |
| if (run_command(&cp) == 0) |
| return 0; |
| |
| /* `stty` could not be executed; access the Console directly */ |
| use_stty = 0; |
| } |
| |
| if (save_term(flags) < 0) |
| return -1; |
| |
| if (!SetConsoleMode(hconin, cmode_in & ~bits)) { |
| CloseHandle(hconin); |
| hconin = INVALID_HANDLE_VALUE; |
| sigchain_pop_common(); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int disable_echo(enum save_term_flags flags) |
| { |
| return disable_bits(flags, ENABLE_ECHO_INPUT); |
| } |
| |
| static int enable_non_canonical(enum save_term_flags flags) |
| { |
| return disable_bits(flags, |
| ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT); |
| } |
| |
| /* |
| * Override `getchar()`, as the default implementation does not use |
| * `ReadFile()`. |
| * |
| * This poses a problem when we want to see whether the standard |
| * input has more characters, as the default of Git for Windows is to start the |
| * Bash in a MinTTY, which uses a named pipe to emulate a pty, in which case |
| * our `poll()` emulation calls `PeekNamedPipe()`, which seems to require |
| * `ReadFile()` to be called first to work properly (it only reports 0 |
| * available bytes, otherwise). |
| * |
| * So let's just override `getchar()` with a version backed by `ReadFile()` and |
| * go our merry ways from here. |
| */ |
| static int mingw_getchar(void) |
| { |
| DWORD read = 0; |
| unsigned char ch; |
| |
| if (!ReadFile(GetStdHandle(STD_INPUT_HANDLE), &ch, 1, &read, NULL)) |
| return EOF; |
| |
| if (!read) { |
| error("Unexpected 0 read"); |
| return EOF; |
| } |
| |
| return ch; |
| } |
| #define getchar mingw_getchar |
| |
| static int getchar_with_timeout(int timeout) |
| { |
| struct pollfd pfd = { .fd = 0, .events = POLLIN }; |
| |
| if (poll(&pfd, 1, timeout) < 1) |
| return EOF; |
| |
| return getchar(); |
| } |
| |
| #endif |
| |
| #ifndef FORCE_TEXT |
| #define FORCE_TEXT |
| #endif |
| |
| char *git_terminal_prompt(const char *prompt, int echo) |
| { |
| static struct strbuf buf = STRBUF_INIT; |
| int r; |
| FILE *input_fh, *output_fh; |
| |
| input_fh = fopen(INPUT_PATH, "r" FORCE_TEXT); |
| if (!input_fh) |
| return NULL; |
| |
| output_fh = fopen(OUTPUT_PATH, "w" FORCE_TEXT); |
| if (!output_fh) { |
| fclose(input_fh); |
| return NULL; |
| } |
| |
| if (!echo && disable_echo(0)) { |
| fclose(input_fh); |
| fclose(output_fh); |
| return NULL; |
| } |
| |
| fputs(prompt, output_fh); |
| fflush(output_fh); |
| |
| r = strbuf_getline_lf(&buf, input_fh); |
| if (!echo) { |
| putc('\n', output_fh); |
| fflush(output_fh); |
| } |
| |
| restore_term(); |
| fclose(input_fh); |
| fclose(output_fh); |
| |
| if (r == EOF) |
| return NULL; |
| return buf.buf; |
| } |
| |
| /* |
| * The `is_known_escape_sequence()` function returns 1 if the passed string |
| * corresponds to an Escape sequence that the terminal capabilities contains. |
| * |
| * To avoid depending on ncurses or other platform-specific libraries, we rely |
| * on the presence of the `infocmp` executable to do the job for us (failing |
| * silently if the program is not available or refused to run). |
| */ |
| struct escape_sequence_entry { |
| struct hashmap_entry entry; |
| char sequence[FLEX_ARRAY]; |
| }; |
| |
| static int sequence_entry_cmp(const void *hashmap_cmp_fn_data UNUSED, |
| const struct escape_sequence_entry *e1, |
| const struct escape_sequence_entry *e2, |
| const void *keydata) |
| { |
| return strcmp(e1->sequence, keydata ? keydata : e2->sequence); |
| } |
| |
| static int is_known_escape_sequence(const char *sequence) |
| { |
| static struct hashmap sequences; |
| static int initialized; |
| |
| if (!initialized) { |
| struct child_process cp = CHILD_PROCESS_INIT; |
| struct strbuf buf = STRBUF_INIT; |
| char *p, *eol; |
| |
| hashmap_init(&sequences, (hashmap_cmp_fn)sequence_entry_cmp, |
| NULL, 0); |
| |
| strvec_pushl(&cp.args, "infocmp", "-L", "-1", NULL); |
| if (pipe_command(&cp, NULL, 0, &buf, 0, NULL, 0)) |
| strbuf_setlen(&buf, 0); |
| |
| for (eol = p = buf.buf; *p; p = eol + 1) { |
| p = strchr(p, '='); |
| if (!p) |
| break; |
| p++; |
| eol = strchrnul(p, '\n'); |
| |
| if (starts_with(p, "\\E")) { |
| char *comma = memchr(p, ',', eol - p); |
| struct escape_sequence_entry *e; |
| |
| p[0] = '^'; |
| p[1] = '['; |
| FLEX_ALLOC_MEM(e, sequence, p, comma - p); |
| hashmap_entry_init(&e->entry, |
| strhash(e->sequence)); |
| hashmap_add(&sequences, &e->entry); |
| } |
| if (!*eol) |
| break; |
| } |
| initialized = 1; |
| } |
| |
| return !!hashmap_get_from_hash(&sequences, strhash(sequence), sequence); |
| } |
| |
| int read_key_without_echo(struct strbuf *buf) |
| { |
| static int warning_displayed; |
| int ch; |
| |
| if (warning_displayed || enable_non_canonical(SAVE_TERM_STDIN) < 0) { |
| if (!warning_displayed) { |
| warning("reading single keystrokes not supported on " |
| "this platform; reading line instead"); |
| warning_displayed = 1; |
| } |
| |
| return strbuf_getline(buf, stdin); |
| } |
| |
| strbuf_reset(buf); |
| ch = getchar(); |
| if (ch == EOF) { |
| restore_term(); |
| return EOF; |
| } |
| strbuf_addch(buf, ch); |
| |
| if (ch == '\033' /* ESC */) { |
| /* |
| * We are most likely looking at an Escape sequence. Let's try |
| * to read more bytes, waiting at most half a second, assuming |
| * that the sequence is complete if we did not receive any byte |
| * within that time. |
| * |
| * Start by replacing the Escape byte with ^[ */ |
| strbuf_splice(buf, buf->len - 1, 1, "^[", 2); |
| |
| /* |
| * Query the terminal capabilities once about all the Escape |
| * sequences it knows about, so that we can avoid waiting for |
| * half a second when we know that the sequence is complete. |
| */ |
| while (!is_known_escape_sequence(buf->buf)) { |
| ch = getchar_with_timeout(500); |
| if (ch == EOF) |
| break; |
| strbuf_addch(buf, ch); |
| } |
| } |
| |
| restore_term(); |
| return 0; |
| } |
| |
| #else |
| |
| int save_term(enum save_term_flags flags) |
| { |
| /* no duplex support available */ |
| return -!!(flags & SAVE_TERM_DUPLEX); |
| } |
| |
| void restore_term(void) |
| { |
| } |
| |
| char *git_terminal_prompt(const char *prompt, int echo) |
| { |
| return getpass(prompt); |
| } |
| |
| int read_key_without_echo(struct strbuf *buf) |
| { |
| static int warning_displayed; |
| const char *res; |
| |
| if (!warning_displayed) { |
| warning("reading single keystrokes not supported on this " |
| "platform; reading line instead"); |
| warning_displayed = 1; |
| } |
| |
| res = getpass(""); |
| strbuf_reset(buf); |
| if (!res) |
| return EOF; |
| strbuf_addstr(buf, res); |
| return 0; |
| } |
| |
| #endif |