1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. 2 * 3 * Permission is hereby granted, free of charge, to any person obtaining a copy 4 * of this software and associated documentation files (the "Software"), to 5 * deal in the Software without restriction, including without limitation the 6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 7 * sell copies of the Software, and to permit persons to whom the Software is 8 * furnished to do so, subject to the following conditions: 9 * 10 * The above copyright notice and this permission notice shall be included in 11 * all copies or substantial portions of the Software. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 19 * IN THE SOFTWARE. 20 */ 21 22 #include <assert.h> 23 #include <io.h> 24 #include <string.h> 25 #include <stdlib.h> 26 #include <stdint.h> 27 28 #ifndef COMMON_LVB_REVERSE_VIDEO 29 # define COMMON_LVB_REVERSE_VIDEO 0x4000 30 #endif 31 32 #include "uv.h" 33 #include "internal.h" 34 #include "handle-inl.h" 35 #include "stream-inl.h" 36 #include "req-inl.h" 37 38 #ifndef InterlockedOr 39 # define InterlockedOr _InterlockedOr 40 #endif 41 42 #define UNICODE_REPLACEMENT_CHARACTER (0xfffd) 43 44 #define ANSI_NORMAL 0x0000 45 #define ANSI_ESCAPE_SEEN 0x0002 46 #define ANSI_CSI 0x0004 47 #define ANSI_ST_CONTROL 0x0008 48 #define ANSI_IGNORE 0x0010 49 #define ANSI_IN_ARG 0x0020 50 #define ANSI_IN_STRING 0x0040 51 #define ANSI_BACKSLASH_SEEN 0x0080 52 #define ANSI_EXTENSION 0x0100 53 #define ANSI_DECSCUSR 0x0200 54 55 #define MAX_INPUT_BUFFER_LENGTH 8192 56 #define MAX_CONSOLE_CHAR 8192 57 58 #ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING 59 #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004 60 #endif 61 #ifndef ENABLE_VIRTUAL_TERMINAL_INPUT 62 #define ENABLE_VIRTUAL_TERMINAL_INPUT 0x0200 63 #endif 64 65 #define CURSOR_SIZE_SMALL 25 66 #define CURSOR_SIZE_LARGE 100 67 68 static void uv__tty_capture_initial_style( 69 CONSOLE_SCREEN_BUFFER_INFO* screen_buffer_info, 70 CONSOLE_CURSOR_INFO* cursor_info); 71 static void uv__tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info); 72 static int uv__cancel_read_console(uv_tty_t* handle); 73 74 75 /* Null uv_buf_t */ 76 static const uv_buf_t uv_null_buf_ = { 0, NULL }; 77 78 enum uv__read_console_status_e { 79 NOT_STARTED, 80 IN_PROGRESS, 81 TRAP_REQUESTED, 82 COMPLETED 83 }; 84 85 static volatile LONG uv__read_console_status = NOT_STARTED; 86 static volatile LONG uv__restore_screen_state; 87 static CONSOLE_SCREEN_BUFFER_INFO uv__saved_screen_state; 88 89 90 /* 91 * The console virtual window. 92 * 93 * Normally cursor movement in windows is relative to the console screen buffer, 94 * e.g. the application is allowed to overwrite the 'history'. This is very 95 * inconvenient, it makes absolute cursor movement pretty useless. There is 96 * also the concept of 'client rect' which is defined by the actual size of 97 * the console window and the scroll position of the screen buffer, but it's 98 * very volatile because it changes when the user scrolls. 99 * 100 * To make cursor movement behave sensibly we define a virtual window to which 101 * cursor movement is confined. The virtual window is always as wide as the 102 * console screen buffer, but it's height is defined by the size of the 103 * console window. The top of the virtual window aligns with the position 104 * of the caret when the first stdout/err handle is created, unless that would 105 * mean that it would extend beyond the bottom of the screen buffer - in that 106 * that case it's located as far down as possible. 107 * 108 * When the user writes a long text or many newlines, such that the output 109 * reaches beyond the bottom of the virtual window, the virtual window is 110 * shifted downwards, but not resized. 111 * 112 * Since all tty i/o happens on the same console, this window is shared 113 * between all stdout/stderr handles. 114 */ 115 116 static int uv_tty_virtual_offset = -1; 117 static int uv_tty_virtual_height = -1; 118 static int uv_tty_virtual_width = -1; 119 120 /* The console window size 121 * We keep this separate from uv_tty_virtual_*. We use those values to only 122 * handle signalling SIGWINCH 123 */ 124 125 static HANDLE uv__tty_console_handle_out = INVALID_HANDLE_VALUE; 126 static HANDLE uv__tty_console_handle_in = INVALID_HANDLE_VALUE; 127 static DWORD uv__tty_console_in_original_mode = (DWORD)-1; 128 static volatile LONG uv__tty_console_in_need_mode_reset = 0; 129 static int uv__tty_console_height = -1; 130 static int uv__tty_console_width = -1; 131 static HANDLE uv__tty_console_resized = INVALID_HANDLE_VALUE; 132 static uv_mutex_t uv__tty_console_resize_mutex; 133 134 static DWORD WINAPI uv__tty_console_resize_message_loop_thread(void* param); 135 static void CALLBACK uv__tty_console_resize_event(HWINEVENTHOOK hWinEventHook, 136 DWORD event, 137 HWND hwnd, 138 LONG idObject, 139 LONG idChild, 140 DWORD dwEventThread, 141 DWORD dwmsEventTime); 142 static DWORD WINAPI uv__tty_console_resize_watcher_thread(void* param); 143 static void uv__tty_console_signal_resize(void); 144 145 /* We use a semaphore rather than a mutex or critical section because in some 146 cases (uv__cancel_read_console) we need take the lock in the main thread and 147 release it in another thread. Using a semaphore ensures that in such 148 scenario the main thread will still block when trying to acquire the lock. */ 149 static uv_sem_t uv_tty_output_lock; 150 151 static WORD uv_tty_default_text_attributes = 152 FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; 153 154 static char uv_tty_default_fg_color = 7; 155 static char uv_tty_default_bg_color = 0; 156 static char uv_tty_default_fg_bright = 0; 157 static char uv_tty_default_bg_bright = 0; 158 static char uv_tty_default_inverse = 0; 159 160 static CONSOLE_CURSOR_INFO uv_tty_default_cursor_info; 161 162 /* Determine whether or not ANSI support is enabled. */ 163 static BOOL uv__need_check_vterm_state = TRUE; 164 static uv_tty_vtermstate_t uv__vterm_state = UV_TTY_UNSUPPORTED; 165 static void uv__determine_vterm_state(HANDLE handle); 166 167 void uv__console_init(void) { 168 DWORD dwMode; 169 170 if (uv_sem_init(&uv_tty_output_lock, 1)) 171 abort(); 172 uv__tty_console_handle_out = CreateFileW(L"CONOUT$", 173 GENERIC_READ | GENERIC_WRITE, 174 FILE_SHARE_WRITE, 175 0, 176 OPEN_EXISTING, 177 0, 178 0); 179 if (uv__tty_console_handle_out != INVALID_HANDLE_VALUE) { 180 CONSOLE_SCREEN_BUFFER_INFO sb_info; 181 uv_mutex_init(&uv__tty_console_resize_mutex); 182 if (GetConsoleScreenBufferInfo(uv__tty_console_handle_out, &sb_info)) { 183 uv__tty_console_width = sb_info.dwSize.X; 184 uv__tty_console_height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1; 185 } 186 QueueUserWorkItem(uv__tty_console_resize_message_loop_thread, 187 NULL, 188 WT_EXECUTELONGFUNCTION); 189 } 190 uv__tty_console_handle_in = CreateFileW(L"CONIN$", 191 GENERIC_READ | GENERIC_WRITE, 192 FILE_SHARE_READ, 193 0, 194 OPEN_EXISTING, 195 0, 196 0); 197 if (uv__tty_console_handle_in != INVALID_HANDLE_VALUE) { 198 if (GetConsoleMode(uv__tty_console_handle_in, &dwMode)) { 199 uv__tty_console_in_original_mode = dwMode; 200 } 201 } 202 } 203 204 205 int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, uv_file fd, int unused) { 206 BOOL readable; 207 DWORD NumberOfEvents; 208 HANDLE handle; 209 CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info; 210 CONSOLE_CURSOR_INFO cursor_info; 211 (void)unused; 212 213 uv__once_init(); 214 handle = (HANDLE) uv__get_osfhandle(fd); 215 if (handle == INVALID_HANDLE_VALUE) 216 return UV_EBADF; 217 218 if (fd <= 2) { 219 /* In order to avoid closing a stdio file descriptor 0-2, duplicate the 220 * underlying OS handle and forget about the original fd. 221 * We could also opt to use the original OS handle and just never close it, 222 * but then there would be no reliable way to cancel pending read operations 223 * upon close. 224 */ 225 if (!DuplicateHandle(INVALID_HANDLE_VALUE, 226 handle, 227 INVALID_HANDLE_VALUE, 228 &handle, 229 0, 230 FALSE, 231 DUPLICATE_SAME_ACCESS)) 232 return uv_translate_sys_error(GetLastError()); 233 fd = -1; 234 } 235 236 readable = GetNumberOfConsoleInputEvents(handle, &NumberOfEvents); 237 if (!readable) { 238 /* Obtain the screen buffer info with the output handle. */ 239 if (!GetConsoleScreenBufferInfo(handle, &screen_buffer_info)) { 240 return uv_translate_sys_error(GetLastError()); 241 } 242 243 /* Obtain the cursor info with the output handle. */ 244 if (!GetConsoleCursorInfo(handle, &cursor_info)) { 245 return uv_translate_sys_error(GetLastError()); 246 } 247 248 /* Obtain the tty_output_lock because the virtual window state is shared 249 * between all uv_tty_t handles. */ 250 uv_sem_wait(&uv_tty_output_lock); 251 252 if (uv__need_check_vterm_state) 253 uv__determine_vterm_state(handle); 254 255 /* Remember the original console text attributes and cursor info. */ 256 uv__tty_capture_initial_style(&screen_buffer_info, &cursor_info); 257 258 uv__tty_update_virtual_window(&screen_buffer_info); 259 260 uv_sem_post(&uv_tty_output_lock); 261 } 262 263 264 uv__stream_init(loop, (uv_stream_t*) tty, UV_TTY); 265 uv__connection_init((uv_stream_t*) tty); 266 267 tty->handle = handle; 268 tty->u.fd = fd; 269 tty->reqs_pending = 0; 270 tty->flags |= UV_HANDLE_BOUND; 271 272 if (readable) { 273 /* Initialize TTY input specific fields. */ 274 tty->flags |= UV_HANDLE_TTY_READABLE | UV_HANDLE_READABLE; 275 /* TODO: remove me in v2.x. */ 276 tty->tty.rd.mode.unused_ = NULL; 277 /* Partially overwrites unused_ again. */ 278 tty->tty.rd.mode.mode = 0; 279 tty->tty.rd.read_line_buffer = uv_null_buf_; 280 tty->tty.rd.read_raw_wait = NULL; 281 282 /* Init keycode-to-vt100 mapper state. */ 283 tty->tty.rd.last_key_len = 0; 284 tty->tty.rd.last_key_offset = 0; 285 tty->tty.rd.last_utf16_high_surrogate = 0; 286 memset(&tty->tty.rd.last_input_record, 0, sizeof tty->tty.rd.last_input_record); 287 } else { 288 /* TTY output specific fields. */ 289 tty->flags |= UV_HANDLE_WRITABLE; 290 291 /* Init utf8-to-utf16 conversion state. */ 292 tty->tty.wr.utf8_bytes_left = 0; 293 tty->tty.wr.utf8_codepoint = 0; 294 295 /* Initialize eol conversion state */ 296 tty->tty.wr.previous_eol = 0; 297 298 /* Init ANSI parser state. */ 299 tty->tty.wr.ansi_parser_state = ANSI_NORMAL; 300 } 301 302 return 0; 303 } 304 305 306 /* Set the default console text attributes based on how the console was 307 * configured when libuv started. 308 */ 309 static void uv__tty_capture_initial_style( 310 CONSOLE_SCREEN_BUFFER_INFO* screen_buffer_info, 311 CONSOLE_CURSOR_INFO* cursor_info) { 312 static int style_captured = 0; 313 314 /* Only do this once. 315 Assumption: Caller has acquired uv_tty_output_lock. */ 316 if (style_captured) 317 return; 318 319 /* Save raw win32 attributes. */ 320 uv_tty_default_text_attributes = screen_buffer_info->wAttributes; 321 322 /* Convert black text on black background to use white text. */ 323 if (uv_tty_default_text_attributes == 0) 324 uv_tty_default_text_attributes = 7; 325 326 /* Convert Win32 attributes to ANSI colors. */ 327 uv_tty_default_fg_color = 0; 328 uv_tty_default_bg_color = 0; 329 uv_tty_default_fg_bright = 0; 330 uv_tty_default_bg_bright = 0; 331 uv_tty_default_inverse = 0; 332 333 if (uv_tty_default_text_attributes & FOREGROUND_RED) 334 uv_tty_default_fg_color |= 1; 335 336 if (uv_tty_default_text_attributes & FOREGROUND_GREEN) 337 uv_tty_default_fg_color |= 2; 338 339 if (uv_tty_default_text_attributes & FOREGROUND_BLUE) 340 uv_tty_default_fg_color |= 4; 341 342 if (uv_tty_default_text_attributes & BACKGROUND_RED) 343 uv_tty_default_bg_color |= 1; 344 345 if (uv_tty_default_text_attributes & BACKGROUND_GREEN) 346 uv_tty_default_bg_color |= 2; 347 348 if (uv_tty_default_text_attributes & BACKGROUND_BLUE) 349 uv_tty_default_bg_color |= 4; 350 351 if (uv_tty_default_text_attributes & FOREGROUND_INTENSITY) 352 uv_tty_default_fg_bright = 1; 353 354 if (uv_tty_default_text_attributes & BACKGROUND_INTENSITY) 355 uv_tty_default_bg_bright = 1; 356 357 if (uv_tty_default_text_attributes & COMMON_LVB_REVERSE_VIDEO) 358 uv_tty_default_inverse = 1; 359 360 /* Save the cursor size and the cursor state. */ 361 uv_tty_default_cursor_info = *cursor_info; 362 363 style_captured = 1; 364 } 365 366 367 int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) { 368 DWORD flags; 369 DWORD try_set_flags; 370 unsigned char was_reading; 371 uv_alloc_cb alloc_cb; 372 uv_read_cb read_cb; 373 int err; 374 375 if (!(tty->flags & UV_HANDLE_TTY_READABLE)) { 376 return UV_EINVAL; 377 } 378 379 if ((int)mode == tty->tty.rd.mode.mode) { 380 return 0; 381 } 382 383 try_set_flags = 0; 384 switch (mode) { 385 case UV_TTY_MODE_NORMAL: 386 flags = ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT; 387 break; 388 case UV_TTY_MODE_RAW_VT: 389 try_set_flags = ENABLE_VIRTUAL_TERMINAL_INPUT; 390 InterlockedExchange(&uv__tty_console_in_need_mode_reset, 1); 391 /* fallthrough */ 392 case UV_TTY_MODE_RAW: 393 flags = ENABLE_WINDOW_INPUT; 394 break; 395 case UV_TTY_MODE_IO: 396 return UV_ENOTSUP; 397 default: 398 return UV_EINVAL; 399 } 400 401 /* If currently reading, stop, and restart reading. */ 402 if (tty->flags & UV_HANDLE_READING) { 403 was_reading = 1; 404 alloc_cb = tty->alloc_cb; 405 read_cb = tty->read_cb; 406 err = uv__tty_read_stop(tty); 407 if (err) { 408 return uv_translate_sys_error(err); 409 } 410 } else { 411 was_reading = 0; 412 alloc_cb = NULL; 413 read_cb = NULL; 414 } 415 416 uv_sem_wait(&uv_tty_output_lock); 417 if (!SetConsoleMode(tty->handle, flags | try_set_flags) && 418 !SetConsoleMode(tty->handle, flags)) { 419 err = uv_translate_sys_error(GetLastError()); 420 uv_sem_post(&uv_tty_output_lock); 421 return err; 422 } 423 uv_sem_post(&uv_tty_output_lock); 424 425 /* Update mode. */ 426 tty->tty.rd.mode.mode = mode; 427 428 /* If we just stopped reading, restart. */ 429 if (was_reading) { 430 err = uv__tty_read_start(tty, alloc_cb, read_cb); 431 if (err) { 432 return uv_translate_sys_error(err); 433 } 434 } 435 436 return 0; 437 } 438 439 440 int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) { 441 CONSOLE_SCREEN_BUFFER_INFO info; 442 443 if (!GetConsoleScreenBufferInfo(tty->handle, &info)) { 444 return uv_translate_sys_error(GetLastError()); 445 } 446 447 uv_sem_wait(&uv_tty_output_lock); 448 uv__tty_update_virtual_window(&info); 449 uv_sem_post(&uv_tty_output_lock); 450 451 *width = uv_tty_virtual_width; 452 *height = uv_tty_virtual_height; 453 454 return 0; 455 } 456 457 458 static void CALLBACK uv_tty_post_raw_read(void* data, BOOLEAN didTimeout) { 459 uv_loop_t* loop; 460 uv_tty_t* handle; 461 uv_req_t* req; 462 463 assert(data); 464 assert(!didTimeout); 465 466 req = (uv_req_t*) data; 467 handle = (uv_tty_t*) req->data; 468 loop = handle->loop; 469 470 UnregisterWait(handle->tty.rd.read_raw_wait); 471 handle->tty.rd.read_raw_wait = NULL; 472 473 SET_REQ_SUCCESS(req); 474 POST_COMPLETION_FOR_REQ(loop, req); 475 } 476 477 478 static void uv__tty_queue_read_raw(uv_loop_t* loop, uv_tty_t* handle) { 479 uv_read_t* req; 480 BOOL r; 481 482 assert(handle->flags & UV_HANDLE_READING); 483 assert(!(handle->flags & UV_HANDLE_READ_PENDING)); 484 485 assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE); 486 487 handle->tty.rd.read_line_buffer = uv_null_buf_; 488 489 req = &handle->read_req; 490 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped)); 491 492 r = RegisterWaitForSingleObject(&handle->tty.rd.read_raw_wait, 493 handle->handle, 494 uv_tty_post_raw_read, 495 (void*) req, 496 INFINITE, 497 WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE); 498 if (!r) { 499 handle->tty.rd.read_raw_wait = NULL; 500 SET_REQ_ERROR(req, GetLastError()); 501 uv__insert_pending_req(loop, (uv_req_t*)req); 502 } 503 504 handle->flags |= UV_HANDLE_READ_PENDING; 505 handle->reqs_pending++; 506 } 507 508 509 static DWORD CALLBACK uv_tty_line_read_thread(void* data) { 510 uv_loop_t* loop; 511 uv_tty_t* handle; 512 uv_req_t* req; 513 DWORD bytes; 514 size_t read_bytes; 515 WCHAR utf16[MAX_INPUT_BUFFER_LENGTH / 3]; 516 DWORD chars; 517 DWORD read_chars; 518 LONG status; 519 COORD pos; 520 BOOL read_console_success; 521 522 assert(data); 523 524 req = (uv_req_t*) data; 525 handle = (uv_tty_t*) req->data; 526 loop = handle->loop; 527 528 assert(handle->tty.rd.read_line_buffer.base != NULL); 529 assert(handle->tty.rd.read_line_buffer.len > 0); 530 531 /* ReadConsole can't handle big buffers. */ 532 if (handle->tty.rd.read_line_buffer.len < MAX_INPUT_BUFFER_LENGTH) { 533 bytes = handle->tty.rd.read_line_buffer.len; 534 } else { 535 bytes = MAX_INPUT_BUFFER_LENGTH; 536 } 537 538 /* At last, unicode! One utf-16 codeunit never takes more than 3 utf-8 539 * codeunits to encode. */ 540 chars = bytes / 3; 541 542 status = InterlockedExchange(&uv__read_console_status, IN_PROGRESS); 543 if (status == TRAP_REQUESTED) { 544 SET_REQ_SUCCESS(req); 545 InterlockedExchange(&uv__read_console_status, COMPLETED); 546 req->u.io.overlapped.InternalHigh = 0; 547 POST_COMPLETION_FOR_REQ(loop, req); 548 return 0; 549 } 550 551 read_console_success = ReadConsoleW(handle->handle, 552 (void*) utf16, 553 chars, 554 &read_chars, 555 NULL); 556 557 if (read_console_success) { 558 read_bytes = bytes; 559 uv_utf16_to_wtf8(utf16, 560 read_chars, 561 &handle->tty.rd.read_line_buffer.base, 562 &read_bytes); 563 SET_REQ_SUCCESS(req); 564 req->u.io.overlapped.InternalHigh = (DWORD) read_bytes; 565 } else { 566 SET_REQ_ERROR(req, GetLastError()); 567 } 568 569 status = InterlockedExchange(&uv__read_console_status, COMPLETED); 570 571 if (status == TRAP_REQUESTED) { 572 /* If we canceled the read by sending a VK_RETURN event, restore the 573 screen state to undo the visual effect of the VK_RETURN */ 574 if (read_console_success && InterlockedOr(&uv__restore_screen_state, 0)) { 575 HANDLE active_screen_buffer; 576 active_screen_buffer = CreateFileA("conout$", 577 GENERIC_READ | GENERIC_WRITE, 578 FILE_SHARE_READ | FILE_SHARE_WRITE, 579 NULL, 580 OPEN_EXISTING, 581 FILE_ATTRIBUTE_NORMAL, 582 NULL); 583 if (active_screen_buffer != INVALID_HANDLE_VALUE) { 584 pos = uv__saved_screen_state.dwCursorPosition; 585 586 /* If the cursor was at the bottom line of the screen buffer, the 587 VK_RETURN would have caused the buffer contents to scroll up by one 588 line. The right position to reset the cursor to is therefore one line 589 higher */ 590 if (pos.Y == uv__saved_screen_state.dwSize.Y - 1) 591 pos.Y--; 592 593 SetConsoleCursorPosition(active_screen_buffer, pos); 594 CloseHandle(active_screen_buffer); 595 } 596 } 597 uv_sem_post(&uv_tty_output_lock); 598 } 599 POST_COMPLETION_FOR_REQ(loop, req); 600 return 0; 601 } 602 603 604 static void uv__tty_queue_read_line(uv_loop_t* loop, uv_tty_t* handle) { 605 uv_read_t* req; 606 BOOL r; 607 608 assert(handle->flags & UV_HANDLE_READING); 609 assert(!(handle->flags & UV_HANDLE_READ_PENDING)); 610 assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE); 611 612 req = &handle->read_req; 613 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped)); 614 615 handle->tty.rd.read_line_buffer = uv_buf_init(NULL, 0); 616 handle->alloc_cb((uv_handle_t*) handle, 8192, &handle->tty.rd.read_line_buffer); 617 if (handle->tty.rd.read_line_buffer.base == NULL || 618 handle->tty.rd.read_line_buffer.len == 0) { 619 handle->read_cb((uv_stream_t*) handle, 620 UV_ENOBUFS, 621 &handle->tty.rd.read_line_buffer); 622 return; 623 } 624 assert(handle->tty.rd.read_line_buffer.base != NULL); 625 626 /* Reset flags No locking is required since there cannot be a line read 627 in progress. We are also relying on the memory barrier provided by 628 QueueUserWorkItem*/ 629 uv__restore_screen_state = FALSE; 630 uv__read_console_status = NOT_STARTED; 631 r = QueueUserWorkItem(uv_tty_line_read_thread, 632 (void*) req, 633 WT_EXECUTELONGFUNCTION); 634 if (!r) { 635 SET_REQ_ERROR(req, GetLastError()); 636 uv__insert_pending_req(loop, (uv_req_t*)req); 637 } 638 639 handle->flags |= UV_HANDLE_READ_PENDING; 640 handle->reqs_pending++; 641 } 642 643 644 static void uv__tty_queue_read(uv_loop_t* loop, uv_tty_t* handle) { 645 if (uv__is_raw_tty_mode(handle->tty.rd.mode.mode)) { 646 uv__tty_queue_read_raw(loop, handle); 647 } else { 648 uv__tty_queue_read_line(loop, handle); 649 } 650 } 651 652 653 static const char* get_vt100_fn_key(DWORD code, char shift, char ctrl, 654 size_t* len) { 655 #define VK_CASE(vk, normal_str, shift_str, ctrl_str, shift_ctrl_str) \ 656 case (vk): \ 657 if (shift && ctrl) { \ 658 *len = sizeof shift_ctrl_str; \ 659 return "\033" shift_ctrl_str; \ 660 } else if (shift) { \ 661 *len = sizeof shift_str ; \ 662 return "\033" shift_str; \ 663 } else if (ctrl) { \ 664 *len = sizeof ctrl_str; \ 665 return "\033" ctrl_str; \ 666 } else { \ 667 *len = sizeof normal_str; \ 668 return "\033" normal_str; \ 669 } 670 671 switch (code) { 672 /* These mappings are the same as Cygwin's. Unmodified and alt-modified 673 * keypad keys comply with linux console, modifiers comply with xterm 674 * modifier usage. F1. f12 and shift-f1. f10 comply with linux console, f6. 675 * f12 with and without modifiers comply with rxvt. */ 676 VK_CASE(VK_INSERT, "[2~", "[2;2~", "[2;5~", "[2;6~") 677 VK_CASE(VK_END, "[4~", "[4;2~", "[4;5~", "[4;6~") 678 VK_CASE(VK_DOWN, "[B", "[1;2B", "[1;5B", "[1;6B") 679 VK_CASE(VK_NEXT, "[6~", "[6;2~", "[6;5~", "[6;6~") 680 VK_CASE(VK_LEFT, "[D", "[1;2D", "[1;5D", "[1;6D") 681 VK_CASE(VK_CLEAR, "[G", "[1;2G", "[1;5G", "[1;6G") 682 VK_CASE(VK_RIGHT, "[C", "[1;2C", "[1;5C", "[1;6C") 683 VK_CASE(VK_UP, "[A", "[1;2A", "[1;5A", "[1;6A") 684 VK_CASE(VK_HOME, "[1~", "[1;2~", "[1;5~", "[1;6~") 685 VK_CASE(VK_PRIOR, "[5~", "[5;2~", "[5;5~", "[5;6~") 686 VK_CASE(VK_DELETE, "[3~", "[3;2~", "[3;5~", "[3;6~") 687 VK_CASE(VK_NUMPAD0, "[2~", "[2;2~", "[2;5~", "[2;6~") 688 VK_CASE(VK_NUMPAD1, "[4~", "[4;2~", "[4;5~", "[4;6~") 689 VK_CASE(VK_NUMPAD2, "[B", "[1;2B", "[1;5B", "[1;6B") 690 VK_CASE(VK_NUMPAD3, "[6~", "[6;2~", "[6;5~", "[6;6~") 691 VK_CASE(VK_NUMPAD4, "[D", "[1;2D", "[1;5D", "[1;6D") 692 VK_CASE(VK_NUMPAD5, "[G", "[1;2G", "[1;5G", "[1;6G") 693 VK_CASE(VK_NUMPAD6, "[C", "[1;2C", "[1;5C", "[1;6C") 694 VK_CASE(VK_NUMPAD7, "[A", "[1;2A", "[1;5A", "[1;6A") 695 VK_CASE(VK_NUMPAD8, "[1~", "[1;2~", "[1;5~", "[1;6~") 696 VK_CASE(VK_NUMPAD9, "[5~", "[5;2~", "[5;5~", "[5;6~") 697 VK_CASE(VK_DECIMAL, "[3~", "[3;2~", "[3;5~", "[3;6~") 698 VK_CASE(VK_F1, "[[A", "[23~", "[11^", "[23^" ) 699 VK_CASE(VK_F2, "[[B", "[24~", "[12^", "[24^" ) 700 VK_CASE(VK_F3, "[[C", "[25~", "[13^", "[25^" ) 701 VK_CASE(VK_F4, "[[D", "[26~", "[14^", "[26^" ) 702 VK_CASE(VK_F5, "[[E", "[28~", "[15^", "[28^" ) 703 VK_CASE(VK_F6, "[17~", "[29~", "[17^", "[29^" ) 704 VK_CASE(VK_F7, "[18~", "[31~", "[18^", "[31^" ) 705 VK_CASE(VK_F8, "[19~", "[32~", "[19^", "[32^" ) 706 VK_CASE(VK_F9, "[20~", "[33~", "[20^", "[33^" ) 707 VK_CASE(VK_F10, "[21~", "[34~", "[21^", "[34^" ) 708 VK_CASE(VK_F11, "[23~", "[23$", "[23^", "[23@" ) 709 VK_CASE(VK_F12, "[24~", "[24$", "[24^", "[24@" ) 710 711 default: 712 *len = 0; 713 return NULL; 714 } 715 #undef VK_CASE 716 } 717 718 719 void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, 720 uv_req_t* req) { 721 /* Shortcut for handle->tty.rd.last_input_record.Event.KeyEvent. */ 722 #define KEV handle->tty.rd.last_input_record.Event.KeyEvent 723 724 DWORD records_left, records_read; 725 uv_buf_t buf; 726 _off_t buf_used; 727 728 assert(handle->type == UV_TTY); 729 assert(handle->flags & UV_HANDLE_TTY_READABLE); 730 handle->flags &= ~UV_HANDLE_READ_PENDING; 731 732 if (!(handle->flags & UV_HANDLE_READING) || 733 !(uv__is_raw_tty_mode(handle->tty.rd.mode.mode))) { 734 goto out; 735 } 736 737 if (!REQ_SUCCESS(req)) { 738 /* An error occurred while waiting for the event. */ 739 if ((handle->flags & UV_HANDLE_READING)) { 740 handle->flags &= ~UV_HANDLE_READING; 741 handle->read_cb((uv_stream_t*)handle, 742 uv_translate_sys_error(GET_REQ_ERROR(req)), 743 &uv_null_buf_); 744 } 745 goto out; 746 } 747 748 /* Fetch the number of events */ 749 if (!GetNumberOfConsoleInputEvents(handle->handle, &records_left)) { 750 handle->flags &= ~UV_HANDLE_READING; 751 DECREASE_ACTIVE_COUNT(loop, handle); 752 handle->read_cb((uv_stream_t*)handle, 753 uv_translate_sys_error(GetLastError()), 754 &uv_null_buf_); 755 goto out; 756 } 757 758 /* Windows sends a lot of events that we're not interested in, so buf will be 759 * allocated on demand, when there's actually something to emit. */ 760 buf = uv_null_buf_; 761 buf_used = 0; 762 763 while ((records_left > 0 || handle->tty.rd.last_key_len > 0) && 764 (handle->flags & UV_HANDLE_READING)) { 765 if (handle->tty.rd.last_key_len == 0) { 766 /* Read the next input record */ 767 if (!ReadConsoleInputW(handle->handle, 768 &handle->tty.rd.last_input_record, 769 1, 770 &records_read)) { 771 handle->flags &= ~UV_HANDLE_READING; 772 DECREASE_ACTIVE_COUNT(loop, handle); 773 handle->read_cb((uv_stream_t*) handle, 774 uv_translate_sys_error(GetLastError()), 775 &buf); 776 goto out; 777 } 778 records_left--; 779 780 /* We might be not subscribed to EVENT_CONSOLE_LAYOUT or we might be 781 * running under some TTY emulator that does not send those events. */ 782 if (handle->tty.rd.last_input_record.EventType == WINDOW_BUFFER_SIZE_EVENT) { 783 uv__tty_console_signal_resize(); 784 } 785 786 /* Ignore other events that are not key events. */ 787 if (handle->tty.rd.last_input_record.EventType != KEY_EVENT) { 788 continue; 789 } 790 791 /* Ignore keyup events, unless the left alt key was held and a valid 792 * unicode character was emitted. */ 793 if (!KEV.bKeyDown && 794 (KEV.wVirtualKeyCode != VK_MENU || 795 KEV.uChar.UnicodeChar == 0)) { 796 continue; 797 } 798 799 /* Ignore keypresses to numpad number keys if the left alt is held 800 * because the user is composing a character, or windows simulating this. 801 */ 802 if ((KEV.dwControlKeyState & LEFT_ALT_PRESSED) && 803 !(KEV.dwControlKeyState & ENHANCED_KEY) && 804 (KEV.wVirtualKeyCode == VK_INSERT || 805 KEV.wVirtualKeyCode == VK_END || 806 KEV.wVirtualKeyCode == VK_DOWN || 807 KEV.wVirtualKeyCode == VK_NEXT || 808 KEV.wVirtualKeyCode == VK_LEFT || 809 KEV.wVirtualKeyCode == VK_CLEAR || 810 KEV.wVirtualKeyCode == VK_RIGHT || 811 KEV.wVirtualKeyCode == VK_HOME || 812 KEV.wVirtualKeyCode == VK_UP || 813 KEV.wVirtualKeyCode == VK_PRIOR || 814 KEV.wVirtualKeyCode == VK_NUMPAD0 || 815 KEV.wVirtualKeyCode == VK_NUMPAD1 || 816 KEV.wVirtualKeyCode == VK_NUMPAD2 || 817 KEV.wVirtualKeyCode == VK_NUMPAD3 || 818 KEV.wVirtualKeyCode == VK_NUMPAD4 || 819 KEV.wVirtualKeyCode == VK_NUMPAD5 || 820 KEV.wVirtualKeyCode == VK_NUMPAD6 || 821 KEV.wVirtualKeyCode == VK_NUMPAD7 || 822 KEV.wVirtualKeyCode == VK_NUMPAD8 || 823 KEV.wVirtualKeyCode == VK_NUMPAD9)) { 824 continue; 825 } 826 827 if (KEV.uChar.UnicodeChar != 0) { 828 int prefix_len; 829 size_t char_len; 830 char* last_key_buf; 831 832 /* Character key pressed */ 833 if (KEV.uChar.UnicodeChar >= 0xD800 && 834 KEV.uChar.UnicodeChar < 0xDC00) { 835 /* UTF-16 high surrogate */ 836 handle->tty.rd.last_utf16_high_surrogate = KEV.uChar.UnicodeChar; 837 continue; 838 } 839 840 /* Prefix with \u033 if alt was held, but alt was not used as part a 841 * compose sequence. */ 842 if ((KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) 843 && !(KEV.dwControlKeyState & (LEFT_CTRL_PRESSED | 844 RIGHT_CTRL_PRESSED)) && KEV.bKeyDown) { 845 handle->tty.rd.last_key[0] = '\033'; 846 prefix_len = 1; 847 } else { 848 prefix_len = 0; 849 } 850 851 char_len = sizeof handle->tty.rd.last_key; 852 last_key_buf = &handle->tty.rd.last_key[prefix_len]; 853 if (handle->tty.rd.last_utf16_high_surrogate) { 854 /* UTF-16 surrogate pair */ 855 WCHAR utf16_buffer[2]; 856 utf16_buffer[0] = handle->tty.rd.last_utf16_high_surrogate; 857 utf16_buffer[1] = KEV.uChar.UnicodeChar; 858 if (uv_utf16_to_wtf8(utf16_buffer, 859 2, 860 &last_key_buf, 861 &char_len)) 862 char_len = 0; 863 handle->tty.rd.last_utf16_high_surrogate = 0; 864 } else { 865 /* Single UTF-16 character */ 866 if (uv_utf16_to_wtf8(&KEV.uChar.UnicodeChar, 867 1, 868 &last_key_buf, 869 &char_len)) 870 char_len = 0; 871 } 872 873 /* If the utf16 character(s) couldn't be converted something must be 874 * wrong. */ 875 if (char_len == 0) { 876 handle->flags &= ~UV_HANDLE_READING; 877 DECREASE_ACTIVE_COUNT(loop, handle); 878 handle->read_cb((uv_stream_t*) handle, 879 uv_translate_sys_error(GetLastError()), 880 &buf); 881 goto out; 882 } 883 884 handle->tty.rd.last_key_len = (unsigned char) (prefix_len + char_len); 885 handle->tty.rd.last_key_offset = 0; 886 continue; 887 888 } else { 889 /* Function key pressed */ 890 const char* vt100; 891 size_t prefix_len, vt100_len; 892 893 vt100 = get_vt100_fn_key(KEV.wVirtualKeyCode, 894 !!(KEV.dwControlKeyState & SHIFT_PRESSED), 895 !!(KEV.dwControlKeyState & ( 896 LEFT_CTRL_PRESSED | 897 RIGHT_CTRL_PRESSED)), 898 &vt100_len); 899 900 /* If we were unable to map to a vt100 sequence, just ignore. */ 901 if (!vt100) { 902 continue; 903 } 904 905 /* Prefix with \x033 when the alt key was held. */ 906 if (KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) { 907 handle->tty.rd.last_key[0] = '\033'; 908 prefix_len = 1; 909 } else { 910 prefix_len = 0; 911 } 912 913 /* Copy the vt100 sequence to the handle buffer. */ 914 assert(prefix_len + vt100_len < sizeof handle->tty.rd.last_key); 915 memcpy(&handle->tty.rd.last_key[prefix_len], vt100, vt100_len); 916 917 handle->tty.rd.last_key_len = (unsigned char) (prefix_len + vt100_len); 918 handle->tty.rd.last_key_offset = 0; 919 continue; 920 } 921 } else { 922 /* Copy any bytes left from the last keypress to the user buffer. */ 923 if (handle->tty.rd.last_key_offset < handle->tty.rd.last_key_len) { 924 /* Allocate a buffer if needed */ 925 if (buf_used == 0) { 926 buf = uv_buf_init(NULL, 0); 927 handle->alloc_cb((uv_handle_t*) handle, 1024, &buf); 928 if (buf.base == NULL || buf.len == 0) { 929 handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf); 930 goto out; 931 } 932 assert(buf.base != NULL); 933 } 934 935 buf.base[buf_used++] = handle->tty.rd.last_key[handle->tty.rd.last_key_offset++]; 936 937 /* If the buffer is full, emit it */ 938 if ((size_t) buf_used == buf.len) { 939 handle->read_cb((uv_stream_t*) handle, buf_used, &buf); 940 buf = uv_null_buf_; 941 buf_used = 0; 942 } 943 944 continue; 945 } 946 947 /* Apply dwRepeat from the last input record. */ 948 if (--KEV.wRepeatCount > 0) { 949 handle->tty.rd.last_key_offset = 0; 950 continue; 951 } 952 953 handle->tty.rd.last_key_len = 0; 954 continue; 955 } 956 } 957 958 /* Send the buffer back to the user */ 959 if (buf_used > 0) { 960 handle->read_cb((uv_stream_t*) handle, buf_used, &buf); 961 } 962 963 out: 964 /* Wait for more input events. */ 965 if ((handle->flags & UV_HANDLE_READING) && 966 !(handle->flags & UV_HANDLE_READ_PENDING)) { 967 uv__tty_queue_read(loop, handle); 968 } 969 970 DECREASE_PENDING_REQ_COUNT(handle); 971 972 #undef KEV 973 } 974 975 976 977 void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle, 978 uv_req_t* req) { 979 uv_buf_t buf; 980 981 assert(handle->type == UV_TTY); 982 assert(handle->flags & UV_HANDLE_TTY_READABLE); 983 984 buf = handle->tty.rd.read_line_buffer; 985 986 handle->flags &= ~UV_HANDLE_READ_PENDING; 987 handle->tty.rd.read_line_buffer = uv_null_buf_; 988 989 if (!REQ_SUCCESS(req)) { 990 /* Read was not successful */ 991 if (handle->flags & UV_HANDLE_READING) { 992 /* Real error */ 993 handle->flags &= ~UV_HANDLE_READING; 994 DECREASE_ACTIVE_COUNT(loop, handle); 995 handle->read_cb((uv_stream_t*) handle, 996 uv_translate_sys_error(GET_REQ_ERROR(req)), 997 &buf); 998 } 999 } else { 1000 if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING) && 1001 req->u.io.overlapped.InternalHigh != 0) { 1002 /* Read successful. TODO: read unicode, convert to utf-8 */ 1003 DWORD bytes = req->u.io.overlapped.InternalHigh; 1004 handle->read_cb((uv_stream_t*) handle, bytes, &buf); 1005 } 1006 handle->flags &= ~UV_HANDLE_CANCELLATION_PENDING; 1007 } 1008 1009 /* Wait for more input events. */ 1010 if ((handle->flags & UV_HANDLE_READING) && 1011 !(handle->flags & UV_HANDLE_READ_PENDING)) { 1012 uv__tty_queue_read(loop, handle); 1013 } 1014 1015 DECREASE_PENDING_REQ_COUNT(handle); 1016 } 1017 1018 1019 void uv__process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle, 1020 uv_req_t* req) { 1021 assert(handle->type == UV_TTY); 1022 assert(handle->flags & UV_HANDLE_TTY_READABLE); 1023 1024 /* If the read_line_buffer member is zero, it must have been an raw read. 1025 * Otherwise it was a line-buffered read. FIXME: This is quite obscure. Use a 1026 * flag or something. */ 1027 if (handle->tty.rd.read_line_buffer.len == 0) { 1028 uv_process_tty_read_raw_req(loop, handle, req); 1029 } else { 1030 uv_process_tty_read_line_req(loop, handle, req); 1031 } 1032 } 1033 1034 1035 int uv__tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb, 1036 uv_read_cb read_cb) { 1037 uv_loop_t* loop = handle->loop; 1038 1039 if (!(handle->flags & UV_HANDLE_TTY_READABLE)) { 1040 return ERROR_INVALID_PARAMETER; 1041 } 1042 1043 handle->flags |= UV_HANDLE_READING; 1044 INCREASE_ACTIVE_COUNT(loop, handle); 1045 handle->read_cb = read_cb; 1046 handle->alloc_cb = alloc_cb; 1047 1048 /* If reading was stopped and then started again, there could still be a read 1049 * request pending. */ 1050 if (handle->flags & UV_HANDLE_READ_PENDING) { 1051 return 0; 1052 } 1053 1054 /* Maybe the user stopped reading half-way while processing key events. 1055 * Short-circuit if this could be the case. */ 1056 if (handle->tty.rd.last_key_len > 0) { 1057 SET_REQ_SUCCESS(&handle->read_req); 1058 uv__insert_pending_req(handle->loop, (uv_req_t*) &handle->read_req); 1059 /* Make sure no attempt is made to insert it again until it's handled. */ 1060 handle->flags |= UV_HANDLE_READ_PENDING; 1061 handle->reqs_pending++; 1062 return 0; 1063 } 1064 1065 uv__tty_queue_read(loop, handle); 1066 1067 return 0; 1068 } 1069 1070 1071 int uv__tty_read_stop(uv_tty_t* handle) { 1072 INPUT_RECORD record; 1073 DWORD written, err; 1074 1075 handle->flags &= ~UV_HANDLE_READING; 1076 DECREASE_ACTIVE_COUNT(handle->loop, handle); 1077 1078 if (!(handle->flags & UV_HANDLE_READ_PENDING)) 1079 return 0; 1080 1081 if (uv__is_raw_tty_mode(handle->tty.rd.mode.mode)) { 1082 /* Cancel raw read. Write some bullshit event to force the console wait to 1083 * return. */ 1084 memset(&record, 0, sizeof record); 1085 record.EventType = FOCUS_EVENT; 1086 if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) { 1087 return GetLastError(); 1088 } 1089 } else if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING)) { 1090 /* Cancel line-buffered read if not already pending */ 1091 err = uv__cancel_read_console(handle); 1092 if (err) 1093 return err; 1094 1095 handle->flags |= UV_HANDLE_CANCELLATION_PENDING; 1096 } 1097 1098 return 0; 1099 } 1100 1101 static int uv__cancel_read_console(uv_tty_t* handle) { 1102 HANDLE active_screen_buffer = INVALID_HANDLE_VALUE; 1103 INPUT_RECORD record; 1104 DWORD written; 1105 DWORD err = 0; 1106 LONG status; 1107 1108 assert(!(handle->flags & UV_HANDLE_CANCELLATION_PENDING)); 1109 1110 /* Hold the output lock during the cancellation, to ensure that further 1111 writes don't interfere with the screen state. It will be the ReadConsole 1112 thread's responsibility to release the lock. */ 1113 uv_sem_wait(&uv_tty_output_lock); 1114 status = InterlockedExchange(&uv__read_console_status, TRAP_REQUESTED); 1115 if (status != IN_PROGRESS) { 1116 /* Either we have managed to set a trap for the other thread before 1117 ReadConsole is called, or ReadConsole has returned because the user 1118 has pressed ENTER. In either case, there is nothing else to do. */ 1119 uv_sem_post(&uv_tty_output_lock); 1120 return 0; 1121 } 1122 1123 /* Save screen state before sending the VK_RETURN event */ 1124 active_screen_buffer = CreateFileA("conout$", 1125 GENERIC_READ | GENERIC_WRITE, 1126 FILE_SHARE_READ | FILE_SHARE_WRITE, 1127 NULL, 1128 OPEN_EXISTING, 1129 FILE_ATTRIBUTE_NORMAL, 1130 NULL); 1131 1132 if (active_screen_buffer != INVALID_HANDLE_VALUE && 1133 GetConsoleScreenBufferInfo(active_screen_buffer, 1134 &uv__saved_screen_state)) { 1135 InterlockedOr(&uv__restore_screen_state, 1); 1136 } 1137 1138 /* Write enter key event to force the console wait to return. */ 1139 record.EventType = KEY_EVENT; 1140 record.Event.KeyEvent.bKeyDown = TRUE; 1141 record.Event.KeyEvent.wRepeatCount = 1; 1142 record.Event.KeyEvent.wVirtualKeyCode = VK_RETURN; 1143 record.Event.KeyEvent.wVirtualScanCode = 1144 MapVirtualKeyW(VK_RETURN, MAPVK_VK_TO_VSC); 1145 record.Event.KeyEvent.uChar.UnicodeChar = L'\r'; 1146 record.Event.KeyEvent.dwControlKeyState = 0; 1147 if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) 1148 err = GetLastError(); 1149 1150 if (active_screen_buffer != INVALID_HANDLE_VALUE) 1151 CloseHandle(active_screen_buffer); 1152 1153 return err; 1154 } 1155 1156 1157 static void uv__tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info) { 1158 uv_tty_virtual_width = info->dwSize.X; 1159 uv_tty_virtual_height = info->srWindow.Bottom - info->srWindow.Top + 1; 1160 1161 /* Recompute virtual window offset row. */ 1162 if (uv_tty_virtual_offset == -1) { 1163 uv_tty_virtual_offset = info->dwCursorPosition.Y; 1164 } else if (uv_tty_virtual_offset < info->dwCursorPosition.Y - 1165 uv_tty_virtual_height + 1) { 1166 /* If suddenly find the cursor outside of the virtual window, it must have 1167 * somehow scrolled. Update the virtual window offset. */ 1168 uv_tty_virtual_offset = info->dwCursorPosition.Y - 1169 uv_tty_virtual_height + 1; 1170 } 1171 if (uv_tty_virtual_offset + uv_tty_virtual_height > info->dwSize.Y) { 1172 uv_tty_virtual_offset = info->dwSize.Y - uv_tty_virtual_height; 1173 } 1174 if (uv_tty_virtual_offset < 0) { 1175 uv_tty_virtual_offset = 0; 1176 } 1177 } 1178 1179 1180 static COORD uv__tty_make_real_coord(uv_tty_t* handle, 1181 CONSOLE_SCREEN_BUFFER_INFO* info, int x, unsigned char x_relative, int y, 1182 unsigned char y_relative) { 1183 COORD result; 1184 1185 uv__tty_update_virtual_window(info); 1186 1187 /* Adjust y position */ 1188 if (y_relative) { 1189 y = info->dwCursorPosition.Y + y; 1190 } else { 1191 y = uv_tty_virtual_offset + y; 1192 } 1193 /* Clip y to virtual client rectangle */ 1194 if (y < uv_tty_virtual_offset) { 1195 y = uv_tty_virtual_offset; 1196 } else if (y >= uv_tty_virtual_offset + uv_tty_virtual_height) { 1197 y = uv_tty_virtual_offset + uv_tty_virtual_height - 1; 1198 } 1199 1200 /* Adjust x */ 1201 if (x_relative) { 1202 x = info->dwCursorPosition.X + x; 1203 } 1204 /* Clip x */ 1205 if (x < 0) { 1206 x = 0; 1207 } else if (x >= uv_tty_virtual_width) { 1208 x = uv_tty_virtual_width - 1; 1209 } 1210 1211 result.X = (unsigned short) x; 1212 result.Y = (unsigned short) y; 1213 return result; 1214 } 1215 1216 1217 static int uv__tty_emit_text(uv_tty_t* handle, WCHAR buffer[], DWORD length, 1218 DWORD* error) { 1219 DWORD written; 1220 1221 if (*error != ERROR_SUCCESS) { 1222 return -1; 1223 } 1224 1225 if (!WriteConsoleW(handle->handle, 1226 (void*) buffer, 1227 length, 1228 &written, 1229 NULL)) { 1230 *error = GetLastError(); 1231 return -1; 1232 } 1233 1234 return 0; 1235 } 1236 1237 1238 static int uv__tty_move_caret(uv_tty_t* handle, int x, unsigned char x_relative, 1239 int y, unsigned char y_relative, DWORD* error) { 1240 CONSOLE_SCREEN_BUFFER_INFO info; 1241 COORD pos; 1242 1243 if (*error != ERROR_SUCCESS) { 1244 return -1; 1245 } 1246 1247 retry: 1248 if (!GetConsoleScreenBufferInfo(handle->handle, &info)) { 1249 *error = GetLastError(); 1250 } 1251 1252 pos = uv__tty_make_real_coord(handle, &info, x, x_relative, y, y_relative); 1253 1254 if (!SetConsoleCursorPosition(handle->handle, pos)) { 1255 if (GetLastError() == ERROR_INVALID_PARAMETER) { 1256 /* The console may be resized - retry */ 1257 goto retry; 1258 } else { 1259 *error = GetLastError(); 1260 return -1; 1261 } 1262 } 1263 1264 return 0; 1265 } 1266 1267 1268 static int uv__tty_reset(uv_tty_t* handle, DWORD* error) { 1269 const COORD origin = {0, 0}; 1270 const WORD char_attrs = uv_tty_default_text_attributes; 1271 CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info; 1272 DWORD count, written; 1273 1274 if (*error != ERROR_SUCCESS) { 1275 return -1; 1276 } 1277 1278 /* Reset original text attributes. */ 1279 if (!SetConsoleTextAttribute(handle->handle, char_attrs)) { 1280 *error = GetLastError(); 1281 return -1; 1282 } 1283 1284 /* Move the cursor position to (0, 0). */ 1285 if (!SetConsoleCursorPosition(handle->handle, origin)) { 1286 *error = GetLastError(); 1287 return -1; 1288 } 1289 1290 /* Clear the screen buffer. */ 1291 retry: 1292 if (!GetConsoleScreenBufferInfo(handle->handle, &screen_buffer_info)) { 1293 *error = GetLastError(); 1294 return -1; 1295 } 1296 1297 count = screen_buffer_info.dwSize.X * screen_buffer_info.dwSize.Y; 1298 1299 if (!(FillConsoleOutputCharacterW(handle->handle, 1300 L'\x20', 1301 count, 1302 origin, 1303 &written) && 1304 FillConsoleOutputAttribute(handle->handle, 1305 char_attrs, 1306 written, 1307 origin, 1308 &written))) { 1309 if (GetLastError() == ERROR_INVALID_PARAMETER) { 1310 /* The console may be resized - retry */ 1311 goto retry; 1312 } else { 1313 *error = GetLastError(); 1314 return -1; 1315 } 1316 } 1317 1318 /* Move the virtual window up to the top. */ 1319 uv_tty_virtual_offset = 0; 1320 uv__tty_update_virtual_window(&screen_buffer_info); 1321 1322 /* Reset the cursor size and the cursor state. */ 1323 if (!SetConsoleCursorInfo(handle->handle, &uv_tty_default_cursor_info)) { 1324 *error = GetLastError(); 1325 return -1; 1326 } 1327 1328 return 0; 1329 } 1330 1331 1332 static int uv__tty_clear(uv_tty_t* handle, int dir, char entire_screen, 1333 DWORD* error) { 1334 CONSOLE_SCREEN_BUFFER_INFO info; 1335 COORD start, end; 1336 DWORD count, written; 1337 1338 int x1, x2, y1, y2; 1339 int x1r, x2r, y1r, y2r; 1340 1341 if (*error != ERROR_SUCCESS) { 1342 return -1; 1343 } 1344 1345 if (dir == 0) { 1346 /* Clear from current position */ 1347 x1 = 0; 1348 x1r = 1; 1349 } else { 1350 /* Clear from column 0 */ 1351 x1 = 0; 1352 x1r = 0; 1353 } 1354 1355 if (dir == 1) { 1356 /* Clear to current position */ 1357 x2 = 0; 1358 x2r = 1; 1359 } else { 1360 /* Clear to end of row. We pretend the console is 65536 characters wide, 1361 * uv__tty_make_real_coord will clip it to the actual console width. */ 1362 x2 = 0xffff; 1363 x2r = 0; 1364 } 1365 1366 if (!entire_screen) { 1367 /* Stay on our own row */ 1368 y1 = y2 = 0; 1369 y1r = y2r = 1; 1370 } else { 1371 /* Apply columns direction to row */ 1372 y1 = x1; 1373 y1r = x1r; 1374 y2 = x2; 1375 y2r = x2r; 1376 } 1377 1378 retry: 1379 if (!GetConsoleScreenBufferInfo(handle->handle, &info)) { 1380 *error = GetLastError(); 1381 return -1; 1382 } 1383 1384 start = uv__tty_make_real_coord(handle, &info, x1, x1r, y1, y1r); 1385 end = uv__tty_make_real_coord(handle, &info, x2, x2r, y2, y2r); 1386 count = (end.Y * info.dwSize.X + end.X) - 1387 (start.Y * info.dwSize.X + start.X) + 1; 1388 1389 if (!(FillConsoleOutputCharacterW(handle->handle, 1390 L'\x20', 1391 count, 1392 start, 1393 &written) && 1394 FillConsoleOutputAttribute(handle->handle, 1395 info.wAttributes, 1396 written, 1397 start, 1398 &written))) { 1399 if (GetLastError() == ERROR_INVALID_PARAMETER) { 1400 /* The console may be resized - retry */ 1401 goto retry; 1402 } else { 1403 *error = GetLastError(); 1404 return -1; 1405 } 1406 } 1407 1408 return 0; 1409 } 1410 1411 #define FLIP_FGBG \ 1412 do { \ 1413 WORD fg = info.wAttributes & 0xF; \ 1414 WORD bg = info.wAttributes & 0xF0; \ 1415 info.wAttributes &= 0xFF00; \ 1416 info.wAttributes |= fg << 4; \ 1417 info.wAttributes |= bg >> 4; \ 1418 } while (0) 1419 1420 static int uv__tty_set_style(uv_tty_t* handle, DWORD* error) { 1421 unsigned short argc = handle->tty.wr.ansi_csi_argc; 1422 unsigned short* argv = handle->tty.wr.ansi_csi_argv; 1423 int i; 1424 CONSOLE_SCREEN_BUFFER_INFO info; 1425 1426 char fg_color = -1, bg_color = -1; 1427 char fg_bright = -1, bg_bright = -1; 1428 char inverse = -1; 1429 1430 if (argc == 0) { 1431 /* Reset mode */ 1432 fg_color = uv_tty_default_fg_color; 1433 bg_color = uv_tty_default_bg_color; 1434 fg_bright = uv_tty_default_fg_bright; 1435 bg_bright = uv_tty_default_bg_bright; 1436 inverse = uv_tty_default_inverse; 1437 } 1438 1439 for (i = 0; i < argc; i++) { 1440 short arg = argv[i]; 1441 1442 if (arg == 0) { 1443 /* Reset mode */ 1444 fg_color = uv_tty_default_fg_color; 1445 bg_color = uv_tty_default_bg_color; 1446 fg_bright = uv_tty_default_fg_bright; 1447 bg_bright = uv_tty_default_bg_bright; 1448 inverse = uv_tty_default_inverse; 1449 1450 } else if (arg == 1) { 1451 /* Foreground bright on */ 1452 fg_bright = 1; 1453 1454 } else if (arg == 2) { 1455 /* Both bright off */ 1456 fg_bright = 0; 1457 bg_bright = 0; 1458 1459 } else if (arg == 5) { 1460 /* Background bright on */ 1461 bg_bright = 1; 1462 1463 } else if (arg == 7) { 1464 /* Inverse: on */ 1465 inverse = 1; 1466 1467 } else if (arg == 21 || arg == 22) { 1468 /* Foreground bright off */ 1469 fg_bright = 0; 1470 1471 } else if (arg == 25) { 1472 /* Background bright off */ 1473 bg_bright = 0; 1474 1475 } else if (arg == 27) { 1476 /* Inverse: off */ 1477 inverse = 0; 1478 1479 } else if (arg >= 30 && arg <= 37) { 1480 /* Set foreground color */ 1481 fg_color = arg - 30; 1482 1483 } else if (arg == 39) { 1484 /* Default text color */ 1485 fg_color = uv_tty_default_fg_color; 1486 fg_bright = uv_tty_default_fg_bright; 1487 1488 } else if (arg >= 40 && arg <= 47) { 1489 /* Set background color */ 1490 bg_color = arg - 40; 1491 1492 } else if (arg == 49) { 1493 /* Default background color */ 1494 bg_color = uv_tty_default_bg_color; 1495 bg_bright = uv_tty_default_bg_bright; 1496 1497 } else if (arg >= 90 && arg <= 97) { 1498 /* Set bold foreground color */ 1499 fg_bright = 1; 1500 fg_color = arg - 90; 1501 1502 } else if (arg >= 100 && arg <= 107) { 1503 /* Set bold background color */ 1504 bg_bright = 1; 1505 bg_color = arg - 100; 1506 1507 } 1508 } 1509 1510 if (fg_color == -1 && bg_color == -1 && fg_bright == -1 && 1511 bg_bright == -1 && inverse == -1) { 1512 /* Nothing changed */ 1513 return 0; 1514 } 1515 1516 if (!GetConsoleScreenBufferInfo(handle->handle, &info)) { 1517 *error = GetLastError(); 1518 return -1; 1519 } 1520 1521 if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) { 1522 FLIP_FGBG; 1523 } 1524 1525 if (fg_color != -1) { 1526 info.wAttributes &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); 1527 if (fg_color & 1) info.wAttributes |= FOREGROUND_RED; 1528 if (fg_color & 2) info.wAttributes |= FOREGROUND_GREEN; 1529 if (fg_color & 4) info.wAttributes |= FOREGROUND_BLUE; 1530 } 1531 1532 if (fg_bright != -1) { 1533 if (fg_bright) { 1534 info.wAttributes |= FOREGROUND_INTENSITY; 1535 } else { 1536 info.wAttributes &= ~FOREGROUND_INTENSITY; 1537 } 1538 } 1539 1540 if (bg_color != -1) { 1541 info.wAttributes &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE); 1542 if (bg_color & 1) info.wAttributes |= BACKGROUND_RED; 1543 if (bg_color & 2) info.wAttributes |= BACKGROUND_GREEN; 1544 if (bg_color & 4) info.wAttributes |= BACKGROUND_BLUE; 1545 } 1546 1547 if (bg_bright != -1) { 1548 if (bg_bright) { 1549 info.wAttributes |= BACKGROUND_INTENSITY; 1550 } else { 1551 info.wAttributes &= ~BACKGROUND_INTENSITY; 1552 } 1553 } 1554 1555 if (inverse != -1) { 1556 if (inverse) { 1557 info.wAttributes |= COMMON_LVB_REVERSE_VIDEO; 1558 } else { 1559 info.wAttributes &= ~COMMON_LVB_REVERSE_VIDEO; 1560 } 1561 } 1562 1563 if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) { 1564 FLIP_FGBG; 1565 } 1566 1567 if (!SetConsoleTextAttribute(handle->handle, info.wAttributes)) { 1568 *error = GetLastError(); 1569 return -1; 1570 } 1571 1572 return 0; 1573 } 1574 1575 1576 static int uv__tty_save_state(uv_tty_t* handle, unsigned char save_attributes, 1577 DWORD* error) { 1578 CONSOLE_SCREEN_BUFFER_INFO info; 1579 1580 if (*error != ERROR_SUCCESS) { 1581 return -1; 1582 } 1583 1584 if (!GetConsoleScreenBufferInfo(handle->handle, &info)) { 1585 *error = GetLastError(); 1586 return -1; 1587 } 1588 1589 uv__tty_update_virtual_window(&info); 1590 1591 handle->tty.wr.saved_position.X = info.dwCursorPosition.X; 1592 handle->tty.wr.saved_position.Y = info.dwCursorPosition.Y - 1593 uv_tty_virtual_offset; 1594 handle->flags |= UV_HANDLE_TTY_SAVED_POSITION; 1595 1596 if (save_attributes) { 1597 handle->tty.wr.saved_attributes = info.wAttributes & 1598 (FOREGROUND_INTENSITY | BACKGROUND_INTENSITY); 1599 handle->flags |= UV_HANDLE_TTY_SAVED_ATTRIBUTES; 1600 } 1601 1602 return 0; 1603 } 1604 1605 1606 static int uv__tty_restore_state(uv_tty_t* handle, 1607 unsigned char restore_attributes, DWORD* error) { 1608 CONSOLE_SCREEN_BUFFER_INFO info; 1609 WORD new_attributes; 1610 1611 if (*error != ERROR_SUCCESS) { 1612 return -1; 1613 } 1614 1615 if (handle->flags & UV_HANDLE_TTY_SAVED_POSITION) { 1616 if (uv__tty_move_caret(handle, 1617 handle->tty.wr.saved_position.X, 1618 0, 1619 handle->tty.wr.saved_position.Y, 1620 0, 1621 error) != 0) { 1622 return -1; 1623 } 1624 } 1625 1626 if (restore_attributes && 1627 (handle->flags & UV_HANDLE_TTY_SAVED_ATTRIBUTES)) { 1628 if (!GetConsoleScreenBufferInfo(handle->handle, &info)) { 1629 *error = GetLastError(); 1630 return -1; 1631 } 1632 1633 new_attributes = info.wAttributes; 1634 new_attributes &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY); 1635 new_attributes |= handle->tty.wr.saved_attributes; 1636 1637 if (!SetConsoleTextAttribute(handle->handle, new_attributes)) { 1638 *error = GetLastError(); 1639 return -1; 1640 } 1641 } 1642 1643 return 0; 1644 } 1645 1646 static int uv__tty_set_cursor_visibility(uv_tty_t* handle, 1647 BOOL visible, 1648 DWORD* error) { 1649 CONSOLE_CURSOR_INFO cursor_info; 1650 1651 if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) { 1652 *error = GetLastError(); 1653 return -1; 1654 } 1655 1656 cursor_info.bVisible = visible; 1657 1658 if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) { 1659 *error = GetLastError(); 1660 return -1; 1661 } 1662 1663 return 0; 1664 } 1665 1666 static int uv__tty_set_cursor_shape(uv_tty_t* handle, int style, DWORD* error) { 1667 CONSOLE_CURSOR_INFO cursor_info; 1668 1669 if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) { 1670 *error = GetLastError(); 1671 return -1; 1672 } 1673 1674 if (style == 0) { 1675 cursor_info.dwSize = uv_tty_default_cursor_info.dwSize; 1676 } else if (style <= 2) { 1677 cursor_info.dwSize = CURSOR_SIZE_LARGE; 1678 } else { 1679 cursor_info.dwSize = CURSOR_SIZE_SMALL; 1680 } 1681 1682 if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) { 1683 *error = GetLastError(); 1684 return -1; 1685 } 1686 1687 return 0; 1688 } 1689 1690 1691 static int uv__tty_write_bufs(uv_tty_t* handle, 1692 const uv_buf_t bufs[], 1693 unsigned int nbufs, 1694 DWORD* error) { 1695 /* We can only write 8k characters at a time. Windows can't handle much more 1696 * characters in a single console write anyway. */ 1697 WCHAR utf16_buf[MAX_CONSOLE_CHAR]; 1698 DWORD utf16_buf_used = 0; 1699 unsigned int i; 1700 1701 #define FLUSH_TEXT() \ 1702 do { \ 1703 if (utf16_buf_used > 0) { \ 1704 uv__tty_emit_text(handle, utf16_buf, utf16_buf_used, error); \ 1705 utf16_buf_used = 0; \ 1706 } \ 1707 } while (0) 1708 1709 #define ENSURE_BUFFER_SPACE(wchars_needed) \ 1710 if (wchars_needed > ARRAY_SIZE(utf16_buf) - utf16_buf_used) { \ 1711 FLUSH_TEXT(); \ 1712 } 1713 1714 /* Cache for fast access */ 1715 unsigned char utf8_bytes_left = handle->tty.wr.utf8_bytes_left; 1716 unsigned int utf8_codepoint = handle->tty.wr.utf8_codepoint; 1717 unsigned char previous_eol = handle->tty.wr.previous_eol; 1718 unsigned short ansi_parser_state = handle->tty.wr.ansi_parser_state; 1719 1720 /* Store the error here. If we encounter an error, stop trying to do i/o but 1721 * keep parsing the buffer so we leave the parser in a consistent state. */ 1722 *error = ERROR_SUCCESS; 1723 1724 uv_sem_wait(&uv_tty_output_lock); 1725 1726 for (i = 0; i < nbufs; i++) { 1727 uv_buf_t buf = bufs[i]; 1728 unsigned int j; 1729 1730 for (j = 0; j < buf.len; j++) { 1731 unsigned char c = buf.base[j]; 1732 1733 /* Run the character through the utf8 decoder We happily accept non 1734 * shortest form encodings and invalid code points - there's no real harm 1735 * that can be done. */ 1736 if (utf8_bytes_left == 0) { 1737 /* Read utf-8 start byte */ 1738 DWORD first_zero_bit; 1739 unsigned char not_c = ~c; 1740 #ifdef _MSC_VER /* msvc */ 1741 if (_BitScanReverse(&first_zero_bit, not_c)) { 1742 #else /* assume gcc */ 1743 if (c != 0) { 1744 first_zero_bit = (sizeof(int) * 8) - 1 - __builtin_clz(not_c); 1745 #endif 1746 if (first_zero_bit == 7) { 1747 /* Ascii - pass right through */ 1748 utf8_codepoint = (unsigned int) c; 1749 1750 } else if (first_zero_bit <= 5) { 1751 /* Multibyte sequence */ 1752 utf8_codepoint = (0xff >> (8 - first_zero_bit)) & c; 1753 utf8_bytes_left = (char) (6 - first_zero_bit); 1754 1755 } else { 1756 /* Invalid continuation */ 1757 utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER; 1758 } 1759 1760 } else { 1761 /* 0xff -- invalid */ 1762 utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER; 1763 } 1764 1765 } else if ((c & 0xc0) == 0x80) { 1766 /* Valid continuation of utf-8 multibyte sequence */ 1767 utf8_bytes_left--; 1768 utf8_codepoint <<= 6; 1769 utf8_codepoint |= ((unsigned int) c & 0x3f); 1770 1771 } else { 1772 /* Start byte where continuation was expected. */ 1773 utf8_bytes_left = 0; 1774 utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER; 1775 /* Patch buf offset so this character will be parsed again as a start 1776 * byte. */ 1777 j--; 1778 } 1779 1780 /* Maybe we need to parse more bytes to find a character. */ 1781 if (utf8_bytes_left != 0) { 1782 continue; 1783 } 1784 1785 /* Parse vt100/ansi escape codes */ 1786 if (uv__vterm_state == UV_TTY_SUPPORTED) { 1787 /* Pass through escape codes if conhost supports them. */ 1788 } else if (ansi_parser_state == ANSI_NORMAL) { 1789 switch (utf8_codepoint) { 1790 case '\033': 1791 ansi_parser_state = ANSI_ESCAPE_SEEN; 1792 continue; 1793 1794 case 0233: 1795 ansi_parser_state = ANSI_CSI; 1796 handle->tty.wr.ansi_csi_argc = 0; 1797 continue; 1798 } 1799 1800 } else if (ansi_parser_state == ANSI_ESCAPE_SEEN) { 1801 switch (utf8_codepoint) { 1802 case '[': 1803 ansi_parser_state = ANSI_CSI; 1804 handle->tty.wr.ansi_csi_argc = 0; 1805 continue; 1806 1807 case '^': 1808 case '_': 1809 case 'P': 1810 case ']': 1811 /* Not supported, but we'll have to parse until we see a stop code, 1812 * e. g. ESC \ or BEL. */ 1813 ansi_parser_state = ANSI_ST_CONTROL; 1814 continue; 1815 1816 case '\033': 1817 /* Ignore double escape. */ 1818 continue; 1819 1820 case 'c': 1821 /* Full console reset. */ 1822 FLUSH_TEXT(); 1823 uv__tty_reset(handle, error); 1824 ansi_parser_state = ANSI_NORMAL; 1825 continue; 1826 1827 case '7': 1828 /* Save the cursor position and text attributes. */ 1829 FLUSH_TEXT(); 1830 uv__tty_save_state(handle, 1, error); 1831 ansi_parser_state = ANSI_NORMAL; 1832 continue; 1833 1834 case '8': 1835 /* Restore the cursor position and text attributes */ 1836 FLUSH_TEXT(); 1837 uv__tty_restore_state(handle, 1, error); 1838 ansi_parser_state = ANSI_NORMAL; 1839 continue; 1840 1841 default: 1842 if (utf8_codepoint >= '@' && utf8_codepoint <= '_') { 1843 /* Single-char control. */ 1844 ansi_parser_state = ANSI_NORMAL; 1845 continue; 1846 } else { 1847 /* Invalid - proceed as normal, */ 1848 ansi_parser_state = ANSI_NORMAL; 1849 } 1850 } 1851 1852 } else if (ansi_parser_state == ANSI_IGNORE) { 1853 /* We're ignoring this command. Stop only on command character. */ 1854 if (utf8_codepoint >= '@' && utf8_codepoint <= '~') { 1855 ansi_parser_state = ANSI_NORMAL; 1856 } 1857 continue; 1858 1859 } else if (ansi_parser_state == ANSI_DECSCUSR) { 1860 /* So far we've the sequence `ESC [ arg space`, and we're waiting for 1861 * the final command byte. */ 1862 if (utf8_codepoint >= '@' && utf8_codepoint <= '~') { 1863 /* Command byte */ 1864 if (utf8_codepoint == 'q') { 1865 /* Change the cursor shape */ 1866 int style = handle->tty.wr.ansi_csi_argc 1867 ? handle->tty.wr.ansi_csi_argv[0] : 1; 1868 if (style >= 0 && style <= 6) { 1869 FLUSH_TEXT(); 1870 uv__tty_set_cursor_shape(handle, style, error); 1871 } 1872 } 1873 1874 /* Sequence ended - go back to normal state. */ 1875 ansi_parser_state = ANSI_NORMAL; 1876 continue; 1877 } 1878 /* Unexpected character, but sequence hasn't ended yet. Ignore the rest 1879 * of the sequence. */ 1880 ansi_parser_state = ANSI_IGNORE; 1881 1882 } else if (ansi_parser_state & ANSI_CSI) { 1883 /* So far we've seen `ESC [`, and we may or may not have already parsed 1884 * some of the arguments that follow. */ 1885 1886 if (utf8_codepoint >= '0' && utf8_codepoint <= '9') { 1887 /* Parse a numerical argument. */ 1888 if (!(ansi_parser_state & ANSI_IN_ARG)) { 1889 /* We were not currently parsing a number, add a new one. */ 1890 /* Check for that there are too many arguments. */ 1891 if (handle->tty.wr.ansi_csi_argc >= 1892 ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) { 1893 ansi_parser_state = ANSI_IGNORE; 1894 continue; 1895 } 1896 ansi_parser_state |= ANSI_IN_ARG; 1897 handle->tty.wr.ansi_csi_argc++; 1898 handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] = 1899 (unsigned short) utf8_codepoint - '0'; 1900 continue; 1901 1902 } else { 1903 /* We were already parsing a number. Parse next digit. */ 1904 uint32_t value = 10 * 1905 handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1]; 1906 1907 /* Check for overflow. */ 1908 if (value > UINT16_MAX) { 1909 ansi_parser_state = ANSI_IGNORE; 1910 continue; 1911 } 1912 1913 handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] = 1914 (unsigned short) value + (utf8_codepoint - '0'); 1915 continue; 1916 } 1917 1918 } else if (utf8_codepoint == ';') { 1919 /* Denotes the end of an argument. */ 1920 if (ansi_parser_state & ANSI_IN_ARG) { 1921 ansi_parser_state &= ~ANSI_IN_ARG; 1922 continue; 1923 1924 } else { 1925 /* If ANSI_IN_ARG is not set, add another argument and default 1926 * it to 0. */ 1927 1928 /* Check for too many arguments */ 1929 if (handle->tty.wr.ansi_csi_argc >= 1930 1931 ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) { 1932 ansi_parser_state = ANSI_IGNORE; 1933 continue; 1934 } 1935 1936 handle->tty.wr.ansi_csi_argc++; 1937 handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] = 0; 1938 continue; 1939 } 1940 1941 } else if (utf8_codepoint == '?' && 1942 !(ansi_parser_state & ANSI_IN_ARG) && 1943 !(ansi_parser_state & ANSI_EXTENSION) && 1944 handle->tty.wr.ansi_csi_argc == 0) { 1945 /* Pass through '?' if it is the first character after CSI */ 1946 /* This is an extension character from the VT100 codeset */ 1947 /* that is supported and used by most ANSI terminals today. */ 1948 ansi_parser_state |= ANSI_EXTENSION; 1949 continue; 1950 1951 } else if (utf8_codepoint == ' ' && 1952 !(ansi_parser_state & ANSI_EXTENSION)) { 1953 /* We expect a command byte to follow after this space. The only 1954 * command that we current support is 'set cursor style'. */ 1955 ansi_parser_state = ANSI_DECSCUSR; 1956 continue; 1957 1958 } else if (utf8_codepoint >= '@' && utf8_codepoint <= '~') { 1959 /* Command byte */ 1960 if (ansi_parser_state & ANSI_EXTENSION) { 1961 /* Sequence is `ESC [ ? args command`. */ 1962 switch (utf8_codepoint) { 1963 case 'l': 1964 /* Hide the cursor */ 1965 if (handle->tty.wr.ansi_csi_argc == 1 && 1966 handle->tty.wr.ansi_csi_argv[0] == 25) { 1967 FLUSH_TEXT(); 1968 uv__tty_set_cursor_visibility(handle, 0, error); 1969 } 1970 break; 1971 1972 case 'h': 1973 /* Show the cursor */ 1974 if (handle->tty.wr.ansi_csi_argc == 1 && 1975 handle->tty.wr.ansi_csi_argv[0] == 25) { 1976 FLUSH_TEXT(); 1977 uv__tty_set_cursor_visibility(handle, 1, error); 1978 } 1979 break; 1980 } 1981 1982 } else { 1983 /* Sequence is `ESC [ args command`. */ 1984 int x, y, d; 1985 switch (utf8_codepoint) { 1986 case 'A': 1987 /* cursor up */ 1988 FLUSH_TEXT(); 1989 y = -(handle->tty.wr.ansi_csi_argc 1990 ? handle->tty.wr.ansi_csi_argv[0] : 1); 1991 uv__tty_move_caret(handle, 0, 1, y, 1, error); 1992 break; 1993 1994 case 'B': 1995 /* cursor down */ 1996 FLUSH_TEXT(); 1997 y = handle->tty.wr.ansi_csi_argc 1998 ? handle->tty.wr.ansi_csi_argv[0] : 1; 1999 uv__tty_move_caret(handle, 0, 1, y, 1, error); 2000 break; 2001 2002 case 'C': 2003 /* cursor forward */ 2004 FLUSH_TEXT(); 2005 x = handle->tty.wr.ansi_csi_argc 2006 ? handle->tty.wr.ansi_csi_argv[0] : 1; 2007 uv__tty_move_caret(handle, x, 1, 0, 1, error); 2008 break; 2009 2010 case 'D': 2011 /* cursor back */ 2012 FLUSH_TEXT(); 2013 x = -(handle->tty.wr.ansi_csi_argc 2014 ? handle->tty.wr.ansi_csi_argv[0] : 1); 2015 uv__tty_move_caret(handle, x, 1, 0, 1, error); 2016 break; 2017 2018 case 'E': 2019 /* cursor next line */ 2020 FLUSH_TEXT(); 2021 y = handle->tty.wr.ansi_csi_argc 2022 ? handle->tty.wr.ansi_csi_argv[0] : 1; 2023 uv__tty_move_caret(handle, 0, 0, y, 1, error); 2024 break; 2025 2026 case 'F': 2027 /* cursor previous line */ 2028 FLUSH_TEXT(); 2029 y = -(handle->tty.wr.ansi_csi_argc 2030 ? handle->tty.wr.ansi_csi_argv[0] : 1); 2031 uv__tty_move_caret(handle, 0, 0, y, 1, error); 2032 break; 2033 2034 case 'G': 2035 /* cursor horizontal move absolute */ 2036 FLUSH_TEXT(); 2037 x = (handle->tty.wr.ansi_csi_argc >= 1 && 2038 handle->tty.wr.ansi_csi_argv[0]) 2039 ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0; 2040 uv__tty_move_caret(handle, x, 0, 0, 1, error); 2041 break; 2042 2043 case 'H': 2044 case 'f': 2045 /* cursor move absolute */ 2046 FLUSH_TEXT(); 2047 y = (handle->tty.wr.ansi_csi_argc >= 1 && 2048 handle->tty.wr.ansi_csi_argv[0]) 2049 ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0; 2050 x = (handle->tty.wr.ansi_csi_argc >= 2 && 2051 handle->tty.wr.ansi_csi_argv[1]) 2052 ? handle->tty.wr.ansi_csi_argv[1] - 1 : 0; 2053 uv__tty_move_caret(handle, x, 0, y, 0, error); 2054 break; 2055 2056 case 'J': 2057 /* Erase screen */ 2058 FLUSH_TEXT(); 2059 d = handle->tty.wr.ansi_csi_argc 2060 ? handle->tty.wr.ansi_csi_argv[0] : 0; 2061 if (d >= 0 && d <= 2) { 2062 uv__tty_clear(handle, d, 1, error); 2063 } 2064 break; 2065 2066 case 'K': 2067 /* Erase line */ 2068 FLUSH_TEXT(); 2069 d = handle->tty.wr.ansi_csi_argc 2070 ? handle->tty.wr.ansi_csi_argv[0] : 0; 2071 if (d >= 0 && d <= 2) { 2072 uv__tty_clear(handle, d, 0, error); 2073 } 2074 break; 2075 2076 case 'm': 2077 /* Set style */ 2078 FLUSH_TEXT(); 2079 uv__tty_set_style(handle, error); 2080 break; 2081 2082 case 's': 2083 /* Save the cursor position. */ 2084 FLUSH_TEXT(); 2085 uv__tty_save_state(handle, 0, error); 2086 break; 2087 2088 case 'u': 2089 /* Restore the cursor position */ 2090 FLUSH_TEXT(); 2091 uv__tty_restore_state(handle, 0, error); 2092 break; 2093 } 2094 } 2095 2096 /* Sequence ended - go back to normal state. */ 2097 ansi_parser_state = ANSI_NORMAL; 2098 continue; 2099 2100 } else { 2101 /* We don't support commands that use private mode characters or 2102 * intermediaries. Ignore the rest of the sequence. */ 2103 ansi_parser_state = ANSI_IGNORE; 2104 continue; 2105 } 2106 2107 } else if (ansi_parser_state & ANSI_ST_CONTROL) { 2108 /* Unsupported control code. 2109 * Ignore everything until we see `BEL` or `ESC \`. */ 2110 if (ansi_parser_state & ANSI_IN_STRING) { 2111 if (!(ansi_parser_state & ANSI_BACKSLASH_SEEN)) { 2112 if (utf8_codepoint == '"') { 2113 ansi_parser_state &= ~ANSI_IN_STRING; 2114 } else if (utf8_codepoint == '\\') { 2115 ansi_parser_state |= ANSI_BACKSLASH_SEEN; 2116 } 2117 } else { 2118 ansi_parser_state &= ~ANSI_BACKSLASH_SEEN; 2119 } 2120 } else { 2121 if (utf8_codepoint == '\007' || (utf8_codepoint == '\\' && 2122 (ansi_parser_state & ANSI_ESCAPE_SEEN))) { 2123 /* End of sequence */ 2124 ansi_parser_state = ANSI_NORMAL; 2125 } else if (utf8_codepoint == '\033') { 2126 /* Escape character */ 2127 ansi_parser_state |= ANSI_ESCAPE_SEEN; 2128 } else if (utf8_codepoint == '"') { 2129 /* String starting */ 2130 ansi_parser_state |= ANSI_IN_STRING; 2131 ansi_parser_state &= ~ANSI_ESCAPE_SEEN; 2132 ansi_parser_state &= ~ANSI_BACKSLASH_SEEN; 2133 } else { 2134 ansi_parser_state &= ~ANSI_ESCAPE_SEEN; 2135 } 2136 } 2137 continue; 2138 } else { 2139 /* Inconsistent state */ 2140 abort(); 2141 } 2142 2143 if (utf8_codepoint == 0x0a || utf8_codepoint == 0x0d) { 2144 /* EOL conversion - emit \r\n when we see \n. */ 2145 2146 if (utf8_codepoint == 0x0a && previous_eol != 0x0d) { 2147 /* \n was not preceded by \r; print \r\n. */ 2148 ENSURE_BUFFER_SPACE(2); 2149 utf16_buf[utf16_buf_used++] = L'\r'; 2150 utf16_buf[utf16_buf_used++] = L'\n'; 2151 } else if (utf8_codepoint == 0x0d && previous_eol == 0x0a) { 2152 /* \n was followed by \r; do not print the \r, since the source was 2153 * either \r\n\r (so the second \r is redundant) or was \n\r (so the 2154 * \n was processed by the last case and an \r automatically 2155 * inserted). */ 2156 } else { 2157 /* \r without \n; print \r as-is. */ 2158 ENSURE_BUFFER_SPACE(1); 2159 utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint; 2160 } 2161 2162 previous_eol = (char) utf8_codepoint; 2163 2164 } else if (utf8_codepoint <= 0xffff) { 2165 /* Encode character into utf-16 buffer. */ 2166 ENSURE_BUFFER_SPACE(1); 2167 utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint; 2168 previous_eol = 0; 2169 } else { 2170 ENSURE_BUFFER_SPACE(2); 2171 utf8_codepoint -= 0x10000; 2172 utf16_buf[utf16_buf_used++] = (WCHAR) (utf8_codepoint / 0x400 + 0xD800); 2173 utf16_buf[utf16_buf_used++] = (WCHAR) (utf8_codepoint % 0x400 + 0xDC00); 2174 previous_eol = 0; 2175 } 2176 } 2177 } 2178 2179 /* Flush remaining characters */ 2180 FLUSH_TEXT(); 2181 2182 /* Copy cached values back to struct. */ 2183 handle->tty.wr.utf8_bytes_left = utf8_bytes_left; 2184 handle->tty.wr.utf8_codepoint = utf8_codepoint; 2185 handle->tty.wr.previous_eol = previous_eol; 2186 handle->tty.wr.ansi_parser_state = ansi_parser_state; 2187 2188 uv_sem_post(&uv_tty_output_lock); 2189 2190 if (*error == STATUS_SUCCESS) { 2191 return 0; 2192 } else { 2193 return -1; 2194 } 2195 2196 #undef FLUSH_TEXT 2197 } 2198 2199 2200 int uv__tty_write(uv_loop_t* loop, 2201 uv_write_t* req, 2202 uv_tty_t* handle, 2203 const uv_buf_t bufs[], 2204 unsigned int nbufs, 2205 uv_write_cb cb) { 2206 DWORD error; 2207 2208 UV_REQ_INIT(req, UV_WRITE); 2209 req->handle = (uv_stream_t*) handle; 2210 req->cb = cb; 2211 2212 handle->reqs_pending++; 2213 handle->stream.conn.write_reqs_pending++; 2214 REGISTER_HANDLE_REQ(loop, handle); 2215 2216 req->u.io.queued_bytes = 0; 2217 2218 if (!uv__tty_write_bufs(handle, bufs, nbufs, &error)) { 2219 SET_REQ_SUCCESS(req); 2220 } else { 2221 SET_REQ_ERROR(req, error); 2222 } 2223 2224 uv__insert_pending_req(loop, (uv_req_t*) req); 2225 2226 return 0; 2227 } 2228 2229 2230 int uv__tty_try_write(uv_tty_t* handle, 2231 const uv_buf_t bufs[], 2232 unsigned int nbufs) { 2233 DWORD error; 2234 2235 if (handle->stream.conn.write_reqs_pending > 0) 2236 return UV_EAGAIN; 2237 2238 if (uv__tty_write_bufs(handle, bufs, nbufs, &error)) 2239 return uv_translate_sys_error(error); 2240 2241 return uv__count_bufs(bufs, nbufs); 2242 } 2243 2244 2245 void uv__process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle, 2246 uv_write_t* req) { 2247 int err; 2248 2249 handle->write_queue_size -= req->u.io.queued_bytes; 2250 UNREGISTER_HANDLE_REQ(loop, handle); 2251 2252 if (req->cb) { 2253 err = GET_REQ_ERROR(req); 2254 req->cb(req, uv_translate_sys_error(err)); 2255 } 2256 2257 2258 handle->stream.conn.write_reqs_pending--; 2259 if (handle->stream.conn.write_reqs_pending == 0 && 2260 uv__is_stream_shutting(handle)) 2261 uv__process_tty_shutdown_req(loop, 2262 handle, 2263 handle->stream.conn.shutdown_req); 2264 2265 DECREASE_PENDING_REQ_COUNT(handle); 2266 } 2267 2268 2269 void uv__tty_close(uv_tty_t* handle) { 2270 assert(handle->u.fd == -1 || handle->u.fd > 2); 2271 if (handle->flags & UV_HANDLE_READING) 2272 uv__tty_read_stop(handle); 2273 2274 if (handle->u.fd == -1) 2275 CloseHandle(handle->handle); 2276 else 2277 _close(handle->u.fd); 2278 2279 handle->u.fd = -1; 2280 handle->handle = INVALID_HANDLE_VALUE; 2281 handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE); 2282 uv__handle_closing(handle); 2283 2284 if (handle->reqs_pending == 0) 2285 uv__want_endgame(handle->loop, (uv_handle_t*) handle); 2286 } 2287 2288 2289 void uv__process_tty_shutdown_req(uv_loop_t* loop, uv_tty_t* stream, uv_shutdown_t* req) { 2290 assert(stream->stream.conn.write_reqs_pending == 0); 2291 assert(req); 2292 2293 stream->stream.conn.shutdown_req = NULL; 2294 UNREGISTER_HANDLE_REQ(loop, stream); 2295 2296 /* TTY shutdown is really just a no-op */ 2297 if (req->cb) { 2298 if (stream->flags & UV_HANDLE_CLOSING) { 2299 req->cb(req, UV_ECANCELED); 2300 } else { 2301 req->cb(req, 0); 2302 } 2303 } 2304 2305 DECREASE_PENDING_REQ_COUNT(stream); 2306 } 2307 2308 2309 void uv__tty_endgame(uv_loop_t* loop, uv_tty_t* handle) { 2310 assert(handle->flags & UV_HANDLE_CLOSING); 2311 assert(handle->reqs_pending == 0); 2312 2313 /* The wait handle used for raw reading should be unregistered when the 2314 * wait callback runs. */ 2315 assert(!(handle->flags & UV_HANDLE_TTY_READABLE) || 2316 handle->tty.rd.read_raw_wait == NULL); 2317 2318 assert(!(handle->flags & UV_HANDLE_CLOSED)); 2319 uv__handle_close(handle); 2320 } 2321 2322 2323 int uv_tty_reset_mode(void) { 2324 /** 2325 * Shells on Windows do know to reset output flags after a program exits, 2326 * but not necessarily input flags, so we do that for them. 2327 */ 2328 if ( 2329 uv__tty_console_handle_in != INVALID_HANDLE_VALUE && 2330 uv__tty_console_in_original_mode != (DWORD)-1 && 2331 InterlockedExchange(&uv__tty_console_in_need_mode_reset, 0) != 0 2332 ) { 2333 SetConsoleMode(uv__tty_console_handle_in, uv__tty_console_in_original_mode); 2334 } 2335 return 0; 2336 } 2337 2338 /* Determine whether or not this version of windows supports 2339 * proper ANSI color codes. Should be supported as of windows 2340 * 10 version 1511, build number 10.0.10586. 2341 */ 2342 static void uv__determine_vterm_state(HANDLE handle) { 2343 DWORD dwMode = 0; 2344 2345 uv__need_check_vterm_state = FALSE; 2346 if (!GetConsoleMode(handle, &dwMode)) { 2347 return; 2348 } 2349 2350 dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING; 2351 if (!SetConsoleMode(handle, dwMode)) { 2352 return; 2353 } 2354 2355 uv__vterm_state = UV_TTY_SUPPORTED; 2356 } 2357 2358 static DWORD WINAPI uv__tty_console_resize_message_loop_thread(void* param) { 2359 NTSTATUS status; 2360 ULONG_PTR conhost_pid; 2361 MSG msg; 2362 2363 if (pSetWinEventHook == NULL || pNtQueryInformationProcess == NULL) 2364 return 0; 2365 2366 status = pNtQueryInformationProcess(GetCurrentProcess(), 2367 ProcessConsoleHostProcess, 2368 &conhost_pid, 2369 sizeof(conhost_pid), 2370 NULL); 2371 2372 if (!NT_SUCCESS(status)) { 2373 /* We couldn't retrieve our console host process, probably because this 2374 * is a 32-bit process running on 64-bit Windows. Fall back to receiving 2375 * console events from the input stream only. */ 2376 return 0; 2377 } 2378 2379 /* Ensure the PID is a multiple of 4, which is required by SetWinEventHook */ 2380 conhost_pid &= ~(ULONG_PTR)0x3; 2381 2382 uv__tty_console_resized = CreateEvent(NULL, TRUE, FALSE, NULL); 2383 if (uv__tty_console_resized == NULL) 2384 return 0; 2385 if (QueueUserWorkItem(uv__tty_console_resize_watcher_thread, 2386 NULL, 2387 WT_EXECUTELONGFUNCTION) == 0) 2388 return 0; 2389 2390 if (!pSetWinEventHook(EVENT_CONSOLE_LAYOUT, 2391 EVENT_CONSOLE_LAYOUT, 2392 NULL, 2393 uv__tty_console_resize_event, 2394 (DWORD)conhost_pid, 2395 0, 2396 WINEVENT_OUTOFCONTEXT)) 2397 return 0; 2398 2399 while (GetMessage(&msg, NULL, 0, 0)) { 2400 TranslateMessage(&msg); 2401 DispatchMessage(&msg); 2402 } 2403 return 0; 2404 } 2405 2406 static void CALLBACK uv__tty_console_resize_event(HWINEVENTHOOK hWinEventHook, 2407 DWORD event, 2408 HWND hwnd, 2409 LONG idObject, 2410 LONG idChild, 2411 DWORD dwEventThread, 2412 DWORD dwmsEventTime) { 2413 SetEvent(uv__tty_console_resized); 2414 } 2415 2416 static DWORD WINAPI uv__tty_console_resize_watcher_thread(void* param) { 2417 for (;;) { 2418 /* Make sure to not overwhelm the system with resize events */ 2419 Sleep(33); 2420 WaitForSingleObject(uv__tty_console_resized, INFINITE); 2421 ResetEvent(uv__tty_console_resized); 2422 uv__tty_console_signal_resize(); 2423 } 2424 return 0; 2425 } 2426 2427 static void uv__tty_console_signal_resize(void) { 2428 CONSOLE_SCREEN_BUFFER_INFO sb_info; 2429 int width, height; 2430 2431 if (!GetConsoleScreenBufferInfo(uv__tty_console_handle_out, &sb_info)) 2432 return; 2433 2434 width = sb_info.dwSize.X; 2435 height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1; 2436 2437 uv_mutex_lock(&uv__tty_console_resize_mutex); 2438 if (width != uv__tty_console_width || height != uv__tty_console_height) { 2439 uv__tty_console_width = width; 2440 uv__tty_console_height = height; 2441 uv_mutex_unlock(&uv__tty_console_resize_mutex); 2442 uv__signal_dispatch(SIGWINCH); 2443 } else { 2444 uv_mutex_unlock(&uv__tty_console_resize_mutex); 2445 } 2446 } 2447 2448 void uv_tty_set_vterm_state(uv_tty_vtermstate_t state) { 2449 uv_sem_wait(&uv_tty_output_lock); 2450 uv__need_check_vterm_state = FALSE; 2451 uv__vterm_state = state; 2452 uv_sem_post(&uv_tty_output_lock); 2453 } 2454 2455 int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state) { 2456 uv_sem_wait(&uv_tty_output_lock); 2457 *state = uv__vterm_state; 2458 uv_sem_post(&uv_tty_output_lock); 2459 return 0; 2460 } 2461
Indexes created Tue Feb 24 08:35:24 UTC 2026