mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Elijah Newren](/assets/img/avatar_default.png)
The last several commits were geared at replacing the include of cache.h in strbuf.c with an include of git-compat-util.h. Unfortunately, I had to drop a patch moving some functions from cache.h to object-name.h, due to excessive conflicts with other in-flight topics. However, even without that patch, the series of patches so far allows us to modify a number of C files to replace an include of cache.h with git-compat-util.h. Do that to reduce our dependencies. (If we could have kept our object-name.h patch in this series, it would have also let us reduce the includes in checkout.c and fmt-merge-msg.c in addition to strbuf.c). Just to ensure that nothing else was bringing in cache.h, all of the affected files have been checked to ensure that gcc -E -I. $SOURCE_FILE | grep '"cache.h"' found no hits and that make DEVELOPER=1 ${OBJECT_FILE_FOR_SOURCE_FILE} successfully compiles without warnings. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
621 lines
14 KiB
C
621 lines
14 KiB
C
#include "git-compat-util.h"
|
|
#include "compat/terminal.h"
|
|
#include "gettext.h"
|
|
#include "sigchain.h"
|
|
#include "strbuf.h"
|
|
#include "run-command.h"
|
|
#include "string-list.h"
|
|
#include "hashmap.h"
|
|
#include "wrapper.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
|