1/* Copyright libuv project 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#ifdef _WIN32
23
24#include "uv.h"
25#include "task.h"
26
27#include <errno.h>
28#include <io.h>
29#include <string.h>
30#include <windows.h>
31
32#define ESC "\x1b"
33#define EUR_UTF8 "\xe2\x82\xac"
34#define EUR_UNICODE 0x20AC
35
36
37const char* expect_str = NULL;
38ssize_t expect_nread = 0;
39
40static void dump_str(const char* str, ssize_t len) {
41  ssize_t i;
42  for (i = 0; i < len; i++) {
43    fprintf(stderr, "%#02x ", *(str + i));
44  }
45}
46
47static void print_err_msg(const char* expect, ssize_t expect_len,
48                          const char* found, ssize_t found_len) {
49  fprintf(stderr, "expect ");
50  dump_str(expect, expect_len);
51  fprintf(stderr, ", but found ");
52  dump_str(found, found_len);
53  fprintf(stderr, "\n");
54}
55
56static void tty_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
57  buf->base = malloc(size);
58  ASSERT_NOT_NULL(buf->base);
59  buf->len = size;
60}
61
62static void tty_read(uv_stream_t* tty_in, ssize_t nread, const uv_buf_t* buf) {
63  if (nread > 0) {
64    if (nread != expect_nread) {
65      fprintf(stderr, "expected nread %ld, but found %ld\n",
66              (long)expect_nread, (long)nread);
67      print_err_msg(expect_str, expect_nread, buf->base, nread);
68      ASSERT(FALSE);
69    }
70    if (strncmp(buf->base, expect_str, nread) != 0) {
71      print_err_msg(expect_str, expect_nread, buf->base, nread);
72      ASSERT(FALSE);
73    }
74    uv_close((uv_handle_t*) tty_in, NULL);
75  } else {
76    ASSERT(nread == 0);
77  }
78}
79
80static void make_key_event_records(WORD virt_key, DWORD ctr_key_state,
81                                   BOOL is_wsl, INPUT_RECORD* records) {
82# define KEV(I) records[(I)].Event.KeyEvent
83  BYTE kb_state[256] = {0};
84  WCHAR buf[2];
85  int ret;
86
87  records[0].EventType = records[1].EventType = KEY_EVENT;
88  KEV(0).bKeyDown = TRUE;
89  KEV(1).bKeyDown = FALSE;
90  KEV(0).wVirtualKeyCode = KEV(1).wVirtualKeyCode = virt_key;
91  KEV(0).wRepeatCount = KEV(1).wRepeatCount = 1;
92  KEV(0).wVirtualScanCode = KEV(1).wVirtualScanCode =
93    MapVirtualKeyW(virt_key, MAPVK_VK_TO_VSC);
94  KEV(0).dwControlKeyState = KEV(1).dwControlKeyState = ctr_key_state;
95  if (ctr_key_state & LEFT_ALT_PRESSED) {
96    kb_state[VK_LMENU] = 0x01;
97  }
98  if (ctr_key_state & RIGHT_ALT_PRESSED) {
99    kb_state[VK_RMENU] = 0x01;
100  }
101  if (ctr_key_state & LEFT_CTRL_PRESSED) {
102    kb_state[VK_LCONTROL] = 0x01;
103  }
104  if (ctr_key_state & RIGHT_CTRL_PRESSED) {
105    kb_state[VK_RCONTROL] = 0x01;
106  }
107  if (ctr_key_state & SHIFT_PRESSED) {
108    kb_state[VK_SHIFT] = 0x01;
109  }
110  ret = ToUnicode(virt_key, KEV(0).wVirtualScanCode, kb_state, buf, 2, 0);
111  if (ret == 1) {
112    if(!is_wsl &&
113        ((ctr_key_state & LEFT_ALT_PRESSED) ||
114         (ctr_key_state & RIGHT_ALT_PRESSED))) {
115      /*
116       * If ALT key is pressed, the UnicodeChar value of the keyup event is
117       * set to 0 on nomal console. Emulate this behavior.
118       * See https://github.com/Microsoft/console/issues/320
119       */
120      KEV(0).uChar.UnicodeChar = buf[0];
121      KEV(1).uChar.UnicodeChar = 0;
122    } else{
123      /*
124       * In WSL UnicodeChar is normally set. This behavior cause #2111.
125       */
126      KEV(0).uChar.UnicodeChar = KEV(1).uChar.UnicodeChar = buf[0];
127    }
128  } else {
129    KEV(0).uChar.UnicodeChar = KEV(1).uChar.UnicodeChar = 0;
130  }
131# undef KEV
132}
133
134TEST_IMPL(tty_duplicate_vt100_fn_key) {
135  int r;
136  int ttyin_fd;
137  uv_tty_t tty_in;
138  uv_loop_t* loop;
139  HANDLE handle;
140  INPUT_RECORD records[2];
141  DWORD written;
142
143  loop = uv_default_loop();
144
145  /* Make sure we have an FD that refers to a tty */
146  handle = CreateFileA("conin$",
147                       GENERIC_READ | GENERIC_WRITE,
148                       FILE_SHARE_READ | FILE_SHARE_WRITE,
149                       NULL,
150                       OPEN_EXISTING,
151                       FILE_ATTRIBUTE_NORMAL,
152                       NULL);
153  ASSERT(handle != INVALID_HANDLE_VALUE);
154  ttyin_fd = _open_osfhandle((intptr_t) handle, 0);
155  ASSERT(ttyin_fd >= 0);
156  ASSERT(UV_TTY == uv_guess_handle(ttyin_fd));
157
158  r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1);  /* Readable. */
159  ASSERT(r == 0);
160  ASSERT(uv_is_readable((uv_stream_t*) &tty_in));
161  ASSERT(!uv_is_writable((uv_stream_t*) &tty_in));
162
163  r = uv_read_start((uv_stream_t*)&tty_in, tty_alloc, tty_read);
164  ASSERT(r == 0);
165
166  expect_str = ESC"[[A";
167  expect_nread = strlen(expect_str);
168
169  /* Turn on raw mode. */
170  r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW);
171  ASSERT(r == 0);
172
173  /*
174   * Send F1 keystrokes. Test of issue cause by #2114 that vt100 fn key
175   * duplicate.
176   */
177  make_key_event_records(VK_F1, 0, TRUE, records);
178  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
179  ASSERT(written == ARRAY_SIZE(records));
180
181  uv_run(loop, UV_RUN_DEFAULT);
182
183  MAKE_VALGRIND_HAPPY();
184  return 0;
185}
186
187TEST_IMPL(tty_duplicate_alt_modifier_key) {
188  int r;
189  int ttyin_fd;
190  uv_tty_t tty_in;
191  uv_loop_t* loop;
192  HANDLE handle;
193  INPUT_RECORD records[2];
194  INPUT_RECORD alt_records[2];
195  DWORD written;
196
197  loop = uv_default_loop();
198
199  /* Make sure we have an FD that refers to a tty */
200  handle = CreateFileA("conin$",
201                       GENERIC_READ | GENERIC_WRITE,
202                       FILE_SHARE_READ | FILE_SHARE_WRITE,
203                       NULL,
204                       OPEN_EXISTING,
205                       FILE_ATTRIBUTE_NORMAL,
206                       NULL);
207  ASSERT(handle != INVALID_HANDLE_VALUE);
208  ttyin_fd = _open_osfhandle((intptr_t) handle, 0);
209  ASSERT(ttyin_fd >= 0);
210  ASSERT(UV_TTY == uv_guess_handle(ttyin_fd));
211
212  r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1);  /* Readable. */
213  ASSERT(r == 0);
214  ASSERT(uv_is_readable((uv_stream_t*) &tty_in));
215  ASSERT(!uv_is_writable((uv_stream_t*) &tty_in));
216
217  r = uv_read_start((uv_stream_t*)&tty_in, tty_alloc, tty_read);
218  ASSERT(r == 0);
219
220  expect_str = ESC"a"ESC"a";
221  expect_nread = strlen(expect_str);
222
223  /* Turn on raw mode. */
224  r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW);
225  ASSERT(r == 0);
226
227  /* Emulate transmission of M-a at normal console */
228  make_key_event_records(VK_MENU, 0, TRUE, alt_records);
229  WriteConsoleInputW(handle, &alt_records[0], 1, &written);
230  ASSERT(written == 1);
231  make_key_event_records(L'A', LEFT_ALT_PRESSED, FALSE, records);
232  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
233  ASSERT(written == 2);
234  WriteConsoleInputW(handle, &alt_records[1], 1, &written);
235  ASSERT(written == 1);
236
237  /* Emulate transmission of M-a at WSL(#2111) */
238  make_key_event_records(VK_MENU, 0, TRUE, alt_records);
239  WriteConsoleInputW(handle, &alt_records[0], 1, &written);
240  ASSERT(written == 1);
241  make_key_event_records(L'A', LEFT_ALT_PRESSED, TRUE, records);
242  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
243  ASSERT(written == 2);
244  WriteConsoleInputW(handle, &alt_records[1], 1, &written);
245  ASSERT(written == 1);
246
247  uv_run(loop, UV_RUN_DEFAULT);
248
249  MAKE_VALGRIND_HAPPY();
250  return 0;
251}
252
253TEST_IMPL(tty_composing_character) {
254  int r;
255  int ttyin_fd;
256  uv_tty_t tty_in;
257  uv_loop_t* loop;
258  HANDLE handle;
259  INPUT_RECORD records[2];
260  INPUT_RECORD alt_records[2];
261  DWORD written;
262
263  loop = uv_default_loop();
264
265  /* Make sure we have an FD that refers to a tty */
266  handle = CreateFileA("conin$",
267                       GENERIC_READ | GENERIC_WRITE,
268                       FILE_SHARE_READ | FILE_SHARE_WRITE,
269                       NULL,
270                       OPEN_EXISTING,
271                       FILE_ATTRIBUTE_NORMAL,
272                       NULL);
273  ASSERT(handle != INVALID_HANDLE_VALUE);
274  ttyin_fd = _open_osfhandle((intptr_t) handle, 0);
275  ASSERT(ttyin_fd >= 0);
276  ASSERT(UV_TTY == uv_guess_handle(ttyin_fd));
277
278  r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1);  /* Readable. */
279  ASSERT(r == 0);
280  ASSERT(uv_is_readable((uv_stream_t*) &tty_in));
281  ASSERT(!uv_is_writable((uv_stream_t*) &tty_in));
282
283  r = uv_read_start((uv_stream_t*)&tty_in, tty_alloc, tty_read);
284  ASSERT(r == 0);
285
286  expect_str = EUR_UTF8;
287  expect_nread = strlen(expect_str);
288
289  /* Turn on raw mode. */
290  r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW);
291  ASSERT(r == 0);
292
293  /* Emulate EUR inputs by LEFT ALT+NUMPAD ASCII KeyComos */
294  make_key_event_records(VK_MENU, 0, FALSE, alt_records);
295  alt_records[1].Event.KeyEvent.uChar.UnicodeChar = EUR_UNICODE;
296  WriteConsoleInputW(handle, &alt_records[0], 1, &written);
297  make_key_event_records(VK_NUMPAD0, LEFT_ALT_PRESSED, FALSE, records);
298  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
299  ASSERT(written == ARRAY_SIZE(records));
300  make_key_event_records(VK_NUMPAD1, LEFT_ALT_PRESSED, FALSE, records);
301  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
302  ASSERT(written == ARRAY_SIZE(records));
303  make_key_event_records(VK_NUMPAD2, LEFT_ALT_PRESSED, FALSE, records);
304  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
305  ASSERT(written == ARRAY_SIZE(records));
306  make_key_event_records(VK_NUMPAD8, LEFT_ALT_PRESSED, FALSE, records);
307  WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written);
308  ASSERT(written == ARRAY_SIZE(records));
309  WriteConsoleInputW(handle, &alt_records[1], 1, &written);
310
311  uv_run(loop, UV_RUN_DEFAULT);
312
313  MAKE_VALGRIND_HAPPY();
314  return 0;
315}
316
317#else
318
319typedef int file_has_no_tests;  /* ISO C forbids an empty translation unit. */
320
321#endif  /* ifndef _WIN32 */
322