compat/terminal.c

   1 #include "git-compat-util.h"
   2 #include "compat/terminal.h"
   3 #include "gettext.h"
   4 #include "sigchain.h"
   5 #include "strbuf.h"
   6 #include "run-command.h"
   7 #include "string-list.h"
   8 #include "hashmap.h"
   9
  10 #if defined(HAVE_DEV_TTY) || defined(GIT_WINDOWS_NATIVE)
  11
  12 static void restore_term_on_signal(int sig)
  13 {
  14         restore_term();
  15         /* restore_term calls sigchain_pop_common */
  16         raise(sig);
  17 }
  18
  19 #ifdef HAVE_DEV_TTY
  20
  21 #define INPUT_PATH "/dev/tty"
  22 #define OUTPUT_PATH "/dev/tty"
  23
  24 static volatile sig_atomic_t term_fd_needs_closing;
  25 static int term_fd = -1;
  26 static struct termios old_term;
  27
  28 static const char *background_resume_msg;
  29 static const char *restore_error_msg;
  30 static volatile sig_atomic_t ttou_received;
  31
  32 /* async safe error function for use by signal handlers. */
  33 static void write_err(const char *msg)
  34 {
  35         write_in_full(2, "error: ", strlen("error: "));
  36         write_in_full(2, msg, strlen(msg));
  37         write_in_full(2, "\n", 1);
  38 }
  39
  40 static void print_background_resume_msg(int signo)
  41 {
  42         int saved_errno = errno;
  43         sigset_t mask;
  44         struct sigaction old_sa;
  45         struct sigaction sa = { .sa_handler = SIG_DFL };
  46
  47         ttou_received = 1;
  48         write_err(background_resume_msg);
  49         sigaction(signo, &sa, &old_sa);
  50         raise(signo);
  51         sigemptyset(&mask);
  52         sigaddset(&mask, signo);
  53         sigprocmask(SIG_UNBLOCK, &mask, NULL);
  54         /* Stopped here */
  55         sigprocmask(SIG_BLOCK, &mask, NULL);
  56         sigaction(signo, &old_sa, NULL);
  57         errno = saved_errno;
  58 }
  59
  60 static void restore_terminal_on_suspend(int signo)
  61 {
  62         int saved_errno = errno;
  63         int res;
  64         struct termios t;
  65         sigset_t mask;
  66         struct sigaction old_sa;
  67         struct sigaction sa = { .sa_handler = SIG_DFL };
  68         int can_restore = 1;
  69
  70         if (tcgetattr(term_fd, &t) < 0)
  71                 can_restore = 0;
  72
  73         if (tcsetattr(term_fd, TCSAFLUSH, &old_term) < 0)
  74                 write_err(restore_error_msg);
  75
  76         sigaction(signo, &sa, &old_sa);
  77         raise(signo);
  78         sigemptyset(&mask);
  79         sigaddset(&mask, signo);
  80         sigprocmask(SIG_UNBLOCK, &mask, NULL);
  81         /* Stopped here */
  82         sigprocmask(SIG_BLOCK, &mask, NULL);
  83         sigaction(signo, &old_sa, NULL);
  84         if (!can_restore) {
  85                 write_err(restore_error_msg);
  86                 goto out;
  87         }
  88         /*
  89          * If we resume in the background then we receive SIGTTOU when calling
  90          * tcsetattr() below. Set up a handler to print an error message in that
  91          * case.
  92          */
  93         sigemptyset(&mask);
  94         sigaddset(&mask, SIGTTOU);
  95         sa.sa_mask = old_sa.sa_mask;
  96         sa.sa_handler = print_background_resume_msg;
  97         sa.sa_flags = SA_RESTART;
  98         sigaction(SIGTTOU, &sa, &old_sa);
  99  again:
 100         ttou_received = 0;
 101         sigprocmask(SIG_UNBLOCK, &mask, NULL);
 102         res = tcsetattr(term_fd, TCSAFLUSH, &t);
 103         sigprocmask(SIG_BLOCK, &mask, NULL);
 104         if (ttou_received)
 105                 goto again;
 106         else if (res < 0)
 107                 write_err(restore_error_msg);
 108         sigaction(SIGTTOU, &old_sa, NULL);
 109  out:
 110         errno = saved_errno;
 111 }
 112
 113 static void reset_job_signals(void)
 114 {
 115         if (restore_error_msg) {
 116                 signal(SIGTTIN, SIG_DFL);
 117                 signal(SIGTTOU, SIG_DFL);
 118                 signal(SIGTSTP, SIG_DFL);
 119                 restore_error_msg = NULL;
 120                 background_resume_msg = NULL;
 121         }
 122 }
 123
 124 static void close_term_fd(void)
 125 {
 126         if (term_fd_needs_closing)
 127                 close(term_fd);
 128         term_fd_needs_closing = 0;
 129         term_fd = -1;
 130 }
 131
 132 void restore_term(void)
 133 {
 134         if (term_fd < 0)
 135                 return;
 136
 137         tcsetattr(term_fd, TCSAFLUSH, &old_term);
 138         close_term_fd();
 139         sigchain_pop_common();
 140         reset_job_signals();
 141 }
 142
 143 int save_term(enum save_term_flags flags)
 144 {
 145         struct sigaction sa;
 146
 147         if (term_fd < 0)
 148                 term_fd = ((flags & SAVE_TERM_STDIN)
 149                            ? 0
 150                            : open("/dev/tty", O_RDWR));
 151         if (term_fd < 0)
 152                 return -1;
 153         term_fd_needs_closing = !(flags & SAVE_TERM_STDIN);
 154         if (tcgetattr(term_fd, &old_term) < 0) {
 155                 close_term_fd();
 156                 return -1;
 157         }
 158         sigchain_push_common(restore_term_on_signal);
 159         /*
 160          * If job control is disabled then the shell will have set the
 161          * disposition of SIGTSTP to SIG_IGN.
 162          */
 163         sigaction(SIGTSTP, NULL, &sa);
 164         if (sa.sa_handler == SIG_IGN)
 165                 return 0;
 166
 167         /* avoid calling gettext() from signal handler */
 168         background_resume_msg = _("cannot resume in the background, please use 'fg' to resume");
 169         restore_error_msg = _("cannot restore terminal settings");
 170         sa.sa_handler = restore_terminal_on_suspend;
 171         sa.sa_flags = SA_RESTART;
 172         sigemptyset(&sa.sa_mask);
 173         sigaddset(&sa.sa_mask, SIGTSTP);
 174         sigaddset(&sa.sa_mask, SIGTTIN);
 175         sigaddset(&sa.sa_mask, SIGTTOU);
 176         sigaction(SIGTSTP, &sa, NULL);
 177         sigaction(SIGTTIN, &sa, NULL);
 178         sigaction(SIGTTOU, &sa, NULL);
 179
 180         return 0;
 181 }
 182
 183 static int disable_bits(enum save_term_flags flags, tcflag_t bits)
 184 {
 185         struct termios t;
 186
 187         if (save_term(flags) < 0)
 188                 return -1;
 189
 190         t = old_term;
 191
 192         t.c_lflag &= ~bits;
 193         if (bits & ICANON) {
 194                 t.c_cc[VMIN] = 1;
 195                 t.c_cc[VTIME] = 0;
 196         }
 197         if (!tcsetattr(term_fd, TCSAFLUSH, &t))
 198                 return 0;
 199
 200         sigchain_pop_common();
 201         reset_job_signals();
 202         close_term_fd();
 203         return -1;
 204 }
 205
 206 static int disable_echo(enum save_term_flags flags)
 207 {
 208         return disable_bits(flags, ECHO);
 209 }
 210
 211 static int enable_non_canonical(enum save_term_flags flags)
 212 {
 213         return disable_bits(flags, ICANON | ECHO);
 214 }
 215
 216 /*
 217  * On macos it is not possible to use poll() with a terminal so use select
 218  * instead.
 219  */
 220 static int getchar_with_timeout(int timeout)
 221 {
 222         struct timeval tv, *tvp = NULL;
 223         fd_set readfds;
 224         int res;
 225
 226  again:
 227         if (timeout >= 0) {
 228                 tv.tv_sec = timeout / 1000;
 229                 tv.tv_usec = (timeout % 1000) * 1000;
 230                 tvp = &tv;
 231         }
 232
 233         FD_ZERO(&readfds);
 234         FD_SET(0, &readfds);
 235         res = select(1, &readfds, NULL, NULL, tvp);
 236         if (!res)
 237                 return EOF;
 238         if (res < 0) {
 239                 if (errno == EINTR)
 240                         goto again;
 241                 else
 242                         return EOF;
 243         }
 244         return getchar();
 245 }
 246
 247 #elif defined(GIT_WINDOWS_NATIVE)
 248
 249 #define INPUT_PATH "CONIN$"
 250 #define OUTPUT_PATH "CONOUT$"
 251 #define FORCE_TEXT "t"
 252
 253 static int use_stty = 1;
 254 static struct string_list stty_restore = STRING_LIST_INIT_DUP;
 255 static HANDLE hconin = INVALID_HANDLE_VALUE;
 256 static HANDLE hconout = INVALID_HANDLE_VALUE;
 257 static DWORD cmode_in, cmode_out;
 258
 259 void restore_term(void)
 260 {
 261         if (use_stty) {
 262                 int i;
 263                 struct child_process cp = CHILD_PROCESS_INIT;
 264
 265                 if (stty_restore.nr == 0)
 266                         return;
 267
 268                 strvec_push(&cp.args, "stty");
 269                 for (i = 0; i < stty_restore.nr; i++)
 270                         strvec_push(&cp.args, stty_restore.items[i].string);
 271                 run_command(&cp);
 272                 string_list_clear(&stty_restore, 0);
 273                 return;
 274         }
 275
 276         sigchain_pop_common();
 277
 278         if (hconin == INVALID_HANDLE_VALUE)
 279                 return;
 280
 281         SetConsoleMode(hconin, cmode_in);
 282         CloseHandle(hconin);
 283         if (cmode_out) {
 284                 assert(hconout != INVALID_HANDLE_VALUE);
 285                 SetConsoleMode(hconout, cmode_out);
 286                 CloseHandle(hconout);
 287         }
 288
 289         hconin = hconout = INVALID_HANDLE_VALUE;
 290 }
 291
 292 int save_term(enum save_term_flags flags)
 293 {
 294         hconin = CreateFileA("CONIN$", GENERIC_READ | GENERIC_WRITE,
 295             FILE_SHARE_READ, NULL, OPEN_EXISTING,
 296             FILE_ATTRIBUTE_NORMAL, NULL);
 297         if (hconin == INVALID_HANDLE_VALUE)
 298                 return -1;
 299
 300         if (flags & SAVE_TERM_DUPLEX) {
 301                 hconout = CreateFileA("CONOUT$", GENERIC_READ | GENERIC_WRITE,
 302                         FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
 303                         FILE_ATTRIBUTE_NORMAL, NULL);
 304                 if (hconout == INVALID_HANDLE_VALUE)
 305                         goto error;
 306
 307                 GetConsoleMode(hconout, &cmode_out);
 308         }
 309
 310         GetConsoleMode(hconin, &cmode_in);
 311         use_stty = 0;
 312         sigchain_push_common(restore_term_on_signal);
 313         return 0;
 314 error:
 315         CloseHandle(hconin);
 316         hconin = INVALID_HANDLE_VALUE;
 317         return -1;
 318 }
 319
 320 static int disable_bits(enum save_term_flags flags, DWORD bits)
 321 {
 322         if (use_stty) {
 323                 struct child_process cp = CHILD_PROCESS_INIT;
 324
 325                 strvec_push(&cp.args, "stty");
 326
 327                 if (bits & ENABLE_LINE_INPUT) {
 328                         string_list_append(&stty_restore, "icanon");
 329                         /*
 330                          * POSIX allows VMIN and VTIME to overlap with VEOF and
 331                          * VEOL - let's hope that is not the case on windows.
 332                          */
 333                         strvec_pushl(&cp.args, "-icanon", "min", "1", "time", "0", NULL);
 334                 }
 335
 336                 if (bits & ENABLE_ECHO_INPUT) {
 337                         string_list_append(&stty_restore, "echo");
 338                         strvec_push(&cp.args, "-echo");
 339                 }
 340
 341                 if (bits & ENABLE_PROCESSED_INPUT) {
 342                         string_list_append(&stty_restore, "-ignbrk");
 343                         string_list_append(&stty_restore, "intr");
 344                         string_list_append(&stty_restore, "^c");
 345                         strvec_push(&cp.args, "ignbrk");
 346                         strvec_push(&cp.args, "intr");
 347                         strvec_push(&cp.args, "");
 348                 }
 349
 350                 if (run_command(&cp) == 0)
 351                         return 0;
 352
 353                 /* `stty` could not be executed; access the Console directly */
 354                 use_stty = 0;
 355         }
 356
 357         if (save_term(flags) < 0)
 358                 return -1;
 359
 360         if (!SetConsoleMode(hconin, cmode_in & ~bits)) {
 361                 CloseHandle(hconin);
 362                 hconin = INVALID_HANDLE_VALUE;
 363                 sigchain_pop_common();
 364                 return -1;
 365         }
 366
 367         return 0;
 368 }
 369
 370 static int disable_echo(enum save_term_flags flags)
 371 {
 372         return disable_bits(flags, ENABLE_ECHO_INPUT);
 373 }
 374
 375 static int enable_non_canonical(enum save_term_flags flags)
 376 {
 377         return disable_bits(flags,
 378                             ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
 379 }
 380
 381 /*
 382  * Override `getchar()`, as the default implementation does not use
 383  * `ReadFile()`.
 384  *
 385  * This poses a problem when we want to see whether the standard
 386  * input has more characters, as the default of Git for Windows is to start the
 387  * Bash in a MinTTY, which uses a named pipe to emulate a pty, in which case
 388  * our `poll()` emulation calls `PeekNamedPipe()`, which seems to require
 389  * `ReadFile()` to be called first to work properly (it only reports 0
 390  * available bytes, otherwise).
 391  *
 392  * So let's just override `getchar()` with a version backed by `ReadFile()` and
 393  * go our merry ways from here.
 394  */
 395 static int mingw_getchar(void)
 396 {
 397         DWORD read = 0;
 398         unsigned char ch;
 399
 400         if (!ReadFile(GetStdHandle(STD_INPUT_HANDLE), &ch, 1, &read, NULL))
 401                 return EOF;
 402
 403         if (!read) {
 404                 error("Unexpected 0 read");
 405                 return EOF;
 406         }
 407
 408         return ch;
 409 }
 410 #define getchar mingw_getchar
 411
 412 static int getchar_with_timeout(int timeout)
 413 {
 414         struct pollfd pfd = { .fd = 0, .events = POLLIN };
 415
 416         if (poll(&pfd, 1, timeout) < 1)
 417                 return EOF;
 418
 419         return getchar();
 420 }
 421
 422 #endif
 423
 424 #ifndef FORCE_TEXT
 425 #define FORCE_TEXT
 426 #endif
 427
 428 char *git_terminal_prompt(const char *prompt, int echo)
 429 {
 430         static struct strbuf buf = STRBUF_INIT;
 431         int r;
 432         FILE *input_fh, *output_fh;
 433
 434         input_fh = fopen(INPUT_PATH, "r" FORCE_TEXT);
 435         if (!input_fh)
 436                 return NULL;
 437
 438         output_fh = fopen(OUTPUT_PATH, "w" FORCE_TEXT);
 439         if (!output_fh) {
 440                 fclose(input_fh);
 441                 return NULL;
 442         }
 443
 444         if (!echo && disable_echo(0)) {
 445                 fclose(input_fh);
 446                 fclose(output_fh);
 447                 return NULL;
 448         }
 449
 450         fputs(prompt, output_fh);
 451         fflush(output_fh);
 452
 453         r = strbuf_getline_lf(&buf, input_fh);
 454         if (!echo) {
 455                 putc('\n', output_fh);
 456                 fflush(output_fh);
 457         }
 458
 459         restore_term();
 460         fclose(input_fh);
 461         fclose(output_fh);
 462
 463         if (r == EOF)
 464                 return NULL;
 465         return buf.buf;
 466 }
 467
 468 /*
 469  * The `is_known_escape_sequence()` function returns 1 if the passed string
 470  * corresponds to an Escape sequence that the terminal capabilities contains.
 471  *
 472  * To avoid depending on ncurses or other platform-specific libraries, we rely
 473  * on the presence of the `infocmp` executable to do the job for us (failing
 474  * silently if the program is not available or refused to run).
 475  */
 476 struct escape_sequence_entry {
 477         struct hashmap_entry entry;
 478         char sequence[FLEX_ARRAY];
 479 };
 480
 481 static int sequence_entry_cmp(const void *hashmap_cmp_fn_data UNUSED,
 482                               const struct escape_sequence_entry *e1,
 483                               const struct escape_sequence_entry *e2,
 484                               const void *keydata)
 485 {
 486         return strcmp(e1->sequence, keydata ? keydata : e2->sequence);
 487 }
 488
 489 static int is_known_escape_sequence(const char *sequence)
 490 {
 491         static struct hashmap sequences;
 492         static int initialized;
 493
 494         if (!initialized) {
 495                 struct child_process cp = CHILD_PROCESS_INIT;
 496                 struct strbuf buf = STRBUF_INIT;
 497                 char *p, *eol;
 498
 499                 hashmap_init(&sequences, (hashmap_cmp_fn)sequence_entry_cmp,
 500                              NULL, 0);
 501
 502                 strvec_pushl(&cp.args, "infocmp", "-L", "-1", NULL);
 503                 if (pipe_command(&cp, NULL, 0, &buf, 0, NULL, 0))
 504                         strbuf_setlen(&buf, 0);
 505
 506                 for (eol = p = buf.buf; *p; p = eol + 1) {
 507                         p = strchr(p, '=');
 508                         if (!p)
 509                                 break;
 510                         p++;
 511                         eol = strchrnul(p, '\n');
 512
 513                         if (starts_with(p, "\\E")) {
 514                                 char *comma = memchr(p, ',', eol - p);
 515                                 struct escape_sequence_entry *e;
 516
 517                                 p[0] = '^';
 518                                 p[1] = '[';
 519                                 FLEX_ALLOC_MEM(e, sequence, p, comma - p);
 520                                 hashmap_entry_init(&e->entry,
 521                                                    strhash(e->sequence));
 522                                 hashmap_add(&sequences, &e->entry);
 523                         }
 524                         if (!*eol)
 525                                 break;
 526                 }
 527                 initialized = 1;
 528         }
 529
 530         return !!hashmap_get_from_hash(&sequences, strhash(sequence), sequence);
 531 }
 532
 533 int read_key_without_echo(struct strbuf *buf)
 534 {
 535         static int warning_displayed;
 536         int ch;
 537
 538         if (warning_displayed || enable_non_canonical(SAVE_TERM_STDIN) < 0) {
 539                 if (!warning_displayed) {
 540                         warning("reading single keystrokes not supported on "
 541                                 "this platform; reading line instead");
 542                         warning_displayed = 1;
 543                 }
 544
 545                 return strbuf_getline(buf, stdin);
 546         }
 547
 548         strbuf_reset(buf);
 549         ch = getchar();
 550         if (ch == EOF) {
 551                 restore_term();
 552                 return EOF;
 553         }
 554         strbuf_addch(buf, ch);
 555
 556         if (ch == '\033' /* ESC */) {
 557                 /*
 558                  * We are most likely looking at an Escape sequence. Let's try
 559                  * to read more bytes, waiting at most half a second, assuming
 560                  * that the sequence is complete if we did not receive any byte
 561                  * within that time.
 562                  *
 563                  * Start by replacing the Escape byte with ^[ */
 564                 strbuf_splice(buf, buf->len - 1, 1, "^[", 2);
 565
 566                 /*
 567                  * Query the terminal capabilities once about all the Escape
 568                  * sequences it knows about, so that we can avoid waiting for
 569                  * half a second when we know that the sequence is complete.
 570                  */
 571                 while (!is_known_escape_sequence(buf->buf)) {
 572                         ch = getchar_with_timeout(500);
 573                         if (ch == EOF)
 574                                 break;
 575                         strbuf_addch(buf, ch);
 576                 }
 577         }
 578
 579         restore_term();
 580         return 0;
 581 }
 582
 583 #else
 584
 585 int save_term(enum save_term_flags flags)
 586 {
 587         /* no duplex support available */
 588         return -!!(flags & SAVE_TERM_DUPLEX);
 589 }
 590
 591 void restore_term(void)
 592 {
 593 }
 594
 595 char *git_terminal_prompt(const char *prompt, int echo)
 596 {
 597         return getpass(prompt);
 598 }
 599
 600 int read_key_without_echo(struct strbuf *buf)
 601 {
 602         static int warning_displayed;
 603         const char *res;
 604
 605         if (!warning_displayed) {
 606                 warning("reading single keystrokes not supported on this "
 607                         "platform; reading line instead");
 608                 warning_displayed = 1;
 609         }
 610
 611         res = getpass("");
 612         strbuf_reset(buf);
 613         if (!res)
 614                 return EOF;
 615         strbuf_addstr(buf, res);
 616         return 0;
 617 }
 618
 619 #endif