Merge branch 'mk/mingw-winansi-ttyname-termination-fix' into maint
[git/git.git] / compat / winansi.c
1 /*
2 * Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
3 */
4
5 #undef NOGDI
6 #include "../git-compat-util.h"
7 #include <wingdi.h>
8 #include <winreg.h>
9 #include "win32.h"
10
11 static int fd_is_interactive[3] = { 0, 0, 0 };
12 #define FD_CONSOLE 0x1
13 #define FD_SWAPPED 0x2
14 #define FD_MSYS 0x4
15
16 /*
17 ANSI codes used by git: m, K
18
19 This file is git-specific. Therefore, this file does not attempt
20 to implement any codes that are not used by git.
21 */
22
23 static HANDLE console;
24 static WORD plain_attr;
25 static WORD attr;
26 static int negative;
27 static int non_ascii_used = 0;
28 static HANDLE hthread, hread, hwrite;
29 static HANDLE hconsole1, hconsole2;
30
31 #ifdef __MINGW32__
32 #if !defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 5
33 typedef struct _CONSOLE_FONT_INFOEX {
34 ULONG cbSize;
35 DWORD nFont;
36 COORD dwFontSize;
37 UINT FontFamily;
38 UINT FontWeight;
39 WCHAR FaceName[LF_FACESIZE];
40 } CONSOLE_FONT_INFOEX, *PCONSOLE_FONT_INFOEX;
41 #endif
42 #endif
43
44 typedef BOOL (WINAPI *PGETCURRENTCONSOLEFONTEX)(HANDLE, BOOL,
45 PCONSOLE_FONT_INFOEX);
46
47 static void warn_if_raster_font(void)
48 {
49 DWORD fontFamily = 0;
50 PGETCURRENTCONSOLEFONTEX pGetCurrentConsoleFontEx;
51
52 /* don't bother if output was ascii only */
53 if (!non_ascii_used)
54 return;
55
56 /* GetCurrentConsoleFontEx is available since Vista */
57 pGetCurrentConsoleFontEx = (PGETCURRENTCONSOLEFONTEX) GetProcAddress(
58 GetModuleHandle("kernel32.dll"),
59 "GetCurrentConsoleFontEx");
60 if (pGetCurrentConsoleFontEx) {
61 CONSOLE_FONT_INFOEX cfi;
62 cfi.cbSize = sizeof(cfi);
63 if (pGetCurrentConsoleFontEx(console, 0, &cfi))
64 fontFamily = cfi.FontFamily;
65 } else {
66 /* pre-Vista: check default console font in registry */
67 HKEY hkey;
68 if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_CURRENT_USER, "Console",
69 0, KEY_READ, &hkey)) {
70 DWORD size = sizeof(fontFamily);
71 RegQueryValueExA(hkey, "FontFamily", NULL, NULL,
72 (LPVOID) &fontFamily, &size);
73 RegCloseKey(hkey);
74 }
75 }
76
77 if (!(fontFamily & TMPF_TRUETYPE)) {
78 const wchar_t *msg = L"\nWarning: Your console font probably "
79 L"doesn\'t support Unicode. If you experience strange "
80 L"characters in the output, consider switching to a "
81 L"TrueType font such as Consolas!\n";
82 DWORD dummy;
83 WriteConsoleW(console, msg, wcslen(msg), &dummy, NULL);
84 }
85 }
86
87 static int is_console(int fd)
88 {
89 CONSOLE_SCREEN_BUFFER_INFO sbi;
90 DWORD mode;
91 HANDLE hcon;
92
93 static int initialized = 0;
94
95 /* get OS handle of the file descriptor */
96 hcon = (HANDLE) _get_osfhandle(fd);
97 if (hcon == INVALID_HANDLE_VALUE)
98 return 0;
99
100 /* check if its a device (i.e. console, printer, serial port) */
101 if (GetFileType(hcon) != FILE_TYPE_CHAR)
102 return 0;
103
104 /* check if its a handle to a console output screen buffer */
105 if (!fd) {
106 if (!GetConsoleMode(hcon, &mode))
107 return 0;
108 } else if (!GetConsoleScreenBufferInfo(hcon, &sbi))
109 return 0;
110
111 if (fd >= 0 && fd <= 2)
112 fd_is_interactive[fd] |= FD_CONSOLE;
113
114 /* initialize attributes */
115 if (!initialized) {
116 console = hcon;
117 attr = plain_attr = sbi.wAttributes;
118 negative = 0;
119 initialized = 1;
120 }
121
122 return 1;
123 }
124
125 #define BUFFER_SIZE 4096
126 #define MAX_PARAMS 16
127
128 static void write_console(unsigned char *str, size_t len)
129 {
130 /* only called from console_thread, so a static buffer will do */
131 static wchar_t wbuf[2 * BUFFER_SIZE + 1];
132 DWORD dummy;
133
134 /* convert utf-8 to utf-16 */
135 int wlen = xutftowcsn(wbuf, (char*) str, ARRAY_SIZE(wbuf), len);
136
137 /* write directly to console */
138 WriteConsoleW(console, wbuf, wlen, &dummy, NULL);
139
140 /* remember if non-ascii characters are printed */
141 if (wlen != len)
142 non_ascii_used = 1;
143 }
144
145 #define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
146 #define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
147
148 static void set_console_attr(void)
149 {
150 WORD attributes = attr;
151 if (negative) {
152 attributes &= ~FOREGROUND_ALL;
153 attributes &= ~BACKGROUND_ALL;
154
155 /* This could probably use a bitmask
156 instead of a series of ifs */
157 if (attr & FOREGROUND_RED)
158 attributes |= BACKGROUND_RED;
159 if (attr & FOREGROUND_GREEN)
160 attributes |= BACKGROUND_GREEN;
161 if (attr & FOREGROUND_BLUE)
162 attributes |= BACKGROUND_BLUE;
163
164 if (attr & BACKGROUND_RED)
165 attributes |= FOREGROUND_RED;
166 if (attr & BACKGROUND_GREEN)
167 attributes |= FOREGROUND_GREEN;
168 if (attr & BACKGROUND_BLUE)
169 attributes |= FOREGROUND_BLUE;
170 }
171 SetConsoleTextAttribute(console, attributes);
172 }
173
174 static void erase_in_line(void)
175 {
176 CONSOLE_SCREEN_BUFFER_INFO sbi;
177 DWORD dummy; /* Needed for Windows 7 (or Vista) regression */
178
179 if (!console)
180 return;
181
182 GetConsoleScreenBufferInfo(console, &sbi);
183 FillConsoleOutputCharacterA(console, ' ',
184 sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
185 &dummy);
186 }
187
188 static void set_attr(char func, const int *params, int paramlen)
189 {
190 int i;
191 switch (func) {
192 case 'm':
193 for (i = 0; i < paramlen; i++) {
194 switch (params[i]) {
195 case 0: /* reset */
196 attr = plain_attr;
197 negative = 0;
198 break;
199 case 1: /* bold */
200 attr |= FOREGROUND_INTENSITY;
201 break;
202 case 2: /* faint */
203 case 22: /* normal */
204 attr &= ~FOREGROUND_INTENSITY;
205 break;
206 case 3: /* italic */
207 /* Unsupported */
208 break;
209 case 4: /* underline */
210 case 21: /* double underline */
211 /* Wikipedia says this flag does nothing */
212 /* Furthermore, mingw doesn't define this flag
213 attr |= COMMON_LVB_UNDERSCORE; */
214 break;
215 case 24: /* no underline */
216 /* attr &= ~COMMON_LVB_UNDERSCORE; */
217 break;
218 case 5: /* slow blink */
219 case 6: /* fast blink */
220 /* We don't have blink, but we do have
221 background intensity */
222 attr |= BACKGROUND_INTENSITY;
223 break;
224 case 25: /* no blink */
225 attr &= ~BACKGROUND_INTENSITY;
226 break;
227 case 7: /* negative */
228 negative = 1;
229 break;
230 case 27: /* positive */
231 negative = 0;
232 break;
233 case 8: /* conceal */
234 case 28: /* reveal */
235 /* Unsupported */
236 break;
237 case 30: /* Black */
238 attr &= ~FOREGROUND_ALL;
239 break;
240 case 31: /* Red */
241 attr &= ~FOREGROUND_ALL;
242 attr |= FOREGROUND_RED;
243 break;
244 case 32: /* Green */
245 attr &= ~FOREGROUND_ALL;
246 attr |= FOREGROUND_GREEN;
247 break;
248 case 33: /* Yellow */
249 attr &= ~FOREGROUND_ALL;
250 attr |= FOREGROUND_RED | FOREGROUND_GREEN;
251 break;
252 case 34: /* Blue */
253 attr &= ~FOREGROUND_ALL;
254 attr |= FOREGROUND_BLUE;
255 break;
256 case 35: /* Magenta */
257 attr &= ~FOREGROUND_ALL;
258 attr |= FOREGROUND_RED | FOREGROUND_BLUE;
259 break;
260 case 36: /* Cyan */
261 attr &= ~FOREGROUND_ALL;
262 attr |= FOREGROUND_GREEN | FOREGROUND_BLUE;
263 break;
264 case 37: /* White */
265 attr |= FOREGROUND_RED |
266 FOREGROUND_GREEN |
267 FOREGROUND_BLUE;
268 break;
269 case 38: /* Unknown */
270 break;
271 case 39: /* reset */
272 attr &= ~FOREGROUND_ALL;
273 attr |= (plain_attr & FOREGROUND_ALL);
274 break;
275 case 40: /* Black */
276 attr &= ~BACKGROUND_ALL;
277 break;
278 case 41: /* Red */
279 attr &= ~BACKGROUND_ALL;
280 attr |= BACKGROUND_RED;
281 break;
282 case 42: /* Green */
283 attr &= ~BACKGROUND_ALL;
284 attr |= BACKGROUND_GREEN;
285 break;
286 case 43: /* Yellow */
287 attr &= ~BACKGROUND_ALL;
288 attr |= BACKGROUND_RED | BACKGROUND_GREEN;
289 break;
290 case 44: /* Blue */
291 attr &= ~BACKGROUND_ALL;
292 attr |= BACKGROUND_BLUE;
293 break;
294 case 45: /* Magenta */
295 attr &= ~BACKGROUND_ALL;
296 attr |= BACKGROUND_RED | BACKGROUND_BLUE;
297 break;
298 case 46: /* Cyan */
299 attr &= ~BACKGROUND_ALL;
300 attr |= BACKGROUND_GREEN | BACKGROUND_BLUE;
301 break;
302 case 47: /* White */
303 attr |= BACKGROUND_RED |
304 BACKGROUND_GREEN |
305 BACKGROUND_BLUE;
306 break;
307 case 48: /* Unknown */
308 break;
309 case 49: /* reset */
310 attr &= ~BACKGROUND_ALL;
311 attr |= (plain_attr & BACKGROUND_ALL);
312 break;
313 default:
314 /* Unsupported code */
315 break;
316 }
317 }
318 set_console_attr();
319 break;
320 case 'K':
321 erase_in_line();
322 break;
323 default:
324 /* Unsupported code */
325 break;
326 }
327 }
328
329 enum {
330 TEXT = 0, ESCAPE = 033, BRACKET = '['
331 };
332
333 static DWORD WINAPI console_thread(LPVOID unused)
334 {
335 unsigned char buffer[BUFFER_SIZE];
336 DWORD bytes;
337 int start, end = 0, c, parampos = 0, state = TEXT;
338 int params[MAX_PARAMS];
339
340 while (1) {
341 /* read next chunk of bytes from the pipe */
342 if (!ReadFile(hread, buffer + end, BUFFER_SIZE - end, &bytes,
343 NULL)) {
344 /* exit if pipe has been closed or disconnected */
345 if (GetLastError() == ERROR_PIPE_NOT_CONNECTED ||
346 GetLastError() == ERROR_BROKEN_PIPE)
347 break;
348 /* ignore other errors */
349 continue;
350 }
351
352 /* scan the bytes and handle ANSI control codes */
353 bytes += end;
354 start = end = 0;
355 while (end < bytes) {
356 c = buffer[end++];
357 switch (state) {
358 case TEXT:
359 if (c == ESCAPE) {
360 /* print text seen so far */
361 if (end - 1 > start)
362 write_console(buffer + start,
363 end - 1 - start);
364
365 /* then start parsing escape sequence */
366 start = end - 1;
367 memset(params, 0, sizeof(params));
368 parampos = 0;
369 state = ESCAPE;
370 }
371 break;
372
373 case ESCAPE:
374 /* continue if "\033[", otherwise bail out */
375 state = (c == BRACKET) ? BRACKET : TEXT;
376 break;
377
378 case BRACKET:
379 /* parse [0-9;]* into array of parameters */
380 if (c >= '0' && c <= '9') {
381 params[parampos] *= 10;
382 params[parampos] += c - '0';
383 } else if (c == ';') {
384 /*
385 * next parameter, bail out if out of
386 * bounds
387 */
388 parampos++;
389 if (parampos >= MAX_PARAMS)
390 state = TEXT;
391 } else {
392 /*
393 * end of escape sequence, change
394 * console attributes
395 */
396 set_attr(c, params, parampos + 1);
397 start = end;
398 state = TEXT;
399 }
400 break;
401 }
402 }
403
404 /* print remaining text unless parsing an escape sequence */
405 if (state == TEXT && end > start) {
406 /* check for incomplete UTF-8 sequences and fix end */
407 if (buffer[end - 1] >= 0x80) {
408 if (buffer[end -1] >= 0xc0)
409 end--;
410 else if (end - 1 > start &&
411 buffer[end - 2] >= 0xe0)
412 end -= 2;
413 else if (end - 2 > start &&
414 buffer[end - 3] >= 0xf0)
415 end -= 3;
416 }
417
418 /* print remaining complete UTF-8 sequences */
419 if (end > start)
420 write_console(buffer + start, end - start);
421
422 /* move remaining bytes to the front */
423 if (end < bytes)
424 memmove(buffer, buffer + end, bytes - end);
425 end = bytes - end;
426 } else {
427 /* all data has been consumed, mark buffer empty */
428 end = 0;
429 }
430 }
431
432 /* check if the console font supports unicode */
433 warn_if_raster_font();
434
435 CloseHandle(hread);
436 return 0;
437 }
438
439 static void winansi_exit(void)
440 {
441 /* flush all streams */
442 _flushall();
443
444 /* signal console thread to exit */
445 FlushFileBuffers(hwrite);
446 DisconnectNamedPipe(hwrite);
447
448 /* wait for console thread to copy remaining data */
449 WaitForSingleObject(hthread, INFINITE);
450
451 /* cleanup handles... */
452 CloseHandle(hwrite);
453 CloseHandle(hthread);
454 }
455
456 static void die_lasterr(const char *fmt, ...)
457 {
458 va_list params;
459 va_start(params, fmt);
460 errno = err_win_to_posix(GetLastError());
461 die_errno(fmt, params);
462 va_end(params);
463 }
464
465 static HANDLE duplicate_handle(HANDLE hnd)
466 {
467 HANDLE hresult, hproc = GetCurrentProcess();
468 if (!DuplicateHandle(hproc, hnd, hproc, &hresult, 0, TRUE,
469 DUPLICATE_SAME_ACCESS))
470 die_lasterr("DuplicateHandle(%li) failed",
471 (long) (intptr_t) hnd);
472 return hresult;
473 }
474
475 static HANDLE swap_osfhnd(int fd, HANDLE new_handle)
476 {
477 /*
478 * Create a copy of the original handle associated with fd
479 * because the original will get closed when we dup2().
480 */
481 HANDLE handle = (HANDLE)_get_osfhandle(fd);
482 HANDLE duplicate = duplicate_handle(handle);
483
484 /* Create a temp fd associated with the already open "new_handle". */
485 int new_fd = _open_osfhandle((intptr_t)new_handle, O_BINARY);
486
487 assert((fd == 1) || (fd == 2));
488
489 /*
490 * Use stock dup2() to re-bind fd to the new handle. Note that
491 * this will implicitly close(1) and close both fd=1 and the
492 * originally associated handle. It will open a new fd=1 and
493 * call DuplicateHandle() on the handle associated with new_fd.
494 * It is because of this implicit close() that we created the
495 * copy of the original.
496 *
497 * Note that the OS can recycle HANDLE (numbers) just like it
498 * recycles fd (numbers), so we must update the cached value
499 * of "console". You can use GetFileType() to see that
500 * handle and _get_osfhandle(fd) may have the same number
501 * value, but they refer to different actual files now.
502 *
503 * Note that dup2() when given target := {0,1,2} will also
504 * call SetStdHandle(), so we don't need to worry about that.
505 */
506 dup2(new_fd, fd);
507 if (console == handle)
508 console = duplicate;
509 handle = INVALID_HANDLE_VALUE;
510
511 /* Close the temp fd. This explicitly closes "new_handle"
512 * (because it has been associated with it).
513 */
514 close(new_fd);
515
516 fd_is_interactive[fd] |= FD_SWAPPED;
517
518 return duplicate;
519 }
520
521 #ifdef DETECT_MSYS_TTY
522
523 #include <winternl.h>
524 #include <ntstatus.h>
525
526 static void detect_msys_tty(int fd)
527 {
528 ULONG result;
529 BYTE buffer[1024];
530 POBJECT_NAME_INFORMATION nameinfo = (POBJECT_NAME_INFORMATION) buffer;
531 PWSTR name;
532
533 /* check if fd is a pipe */
534 HANDLE h = (HANDLE) _get_osfhandle(fd);
535 if (GetFileType(h) != FILE_TYPE_PIPE)
536 return;
537
538 /* get pipe name */
539 if (!NT_SUCCESS(NtQueryObject(h, ObjectNameInformation,
540 buffer, sizeof(buffer) - 2, &result)))
541 return;
542 name = nameinfo->Name.Buffer;
543 name[nameinfo->Name.Length / sizeof(*name)] = 0;
544
545 /*
546 * Check if this could be a MSYS2 pty pipe ('msys-XXXX-ptyN-XX')
547 * or a cygwin pty pipe ('cygwin-XXXX-ptyN-XX')
548 */
549 if ((!wcsstr(name, L"msys-") && !wcsstr(name, L"cygwin-")) ||
550 !wcsstr(name, L"-pty"))
551 return;
552
553 fd_is_interactive[fd] |= FD_MSYS;
554 }
555
556 #endif
557
558 /*
559 * Wrapper for isatty(). Most calls in the main git code
560 * call isatty(1 or 2) to see if the instance is interactive
561 * and should: be colored, show progress, paginate output.
562 * We lie and give results for what the descriptor WAS at
563 * startup (and ignore any pipe redirection we internally
564 * do).
565 */
566 #undef isatty
567 int winansi_isatty(int fd)
568 {
569 if (fd >= 0 && fd <= 2)
570 return fd_is_interactive[fd] != 0;
571 return isatty(fd);
572 }
573
574 void winansi_init(void)
575 {
576 int con1, con2;
577 char name[32];
578
579 /* check if either stdout or stderr is a console output screen buffer */
580 con1 = is_console(1);
581 con2 = is_console(2);
582
583 /* Also compute console bit for fd 0 even though we don't need the result here. */
584 is_console(0);
585
586 if (!con1 && !con2) {
587 #ifdef DETECT_MSYS_TTY
588 /* check if stdin / stdout / stderr are MSYS2 pty pipes */
589 detect_msys_tty(0);
590 detect_msys_tty(1);
591 detect_msys_tty(2);
592 #endif
593 return;
594 }
595
596 /* create a named pipe to communicate with the console thread */
597 xsnprintf(name, sizeof(name), "\\\\.\\pipe\\winansi%lu", GetCurrentProcessId());
598 hwrite = CreateNamedPipe(name, PIPE_ACCESS_OUTBOUND,
599 PIPE_TYPE_BYTE | PIPE_WAIT, 1, BUFFER_SIZE, 0, 0, NULL);
600 if (hwrite == INVALID_HANDLE_VALUE)
601 die_lasterr("CreateNamedPipe failed");
602
603 hread = CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
604 if (hread == INVALID_HANDLE_VALUE)
605 die_lasterr("CreateFile for named pipe failed");
606
607 /* start console spool thread on the pipe's read end */
608 hthread = CreateThread(NULL, 0, console_thread, NULL, 0, NULL);
609 if (hthread == INVALID_HANDLE_VALUE)
610 die_lasterr("CreateThread(console_thread) failed");
611
612 /* schedule cleanup routine */
613 if (atexit(winansi_exit))
614 die_errno("atexit(winansi_exit) failed");
615
616 /* redirect stdout / stderr to the pipe */
617 if (con1)
618 hconsole1 = swap_osfhnd(1, duplicate_handle(hwrite));
619 if (con2)
620 hconsole2 = swap_osfhnd(2, duplicate_handle(hwrite));
621 }
622
623 /*
624 * Returns the real console handle if stdout / stderr is a pipe redirecting
625 * to the console. Allows spawn / exec to pass the console to the next process.
626 */
627 HANDLE winansi_get_osfhandle(int fd)
628 {
629 if (fd == 1 && (fd_is_interactive[1] & FD_SWAPPED))
630 return hconsole1;
631 if (fd == 2 && (fd_is_interactive[2] & FD_SWAPPED))
632 return hconsole2;
633
634 return (HANDLE)_get_osfhandle(fd);
635 }