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 "uv.h" 23 #include "task.h" 24 25 #ifdef _WIN32 26 # include <io.h> 27 # include <windows.h> 28 #else /* Unix */ 29 # include <fcntl.h> 30 # include <unistd.h> 31 # if defined(__linux__) && !defined(__ANDROID__) 32 # include <pty.h> 33 # elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) 34 # include <util.h> 35 # elif defined(__FreeBSD__) || defined(__DragonFly__) 36 # include <libutil.h> 37 # endif 38 #endif 39 40 #include <string.h> 41 #include <errno.h> 42 43 44 TEST_IMPL(tty) { 45 int r, width, height; 46 int ttyin_fd, ttyout_fd; 47 uv_tty_t tty_in, tty_out; 48 uv_loop_t* loop = uv_default_loop(); 49 50 /* Make sure we have an FD that refers to a tty */ 51 #ifdef _WIN32 52 HANDLE handle; 53 handle = CreateFileA("conin$", 54 GENERIC_READ | GENERIC_WRITE, 55 FILE_SHARE_READ | FILE_SHARE_WRITE, 56 NULL, 57 OPEN_EXISTING, 58 FILE_ATTRIBUTE_NORMAL, 59 NULL); 60 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 61 ttyin_fd = _open_osfhandle((intptr_t) handle, 0); 62 63 handle = CreateFileA("conout$", 64 GENERIC_READ | GENERIC_WRITE, 65 FILE_SHARE_READ | FILE_SHARE_WRITE, 66 NULL, 67 OPEN_EXISTING, 68 FILE_ATTRIBUTE_NORMAL, 69 NULL); 70 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 71 ttyout_fd = _open_osfhandle((intptr_t) handle, 0); 72 73 #else /* unix */ 74 ttyin_fd = open("/dev/tty", O_RDONLY, 0); 75 if (ttyin_fd < 0) { 76 fprintf(stderr, "Cannot open /dev/tty as read-only: %s\n", strerror(errno)); 77 fflush(stderr); 78 return TEST_SKIP; 79 } 80 81 ttyout_fd = open("/dev/tty", O_WRONLY, 0); 82 if (ttyout_fd < 0) { 83 fprintf(stderr, "Cannot open /dev/tty as write-only: %s\n", strerror(errno)); 84 fflush(stderr); 85 return TEST_SKIP; 86 } 87 #endif 88 89 ASSERT_GE(ttyin_fd, 0); 90 ASSERT_GE(ttyout_fd, 0); 91 92 ASSERT_EQ(UV_UNKNOWN_HANDLE, uv_guess_handle(-1)); 93 94 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); 95 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); 96 97 r = uv_tty_init(loop, &tty_in, ttyin_fd, 1); /* Readable. */ 98 ASSERT_OK(r); 99 ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); 100 ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); 101 102 r = uv_tty_init(loop, &tty_out, ttyout_fd, 0); /* Writable. */ 103 ASSERT_OK(r); 104 ASSERT(!uv_is_readable((uv_stream_t*) &tty_out)); 105 ASSERT(uv_is_writable((uv_stream_t*) &tty_out)); 106 107 r = uv_tty_get_winsize(&tty_out, &width, &height); 108 ASSERT_OK(r); 109 110 printf("width=%d height=%d\n", width, height); 111 112 if (width == 0 && height == 0) { 113 /* Some environments such as containers or Jenkins behave like this 114 * sometimes */ 115 MAKE_VALGRIND_HAPPY(loop); 116 return TEST_SKIP; 117 } 118 119 ASSERT_GT(width, 0); 120 ASSERT_GT(height, 0); 121 122 /* Turn on raw mode. */ 123 r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); 124 ASSERT_OK(r); 125 126 /* Turn off raw mode. */ 127 r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_NORMAL); 128 ASSERT_OK(r); 129 130 /* Calling uv_tty_reset_mode() repeatedly should not clobber errno. */ 131 errno = 0; 132 ASSERT_OK(uv_tty_reset_mode()); 133 ASSERT_OK(uv_tty_reset_mode()); 134 ASSERT_OK(uv_tty_reset_mode()); 135 ASSERT_OK(errno); 136 137 /* TODO check the actual mode! */ 138 139 uv_close((uv_handle_t*) &tty_in, NULL); 140 uv_close((uv_handle_t*) &tty_out, NULL); 141 142 uv_run(loop, UV_RUN_DEFAULT); 143 144 MAKE_VALGRIND_HAPPY(uv_default_loop()); 145 return 0; 146 } 147 148 149 #ifdef _WIN32 150 static void tty_raw_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf) { 151 buf->base = malloc(size); 152 buf->len = size; 153 } 154 155 static void tty_raw_read(uv_stream_t* tty_in, ssize_t nread, const uv_buf_t* buf) { 156 if (nread > 0) { 157 ASSERT_EQ(1, nread ); 158 ASSERT_EQ(buf->base[0], ' '); 159 uv_close((uv_handle_t*) tty_in, NULL); 160 } else { 161 ASSERT_OK(nread); 162 } 163 } 164 165 TEST_IMPL(tty_raw) { 166 int r; 167 int ttyin_fd; 168 uv_tty_t tty_in; 169 uv_loop_t* loop = uv_default_loop(); 170 HANDLE handle; 171 INPUT_RECORD record; 172 DWORD written; 173 174 /* Make sure we have an FD that refers to a tty */ 175 handle = CreateFileA("conin$", 176 GENERIC_READ | GENERIC_WRITE, 177 FILE_SHARE_READ | FILE_SHARE_WRITE, 178 NULL, 179 OPEN_EXISTING, 180 FILE_ATTRIBUTE_NORMAL, 181 NULL); 182 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 183 ttyin_fd = _open_osfhandle((intptr_t) handle, 0); 184 ASSERT_GE(ttyin_fd, 0); 185 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); 186 187 r = uv_tty_init(loop, &tty_in, ttyin_fd, 1); /* Readable. */ 188 ASSERT_OK(r); 189 ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); 190 ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); 191 192 r = uv_read_start((uv_stream_t*)&tty_in, tty_raw_alloc, tty_raw_read); 193 ASSERT_OK(r); 194 195 /* Give uv_tty_line_read_thread time to block on ReadConsoleW */ 196 Sleep(100); 197 198 /* Turn on raw mode. */ 199 r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); 200 ASSERT_OK(r); 201 202 /* Write ' ' that should be read in raw mode */ 203 record.EventType = KEY_EVENT; 204 record.Event.KeyEvent.bKeyDown = TRUE; 205 record.Event.KeyEvent.wRepeatCount = 1; 206 record.Event.KeyEvent.wVirtualKeyCode = VK_SPACE; 207 record.Event.KeyEvent.wVirtualScanCode = MapVirtualKeyW(VK_SPACE, MAPVK_VK_TO_VSC); 208 record.Event.KeyEvent.uChar.UnicodeChar = L' '; 209 record.Event.KeyEvent.dwControlKeyState = 0; 210 WriteConsoleInputW(handle, &record, 1, &written); 211 212 uv_run(loop, UV_RUN_DEFAULT); 213 214 MAKE_VALGRIND_HAPPY(loop); 215 return 0; 216 } 217 218 TEST_IMPL(tty_empty_write) { 219 int r; 220 int ttyout_fd; 221 uv_tty_t tty_out; 222 char dummy[1]; 223 uv_buf_t bufs[1]; 224 uv_loop_t* loop; 225 226 /* Make sure we have an FD that refers to a tty */ 227 HANDLE handle; 228 229 loop = uv_default_loop(); 230 231 handle = CreateFileA("conout$", 232 GENERIC_READ | GENERIC_WRITE, 233 FILE_SHARE_READ | FILE_SHARE_WRITE, 234 NULL, 235 OPEN_EXISTING, 236 FILE_ATTRIBUTE_NORMAL, 237 NULL); 238 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 239 ttyout_fd = _open_osfhandle((intptr_t) handle, 0); 240 241 ASSERT_GE(ttyout_fd, 0); 242 243 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); 244 245 r = uv_tty_init(loop, &tty_out, ttyout_fd, 0); /* Writable. */ 246 ASSERT_OK(r); 247 ASSERT(!uv_is_readable((uv_stream_t*) &tty_out)); 248 ASSERT(uv_is_writable((uv_stream_t*) &tty_out)); 249 250 bufs[0].len = 0; 251 bufs[0].base = &dummy[0]; 252 253 r = uv_try_write((uv_stream_t*) &tty_out, bufs, 1); 254 ASSERT_OK(r); 255 256 uv_close((uv_handle_t*) &tty_out, NULL); 257 258 uv_run(loop, UV_RUN_DEFAULT); 259 260 MAKE_VALGRIND_HAPPY(loop); 261 return 0; 262 } 263 264 TEST_IMPL(tty_large_write) { 265 int r; 266 int ttyout_fd; 267 uv_tty_t tty_out; 268 char dummy[10000]; 269 uv_buf_t bufs[1]; 270 uv_loop_t* loop; 271 272 /* Make sure we have an FD that refers to a tty */ 273 HANDLE handle; 274 275 loop = uv_default_loop(); 276 277 handle = CreateFileA("conout$", 278 GENERIC_READ | GENERIC_WRITE, 279 FILE_SHARE_READ | FILE_SHARE_WRITE, 280 NULL, 281 OPEN_EXISTING, 282 FILE_ATTRIBUTE_NORMAL, 283 NULL); 284 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 285 ttyout_fd = _open_osfhandle((intptr_t) handle, 0); 286 287 ASSERT_GE(ttyout_fd, 0); 288 289 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); 290 291 r = uv_tty_init(loop, &tty_out, ttyout_fd, 0); /* Writable. */ 292 ASSERT_OK(r); 293 294 memset(dummy, '.', sizeof(dummy) - 1); 295 dummy[sizeof(dummy) - 1] = '\n'; 296 297 bufs[0] = uv_buf_init(dummy, sizeof(dummy)); 298 299 r = uv_try_write((uv_stream_t*) &tty_out, bufs, 1); 300 ASSERT_EQ(10000, r); 301 302 uv_close((uv_handle_t*) &tty_out, NULL); 303 304 uv_run(loop, UV_RUN_DEFAULT); 305 306 MAKE_VALGRIND_HAPPY(loop); 307 return 0; 308 } 309 310 TEST_IMPL(tty_raw_cancel) { 311 int r; 312 int ttyin_fd; 313 uv_tty_t tty_in; 314 HANDLE handle; 315 316 /* Make sure we have an FD that refers to a tty */ 317 handle = CreateFileA("conin$", 318 GENERIC_READ | GENERIC_WRITE, 319 FILE_SHARE_READ | FILE_SHARE_WRITE, 320 NULL, 321 OPEN_EXISTING, 322 FILE_ATTRIBUTE_NORMAL, 323 NULL); 324 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 325 ttyin_fd = _open_osfhandle((intptr_t) handle, 0); 326 ASSERT_GE(ttyin_fd, 0); 327 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); 328 329 r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ 330 ASSERT_OK(r); 331 r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); 332 ASSERT_OK(r); 333 r = uv_read_start((uv_stream_t*)&tty_in, tty_raw_alloc, tty_raw_read); 334 ASSERT_OK(r); 335 336 r = uv_read_stop((uv_stream_t*) &tty_in); 337 ASSERT_OK(r); 338 339 MAKE_VALGRIND_HAPPY(uv_default_loop()); 340 return 0; 341 } 342 #endif 343 344 345 TEST_IMPL(tty_file) { 346 #ifndef _WIN32 347 uv_loop_t loop; 348 uv_tty_t tty; 349 uv_tty_t tty_ro; 350 uv_tty_t tty_wo; 351 int fd; 352 353 ASSERT_OK(uv_loop_init(&loop)); 354 355 fd = open("test/fixtures/empty_file", O_RDONLY); 356 if (fd != -1) { 357 ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); 358 ASSERT_OK(close(fd)); 359 /* test EBADF handling */ 360 ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); 361 } 362 363 /* Bug on AIX where '/dev/random' returns 1 from isatty() */ 364 #ifndef _AIX 365 fd = open("/dev/random", O_RDONLY); 366 if (fd != -1) { 367 ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); 368 ASSERT_OK(close(fd)); 369 } 370 #endif /* _AIX */ 371 372 fd = open("/dev/zero", O_RDONLY); 373 if (fd != -1) { 374 ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); 375 ASSERT_OK(close(fd)); 376 } 377 378 fd = open("/dev/tty", O_RDWR); 379 if (fd != -1) { 380 ASSERT_OK(uv_tty_init(&loop, &tty, fd, 1)); 381 ASSERT_OK(close(fd)); /* TODO: it's indeterminate who owns fd now */ 382 ASSERT(uv_is_readable((uv_stream_t*) &tty)); 383 ASSERT(uv_is_writable((uv_stream_t*) &tty)); 384 uv_close((uv_handle_t*) &tty, NULL); 385 ASSERT(!uv_is_readable((uv_stream_t*) &tty)); 386 ASSERT(!uv_is_writable((uv_stream_t*) &tty)); 387 } 388 389 fd = open("/dev/tty", O_RDONLY); 390 if (fd != -1) { 391 ASSERT_OK(uv_tty_init(&loop, &tty_ro, fd, 1)); 392 ASSERT_OK(close(fd)); /* TODO: it's indeterminate who owns fd now */ 393 ASSERT(uv_is_readable((uv_stream_t*) &tty_ro)); 394 ASSERT(!uv_is_writable((uv_stream_t*) &tty_ro)); 395 uv_close((uv_handle_t*) &tty_ro, NULL); 396 ASSERT(!uv_is_readable((uv_stream_t*) &tty_ro)); 397 ASSERT(!uv_is_writable((uv_stream_t*) &tty_ro)); 398 } 399 400 fd = open("/dev/tty", O_WRONLY); 401 if (fd != -1) { 402 ASSERT_OK(uv_tty_init(&loop, &tty_wo, fd, 0)); 403 ASSERT_OK(close(fd)); /* TODO: it's indeterminate who owns fd now */ 404 ASSERT(!uv_is_readable((uv_stream_t*) &tty_wo)); 405 ASSERT(uv_is_writable((uv_stream_t*) &tty_wo)); 406 uv_close((uv_handle_t*) &tty_wo, NULL); 407 ASSERT(!uv_is_readable((uv_stream_t*) &tty_wo)); 408 ASSERT(!uv_is_writable((uv_stream_t*) &tty_wo)); 409 } 410 411 412 ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); 413 414 MAKE_VALGRIND_HAPPY(&loop); 415 #endif 416 return 0; 417 } 418 419 TEST_IMPL(tty_pty) { 420 /* TODO(gengjiawen): Fix test on QEMU. */ 421 #if defined(__QEMU__) 422 RETURN_SKIP("Test does not currently work in QEMU"); 423 #endif 424 #if defined(__ASAN__) 425 RETURN_SKIP("Test does not currently work in ASAN"); 426 #endif 427 428 #if defined(__APPLE__) || \ 429 defined(__DragonFly__) || \ 430 defined(__FreeBSD__) || \ 431 (defined(__linux__) && !defined(__ANDROID__)) || \ 432 defined(__NetBSD__) || \ 433 defined(__OpenBSD__) 434 int master_fd, slave_fd, r; 435 struct winsize w; 436 uv_loop_t loop; 437 uv_tty_t master_tty, slave_tty; 438 439 ASSERT_OK(uv_loop_init(&loop)); 440 441 r = openpty(&master_fd, &slave_fd, NULL, NULL, &w); 442 if (r != 0) 443 RETURN_SKIP("No pty available, skipping."); 444 445 ASSERT_OK(uv_tty_init(&loop, &slave_tty, slave_fd, 0)); 446 ASSERT_OK(uv_tty_init(&loop, &master_tty, master_fd, 0)); 447 ASSERT(uv_is_readable((uv_stream_t*) &slave_tty)); 448 ASSERT(uv_is_writable((uv_stream_t*) &slave_tty)); 449 ASSERT(uv_is_readable((uv_stream_t*) &master_tty)); 450 ASSERT(uv_is_writable((uv_stream_t*) &master_tty)); 451 /* Check if the file descriptor was reopened. If it is, 452 * UV_HANDLE_BLOCKING_WRITES (value 0x100000) isn't set on flags. 453 */ 454 ASSERT_OK((slave_tty.flags & 0x100000)); 455 /* The master_fd of a pty should never be reopened. 456 */ 457 ASSERT(master_tty.flags & 0x100000); 458 ASSERT_OK(close(slave_fd)); 459 uv_close((uv_handle_t*) &slave_tty, NULL); 460 ASSERT_OK(close(master_fd)); 461 uv_close((uv_handle_t*) &master_tty, NULL); 462 463 ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); 464 465 MAKE_VALGRIND_HAPPY(&loop); 466 #endif 467 return 0; 468 } 469
Indexes created Sun Mar 01 05:31:48 UTC 2026