compat/terminal.c

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