2 * Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
8 * Including the appropriate header file for RtlGenRandom causes MSVC to see a
9 * redefinition of types in an incompatible way when including headers below.
11 #undef HAVE_RTLGENRANDOM
12 #include "../git-compat-util.h"
16 #include "win32/lazyload.h"
18 static int fd_is_interactive
[3] = { 0, 0, 0 };
19 #define FD_CONSOLE 0x1
20 #define FD_SWAPPED 0x2
24 ANSI codes used by git: m, K
26 This file is git-specific. Therefore, this file does not attempt
27 to implement any codes that are not used by git.
30 static HANDLE console
;
31 static WORD plain_attr
;
34 static int non_ascii_used
= 0;
35 static HANDLE hthread
, hread
, hwrite
;
36 static HANDLE hconsole1
, hconsole2
;
39 #if !defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 5
40 typedef struct _CONSOLE_FONT_INFOEX
{
46 WCHAR FaceName
[LF_FACESIZE
];
47 } CONSOLE_FONT_INFOEX
, *PCONSOLE_FONT_INFOEX
;
51 static void warn_if_raster_font(void)
54 DECLARE_PROC_ADDR(kernel32
.dll
, BOOL
, GetCurrentConsoleFontEx
,
55 HANDLE
, BOOL
, PCONSOLE_FONT_INFOEX
);
57 /* don't bother if output was ascii only */
61 /* GetCurrentConsoleFontEx is available since Vista */
62 if (INIT_PROC_ADDR(GetCurrentConsoleFontEx
)) {
63 CONSOLE_FONT_INFOEX cfi
;
64 cfi
.cbSize
= sizeof(cfi
);
65 if (GetCurrentConsoleFontEx(console
, 0, &cfi
))
66 fontFamily
= cfi
.FontFamily
;
68 /* pre-Vista: check default console font in registry */
70 if (ERROR_SUCCESS
== RegOpenKeyExA(HKEY_CURRENT_USER
, "Console",
71 0, KEY_READ
, &hkey
)) {
72 DWORD size
= sizeof(fontFamily
);
73 RegQueryValueExA(hkey
, "FontFamily", NULL
, NULL
,
74 (LPVOID
) &fontFamily
, &size
);
79 if (!(fontFamily
& TMPF_TRUETYPE
)) {
80 const wchar_t *msg
= L
"\nWarning: Your console font probably "
81 L
"doesn\'t support Unicode. If you experience strange "
82 L
"characters in the output, consider switching to a "
83 L
"TrueType font such as Consolas!\n";
85 WriteConsoleW(console
, msg
, wcslen(msg
), &dummy
, NULL
);
89 static int is_console(int fd
)
91 CONSOLE_SCREEN_BUFFER_INFO sbi
;
95 static int initialized
= 0;
97 /* get OS handle of the file descriptor */
98 hcon
= (HANDLE
) _get_osfhandle(fd
);
99 if (hcon
== INVALID_HANDLE_VALUE
)
102 /* check if its a device (i.e. console, printer, serial port) */
103 if (GetFileType(hcon
) != FILE_TYPE_CHAR
)
106 /* check if its a handle to a console output screen buffer */
108 if (!GetConsoleMode(hcon
, &mode
))
111 * This code path is only reached if there is no console
112 * attached to stdout/stderr, i.e. we will not need to output
113 * any text to any console, therefore we might just as well
114 * use black as foreground color.
117 } else if (!GetConsoleScreenBufferInfo(hcon
, &sbi
))
120 if (fd
>= 0 && fd
<= 2)
121 fd_is_interactive
[fd
] |= FD_CONSOLE
;
123 /* initialize attributes */
126 attr
= plain_attr
= sbi
.wAttributes
;
134 #define BUFFER_SIZE 4096
135 #define MAX_PARAMS 16
137 static void write_console(unsigned char *str
, size_t len
)
139 /* only called from console_thread, so a static buffer will do */
140 static wchar_t wbuf
[2 * BUFFER_SIZE
+ 1];
143 /* convert utf-8 to utf-16 */
144 int wlen
= xutftowcsn(wbuf
, (char*) str
, ARRAY_SIZE(wbuf
), len
);
146 wchar_t *err
= L
"[invalid]";
147 WriteConsoleW(console
, err
, wcslen(err
), &dummy
, NULL
);
151 /* write directly to console */
152 WriteConsoleW(console
, wbuf
, wlen
, &dummy
, NULL
);
154 /* remember if non-ascii characters are printed */
159 #define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
160 #define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
162 static void set_console_attr(void)
164 WORD attributes
= attr
;
166 attributes
&= ~FOREGROUND_ALL
;
167 attributes
&= ~BACKGROUND_ALL
;
169 /* This could probably use a bitmask
170 instead of a series of ifs */
171 if (attr
& FOREGROUND_RED
)
172 attributes
|= BACKGROUND_RED
;
173 if (attr
& FOREGROUND_GREEN
)
174 attributes
|= BACKGROUND_GREEN
;
175 if (attr
& FOREGROUND_BLUE
)
176 attributes
|= BACKGROUND_BLUE
;
178 if (attr
& BACKGROUND_RED
)
179 attributes
|= FOREGROUND_RED
;
180 if (attr
& BACKGROUND_GREEN
)
181 attributes
|= FOREGROUND_GREEN
;
182 if (attr
& BACKGROUND_BLUE
)
183 attributes
|= FOREGROUND_BLUE
;
185 SetConsoleTextAttribute(console
, attributes
);
188 static void erase_in_line(void)
190 CONSOLE_SCREEN_BUFFER_INFO sbi
;
191 DWORD dummy
; /* Needed for Windows 7 (or Vista) regression */
196 GetConsoleScreenBufferInfo(console
, &sbi
);
197 FillConsoleOutputCharacterA(console
, ' ',
198 sbi
.dwSize
.X
- sbi
.dwCursorPosition
.X
, sbi
.dwCursorPosition
,
202 static void set_attr(char func
, const int *params
, int paramlen
)
207 for (i
= 0; i
< paramlen
; i
++) {
214 attr
|= FOREGROUND_INTENSITY
;
217 case 22: /* normal */
218 attr
&= ~FOREGROUND_INTENSITY
;
223 case 4: /* underline */
224 case 21: /* double underline */
225 /* Wikipedia says this flag does nothing */
226 /* Furthermore, mingw doesn't define this flag
227 attr |= COMMON_LVB_UNDERSCORE; */
229 case 24: /* no underline */
230 /* attr &= ~COMMON_LVB_UNDERSCORE; */
232 case 5: /* slow blink */
233 case 6: /* fast blink */
234 /* We don't have blink, but we do have
235 background intensity */
236 attr
|= BACKGROUND_INTENSITY
;
238 case 25: /* no blink */
239 attr
&= ~BACKGROUND_INTENSITY
;
241 case 7: /* negative */
244 case 27: /* positive */
247 case 8: /* conceal */
248 case 28: /* reveal */
252 attr
&= ~FOREGROUND_ALL
;
255 attr
&= ~FOREGROUND_ALL
;
256 attr
|= FOREGROUND_RED
;
259 attr
&= ~FOREGROUND_ALL
;
260 attr
|= FOREGROUND_GREEN
;
262 case 33: /* Yellow */
263 attr
&= ~FOREGROUND_ALL
;
264 attr
|= FOREGROUND_RED
| FOREGROUND_GREEN
;
267 attr
&= ~FOREGROUND_ALL
;
268 attr
|= FOREGROUND_BLUE
;
270 case 35: /* Magenta */
271 attr
&= ~FOREGROUND_ALL
;
272 attr
|= FOREGROUND_RED
| FOREGROUND_BLUE
;
275 attr
&= ~FOREGROUND_ALL
;
276 attr
|= FOREGROUND_GREEN
| FOREGROUND_BLUE
;
279 attr
|= FOREGROUND_RED
|
283 case 38: /* Unknown */
286 attr
&= ~FOREGROUND_ALL
;
287 attr
|= (plain_attr
& FOREGROUND_ALL
);
290 attr
&= ~BACKGROUND_ALL
;
293 attr
&= ~BACKGROUND_ALL
;
294 attr
|= BACKGROUND_RED
;
297 attr
&= ~BACKGROUND_ALL
;
298 attr
|= BACKGROUND_GREEN
;
300 case 43: /* Yellow */
301 attr
&= ~BACKGROUND_ALL
;
302 attr
|= BACKGROUND_RED
| BACKGROUND_GREEN
;
305 attr
&= ~BACKGROUND_ALL
;
306 attr
|= BACKGROUND_BLUE
;
308 case 45: /* Magenta */
309 attr
&= ~BACKGROUND_ALL
;
310 attr
|= BACKGROUND_RED
| BACKGROUND_BLUE
;
313 attr
&= ~BACKGROUND_ALL
;
314 attr
|= BACKGROUND_GREEN
| BACKGROUND_BLUE
;
317 attr
|= BACKGROUND_RED
|
321 case 48: /* Unknown */
324 attr
&= ~BACKGROUND_ALL
;
325 attr
|= (plain_attr
& BACKGROUND_ALL
);
328 /* Unsupported code */
338 /* Unsupported code */
344 TEXT
= 0, ESCAPE
= 033, BRACKET
= '['
347 static DWORD WINAPI
console_thread(LPVOID unused
)
349 unsigned char buffer
[BUFFER_SIZE
];
351 int start
, end
= 0, c
, parampos
= 0, state
= TEXT
;
352 int params
[MAX_PARAMS
];
355 /* read next chunk of bytes from the pipe */
356 if (!ReadFile(hread
, buffer
+ end
, BUFFER_SIZE
- end
, &bytes
,
358 /* exit if pipe has been closed or disconnected */
359 if (GetLastError() == ERROR_PIPE_NOT_CONNECTED
||
360 GetLastError() == ERROR_BROKEN_PIPE
)
362 /* ignore other errors */
366 /* scan the bytes and handle ANSI control codes */
369 while (end
< bytes
) {
374 /* print text seen so far */
376 write_console(buffer
+ start
,
379 /* then start parsing escape sequence */
381 memset(params
, 0, sizeof(params
));
388 /* continue if "\033[", otherwise bail out */
389 state
= (c
== BRACKET
) ? BRACKET
: TEXT
;
393 /* parse [0-9;]* into array of parameters */
394 if (c
>= '0' && c
<= '9') {
395 params
[parampos
] *= 10;
396 params
[parampos
] += c
- '0';
397 } else if (c
== ';') {
399 * next parameter, bail out if out of
403 if (parampos
>= MAX_PARAMS
)
407 * end of escape sequence, change
410 set_attr(c
, params
, parampos
+ 1);
418 /* print remaining text unless parsing an escape sequence */
419 if (state
== TEXT
&& end
> start
) {
420 /* check for incomplete UTF-8 sequences and fix end */
421 if (buffer
[end
- 1] >= 0x80) {
422 if (buffer
[end
-1] >= 0xc0)
424 else if (end
- 1 > start
&&
425 buffer
[end
- 2] >= 0xe0)
427 else if (end
- 2 > start
&&
428 buffer
[end
- 3] >= 0xf0)
432 /* print remaining complete UTF-8 sequences */
434 write_console(buffer
+ start
, end
- start
);
436 /* move remaining bytes to the front */
438 memmove(buffer
, buffer
+ end
, bytes
- end
);
441 /* all data has been consumed, mark buffer empty */
446 /* check if the console font supports unicode */
447 warn_if_raster_font();
453 static void winansi_exit(void)
455 /* flush all streams */
458 /* signal console thread to exit */
459 FlushFileBuffers(hwrite
);
460 DisconnectNamedPipe(hwrite
);
462 /* wait for console thread to copy remaining data */
463 WaitForSingleObject(hthread
, INFINITE
);
465 /* cleanup handles... */
467 CloseHandle(hthread
);
470 static void die_lasterr(const char *fmt
, ...)
473 va_start(params
, fmt
);
474 errno
= err_win_to_posix(GetLastError());
475 die_errno(fmt
, params
);
480 int winansi_dup2(int oldfd
, int newfd
)
482 int ret
= dup2(oldfd
, newfd
);
484 if (!ret
&& newfd
>= 0 && newfd
<= 2)
485 fd_is_interactive
[newfd
] = oldfd
< 0 || oldfd
> 2 ?
486 0 : fd_is_interactive
[oldfd
];
491 static HANDLE
duplicate_handle(HANDLE hnd
)
493 HANDLE hresult
, hproc
= GetCurrentProcess();
494 if (!DuplicateHandle(hproc
, hnd
, hproc
, &hresult
, 0, TRUE
,
495 DUPLICATE_SAME_ACCESS
))
496 die_lasterr("DuplicateHandle(%li) failed",
497 (long) (intptr_t) hnd
);
501 static HANDLE
swap_osfhnd(int fd
, HANDLE new_handle
)
504 * Create a copy of the original handle associated with fd
505 * because the original will get closed when we dup2().
507 HANDLE handle
= (HANDLE
)_get_osfhandle(fd
);
508 HANDLE duplicate
= duplicate_handle(handle
);
510 /* Create a temp fd associated with the already open "new_handle". */
511 int new_fd
= _open_osfhandle((intptr_t)new_handle
, O_BINARY
);
513 assert((fd
== 1) || (fd
== 2));
516 * Use stock dup2() to re-bind fd to the new handle. Note that
517 * this will implicitly close(1) and close both fd=1 and the
518 * originally associated handle. It will open a new fd=1 and
519 * call DuplicateHandle() on the handle associated with new_fd.
520 * It is because of this implicit close() that we created the
521 * copy of the original.
523 * Note that we need to update the cached console handle to the
524 * duplicated one because the dup2() call will implicitly close
527 * Note that dup2() when given target := {0,1,2} will also
528 * call SetStdHandle(), so we don't need to worry about that.
530 if (console
== handle
)
534 /* Close the temp fd. This explicitly closes "new_handle"
535 * (because it has been associated with it).
540 setvbuf(stderr
, NULL
, _IONBF
, BUFSIZ
);
541 fd_is_interactive
[fd
] |= FD_SWAPPED
;
546 #ifdef DETECT_MSYS_TTY
548 #include <winternl.h>
550 #if defined(_MSC_VER)
552 typedef struct _OBJECT_NAME_INFORMATION
555 WCHAR NameBuffer
[FLEX_ARRAY
];
556 } OBJECT_NAME_INFORMATION
, *POBJECT_NAME_INFORMATION
;
558 #define ObjectNameInformation 1
561 #include <ntstatus.h>
564 static void detect_msys_tty(int fd
)
568 POBJECT_NAME_INFORMATION nameinfo
= (POBJECT_NAME_INFORMATION
) buffer
;
571 /* check if fd is a pipe */
572 HANDLE h
= (HANDLE
) _get_osfhandle(fd
);
573 if (GetFileType(h
) != FILE_TYPE_PIPE
)
577 if (!NT_SUCCESS(NtQueryObject(h
, ObjectNameInformation
,
578 buffer
, sizeof(buffer
) - 2, &result
)))
580 name
= nameinfo
->Name
.Buffer
;
581 name
[nameinfo
->Name
.Length
/ sizeof(*name
)] = 0;
584 * Check if this could be a MSYS2 pty pipe ('msys-XXXX-ptyN-XX')
585 * or a cygwin pty pipe ('cygwin-XXXX-ptyN-XX')
587 if ((!wcsstr(name
, L
"msys-") && !wcsstr(name
, L
"cygwin-")) ||
588 !wcsstr(name
, L
"-pty"))
592 setvbuf(stderr
, NULL
, _IONBF
, BUFSIZ
);
593 fd_is_interactive
[fd
] |= FD_MSYS
;
599 * Wrapper for isatty(). Most calls in the main git code
600 * call isatty(1 or 2) to see if the instance is interactive
601 * and should: be colored, show progress, paginate output.
602 * We lie and give results for what the descriptor WAS at
603 * startup (and ignore any pipe redirection we internally
607 int winansi_isatty(int fd
)
609 if (fd
>= 0 && fd
<= 2)
610 return fd_is_interactive
[fd
] != 0;
614 void winansi_init(void)
619 /* check if either stdout or stderr is a console output screen buffer */
620 con1
= is_console(1);
621 con2
= is_console(2);
623 /* Also compute console bit for fd 0 even though we don't need the result here. */
626 if (!con1
&& !con2
) {
627 #ifdef DETECT_MSYS_TTY
628 /* check if stdin / stdout / stderr are MSYS2 pty pipes */
636 /* create a named pipe to communicate with the console thread */
637 if (swprintf(name
, ARRAY_SIZE(name
) - 1, L
"\\\\.\\pipe\\winansi%lu",
638 GetCurrentProcessId()) < 0)
639 die("Could not initialize winansi pipe name");
640 hwrite
= CreateNamedPipeW(name
, PIPE_ACCESS_OUTBOUND
,
641 PIPE_TYPE_BYTE
| PIPE_WAIT
, 1, BUFFER_SIZE
, 0, 0, NULL
);
642 if (hwrite
== INVALID_HANDLE_VALUE
)
643 die_lasterr("CreateNamedPipe failed");
645 hread
= CreateFileW(name
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
646 if (hread
== INVALID_HANDLE_VALUE
)
647 die_lasterr("CreateFile for named pipe failed");
649 /* start console spool thread on the pipe's read end */
650 hthread
= CreateThread(NULL
, 0, console_thread
, NULL
, 0, NULL
);
651 if (hthread
== INVALID_HANDLE_VALUE
)
652 die_lasterr("CreateThread(console_thread) failed");
654 /* schedule cleanup routine */
655 if (atexit(winansi_exit
))
656 die_errno("atexit(winansi_exit) failed");
658 /* redirect stdout / stderr to the pipe */
660 hconsole1
= swap_osfhnd(1, duplicate_handle(hwrite
));
662 hconsole2
= swap_osfhnd(2, duplicate_handle(hwrite
));
666 * Returns the real console handle if stdout / stderr is a pipe redirecting
667 * to the console. Allows spawn / exec to pass the console to the next process.
669 HANDLE
winansi_get_osfhandle(int fd
)
673 if (fd
== 1 && (fd_is_interactive
[1] & FD_SWAPPED
))
675 if (fd
== 2 && (fd_is_interactive
[2] & FD_SWAPPED
))
678 ret
= (HANDLE
)_get_osfhandle(fd
);
681 * There are obviously circumstances under which _get_osfhandle()
682 * returns (HANDLE)-2. This is not documented anywhere, but that is so
683 * clearly an invalid handle value that we can just work around this
684 * and return the correct value for invalid handles.
686 return ret
== (HANDLE
)-2 ? INVALID_HANDLE_VALUE
: ret
;