compat/terminal.c

   1 #include "git-compat-util.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         sigchain_pop(sig);
  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 int term_fd = -1;
  24 static struct termios old_term;
  25
  26 void restore_term(void)
  27 {
  28         if (term_fd < 0)
  29                 return;
  30
  31         tcsetattr(term_fd, TCSAFLUSH, &old_term);
  32         close(term_fd);
  33         term_fd = -1;
  34 }
  35
  36 int save_term(int full_duplex)
  37 {
  38         if (term_fd < 0)
  39                 term_fd = open("/dev/tty", O_RDWR);
  40
  41         return (term_fd < 0) ? -1 : tcgetattr(term_fd, &old_term);
  42 }
  43
  44 static int disable_bits(tcflag_t bits)
  45 {
  46         struct termios t;
  47
  48         if (save_term(0) < 0)
  49                 goto error;
  50
  51         t = old_term;
  52         sigchain_push_common(restore_term_on_signal);
  53
  54         t.c_lflag &= ~bits;
  55         if (!tcsetattr(term_fd, TCSAFLUSH, &t))
  56                 return 0;
  57
  58 error:
  59         close(term_fd);
  60         term_fd = -1;
  61         return -1;
  62 }
  63
  64 static int disable_echo(void)
  65 {
  66         return disable_bits(ECHO);
  67 }
  68
  69 static int enable_non_canonical(void)
  70 {
  71         return disable_bits(ICANON | ECHO);
  72 }
  73
  74 #elif defined(GIT_WINDOWS_NATIVE)
  75
  76 #define INPUT_PATH "CONIN$"
  77 #define OUTPUT_PATH "CONOUT$"
  78 #define FORCE_TEXT "t"
  79
  80 static int use_stty = 1;
  81 static struct string_list stty_restore = STRING_LIST_INIT_DUP;
  82 static HANDLE hconin = INVALID_HANDLE_VALUE;
  83 static HANDLE hconout = INVALID_HANDLE_VALUE;
  84 static DWORD cmode_in, cmode_out;
  85
  86 void restore_term(void)
  87 {
  88         if (use_stty) {
  89                 int i;
  90                 struct child_process cp = CHILD_PROCESS_INIT;
  91
  92                 if (stty_restore.nr == 0)
  93                         return;
  94
  95                 strvec_push(&cp.args, "stty");
  96                 for (i = 0; i < stty_restore.nr; i++)
  97                         strvec_push(&cp.args, stty_restore.items[i].string);
  98                 run_command(&cp);
  99                 string_list_clear(&stty_restore, 0);
 100                 return;
 101         }
 102
 103         if (hconin == INVALID_HANDLE_VALUE)
 104                 return;
 105
 106         SetConsoleMode(hconin, cmode_in);
 107         CloseHandle(hconin);
 108         if (cmode_out) {
 109                 assert(hconout != INVALID_HANDLE_VALUE);
 110                 SetConsoleMode(hconout, cmode_out);
 111                 CloseHandle(hconout);
 112         }
 113
 114         hconin = hconout = INVALID_HANDLE_VALUE;
 115 }
 116
 117 int save_term(int full_duplex)
 118 {
 119         hconin = CreateFileA("CONIN$", GENERIC_READ | GENERIC_WRITE,
 120             FILE_SHARE_READ, NULL, OPEN_EXISTING,
 121             FILE_ATTRIBUTE_NORMAL, NULL);
 122         if (hconin == INVALID_HANDLE_VALUE)
 123                 return -1;
 124
 125         if (full_duplex) {
 126                 hconout = CreateFileA("CONOUT$", GENERIC_READ | GENERIC_WRITE,
 127                         FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
 128                         FILE_ATTRIBUTE_NORMAL, NULL);
 129                 if (hconout == INVALID_HANDLE_VALUE)
 130                         goto error;
 131
 132                 GetConsoleMode(hconout, &cmode_out);
 133         }
 134
 135         GetConsoleMode(hconin, &cmode_in);
 136         use_stty = 0;
 137         return 0;
 138 error:
 139         CloseHandle(hconin);
 140         hconin = INVALID_HANDLE_VALUE;
 141         return -1;
 142 }
 143
 144 static int disable_bits(DWORD bits)
 145 {
 146         if (use_stty) {
 147                 struct child_process cp = CHILD_PROCESS_INIT;
 148
 149                 strvec_push(&cp.args, "stty");
 150
 151                 if (bits & ENABLE_LINE_INPUT) {
 152                         string_list_append(&stty_restore, "icanon");
 153                         strvec_push(&cp.args, "-icanon");
 154                 }
 155
 156                 if (bits & ENABLE_ECHO_INPUT) {
 157                         string_list_append(&stty_restore, "echo");
 158                         strvec_push(&cp.args, "-echo");
 159                 }
 160
 161                 if (bits & ENABLE_PROCESSED_INPUT) {
 162                         string_list_append(&stty_restore, "-ignbrk");
 163                         string_list_append(&stty_restore, "intr");
 164                         string_list_append(&stty_restore, "^c");
 165                         strvec_push(&cp.args, "ignbrk");
 166                         strvec_push(&cp.args, "intr");
 167                         strvec_push(&cp.args, "");
 168                 }
 169
 170                 if (run_command(&cp) == 0)
 171                         return 0;
 172
 173                 /* `stty` could not be executed; access the Console directly */
 174                 use_stty = 0;
 175         }
 176
 177         if (save_term(0) < 0)
 178                 return -1;
 179
 180         sigchain_push_common(restore_term_on_signal);
 181         if (!SetConsoleMode(hconin, cmode_in & ~bits)) {
 182                 CloseHandle(hconin);
 183                 hconin = INVALID_HANDLE_VALUE;
 184                 return -1;
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int disable_echo(void)
 191 {
 192         return disable_bits(ENABLE_ECHO_INPUT);
 193 }
 194
 195 static int enable_non_canonical(void)
 196 {
 197         return disable_bits(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
 198 }
 199
 200 /*
 201  * Override `getchar()`, as the default implementation does not use
 202  * `ReadFile()`.
 203  *
 204  * This poses a problem when we want to see whether the standard
 205  * input has more characters, as the default of Git for Windows is to start the
 206  * Bash in a MinTTY, which uses a named pipe to emulate a pty, in which case
 207  * our `poll()` emulation calls `PeekNamedPipe()`, which seems to require
 208  * `ReadFile()` to be called first to work properly (it only reports 0
 209  * available bytes, otherwise).
 210  *
 211  * So let's just override `getchar()` with a version backed by `ReadFile()` and
 212  * go our merry ways from here.
 213  */
 214 static int mingw_getchar(void)
 215 {
 216         DWORD read = 0;
 217         unsigned char ch;
 218
 219         if (!ReadFile(GetStdHandle(STD_INPUT_HANDLE), &ch, 1, &read, NULL))
 220                 return EOF;
 221
 222         if (!read) {
 223                 error("Unexpected 0 read");
 224                 return EOF;
 225         }
 226
 227         return ch;
 228 }
 229 #define getchar mingw_getchar
 230
 231 #endif
 232
 233 #ifndef FORCE_TEXT
 234 #define FORCE_TEXT
 235 #endif
 236
 237 char *git_terminal_prompt(const char *prompt, int echo)
 238 {
 239         static struct strbuf buf = STRBUF_INIT;
 240         int r;
 241         FILE *input_fh, *output_fh;
 242
 243         input_fh = fopen(INPUT_PATH, "r" FORCE_TEXT);
 244         if (!input_fh)
 245                 return NULL;
 246
 247         output_fh = fopen(OUTPUT_PATH, "w" FORCE_TEXT);
 248         if (!output_fh) {
 249                 fclose(input_fh);
 250                 return NULL;
 251         }
 252
 253         if (!echo && disable_echo()) {
 254                 fclose(input_fh);
 255                 fclose(output_fh);
 256                 return NULL;
 257         }
 258
 259         fputs(prompt, output_fh);
 260         fflush(output_fh);
 261
 262         r = strbuf_getline_lf(&buf, input_fh);
 263         if (!echo) {
 264                 putc('\n', output_fh);
 265                 fflush(output_fh);
 266         }
 267
 268         restore_term();
 269         fclose(input_fh);
 270         fclose(output_fh);
 271
 272         if (r == EOF)
 273                 return NULL;
 274         return buf.buf;
 275 }
 276
 277 /*
 278  * The `is_known_escape_sequence()` function returns 1 if the passed string
 279  * corresponds to an Escape sequence that the terminal capabilities contains.
 280  *
 281  * To avoid depending on ncurses or other platform-specific libraries, we rely
 282  * on the presence of the `infocmp` executable to do the job for us (failing
 283  * silently if the program is not available or refused to run).
 284  */
 285 struct escape_sequence_entry {
 286         struct hashmap_entry entry;
 287         char sequence[FLEX_ARRAY];
 288 };
 289
 290 static int sequence_entry_cmp(const void *hashmap_cmp_fn_data,
 291                               const struct escape_sequence_entry *e1,
 292                               const struct escape_sequence_entry *e2,
 293                               const void *keydata)
 294 {
 295         return strcmp(e1->sequence, keydata ? keydata : e2->sequence);
 296 }
 297
 298 static int is_known_escape_sequence(const char *sequence)
 299 {
 300         static struct hashmap sequences;
 301         static int initialized;
 302
 303         if (!initialized) {
 304                 struct child_process cp = CHILD_PROCESS_INIT;
 305                 struct strbuf buf = STRBUF_INIT;
 306                 char *p, *eol;
 307
 308                 hashmap_init(&sequences, (hashmap_cmp_fn)sequence_entry_cmp,
 309                              NULL, 0);
 310
 311                 strvec_pushl(&cp.args, "infocmp", "-L", "-1", NULL);
 312                 if (pipe_command(&cp, NULL, 0, &buf, 0, NULL, 0))
 313                         strbuf_setlen(&buf, 0);
 314
 315                 for (eol = p = buf.buf; *p; p = eol + 1) {
 316                         p = strchr(p, '=');
 317                         if (!p)
 318                                 break;
 319                         p++;
 320                         eol = strchrnul(p, '\n');
 321
 322                         if (starts_with(p, "\\E")) {
 323                                 char *comma = memchr(p, ',', eol - p);
 324                                 struct escape_sequence_entry *e;
 325
 326                                 p[0] = '^';
 327                                 p[1] = '[';
 328                                 FLEX_ALLOC_MEM(e, sequence, p, comma - p);
 329                                 hashmap_entry_init(&e->entry,
 330                                                    strhash(e->sequence));
 331                                 hashmap_add(&sequences, &e->entry);
 332                         }
 333                         if (!*eol)
 334                                 break;
 335                 }
 336                 initialized = 1;
 337         }
 338
 339         return !!hashmap_get_from_hash(&sequences, strhash(sequence), sequence);
 340 }
 341
 342 int read_key_without_echo(struct strbuf *buf)
 343 {
 344         static int warning_displayed;
 345         int ch;
 346
 347         if (warning_displayed || enable_non_canonical() < 0) {
 348                 if (!warning_displayed) {
 349                         warning("reading single keystrokes not supported on "
 350                                 "this platform; reading line instead");
 351                         warning_displayed = 1;
 352                 }
 353
 354                 return strbuf_getline(buf, stdin);
 355         }
 356
 357         strbuf_reset(buf);
 358         ch = getchar();
 359         if (ch == EOF) {
 360                 restore_term();
 361                 return EOF;
 362         }
 363         strbuf_addch(buf, ch);
 364
 365         if (ch == '\033' /* ESC */) {
 366                 /*
 367                  * We are most likely looking at an Escape sequence. Let's try
 368                  * to read more bytes, waiting at most half a second, assuming
 369                  * that the sequence is complete if we did not receive any byte
 370                  * within that time.
 371                  *
 372                  * Start by replacing the Escape byte with ^[ */
 373                 strbuf_splice(buf, buf->len - 1, 1, "^[", 2);
 374
 375                 /*
 376                  * Query the terminal capabilities once about all the Escape
 377                  * sequences it knows about, so that we can avoid waiting for
 378                  * half a second when we know that the sequence is complete.
 379                  */
 380                 while (!is_known_escape_sequence(buf->buf)) {
 381                         struct pollfd pfd = { .fd = 0, .events = POLLIN };
 382
 383                         if (poll(&pfd, 1, 500) < 1)
 384                                 break;
 385
 386                         ch = getchar();
 387                         if (ch == EOF)
 388                                 return 0;
 389                         strbuf_addch(buf, ch);
 390                 }
 391         }
 392
 393         restore_term();
 394         return 0;
 395 }
 396
 397 #else
 398
 399 int save_term(int full_duplex)
 400 {
 401         /* full_duplex == 1, but no support available */
 402         return -full_duplex;
 403 }
 404
 405 void restore_term(void)
 406 {
 407 }
 408
 409 char *git_terminal_prompt(const char *prompt, int echo)
 410 {
 411         return getpass(prompt);
 412 }
 413
 414 int read_key_without_echo(struct strbuf *buf)
 415 {
 416         static int warning_displayed;
 417         const char *res;
 418
 419         if (!warning_displayed) {
 420                 warning("reading single keystrokes not supported on this "
 421                         "platform; reading line instead");
 422                 warning_displayed = 1;
 423         }
 424
 425         res = getpass("");
 426         strbuf_reset(buf);
 427         if (!res)
 428                 return EOF;
 429         strbuf_addstr(buf, res);
 430         return 0;
 431 }
 432
 433 #endif