test-fs.c revision 1.1.1.3
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 #include <errno.h> 26 #include <string.h> /* memset */ 27 #include <fcntl.h> 28 #include <sys/stat.h> 29 #include <limits.h> /* INT_MAX, PATH_MAX, IOV_MAX */ 30 31 #ifndef _WIN32 32 # include <unistd.h> /* unlink, rmdir, etc. */ 33 #else 34 # include <winioctl.h> 35 # include <direct.h> 36 # include <io.h> 37 # ifndef ERROR_SYMLINK_NOT_SUPPORTED 38 # define ERROR_SYMLINK_NOT_SUPPORTED 1464 39 # endif 40 # ifndef S_IFIFO 41 # define S_IFIFO _S_IFIFO 42 # endif 43 # define unlink _unlink 44 # define rmdir _rmdir 45 # define open _open 46 # define write _write 47 # define close _close 48 # ifndef stat 49 # define stat _stati64 50 # endif 51 # ifndef lseek 52 # define lseek _lseek 53 # endif 54 # define S_IFDIR _S_IFDIR 55 # define S_IFCHR _S_IFCHR 56 # define S_IFREG _S_IFREG 57 #endif 58 59 #define TOO_LONG_NAME_LENGTH 65536 60 #define PATHMAX 4096 61 62 #ifdef _WIN32 63 static const int is_win32 = 1; 64 #else 65 static const int is_win32 = 0; 66 #endif 67 68 #if defined(__APPLE__) || defined(__SUNPRO_C) 69 static const int is_apple_or_sunpro_c = 1; 70 #else 71 static const int is_apple_or_sunpro_c = 0; 72 #endif 73 74 typedef struct { 75 const char* path; 76 double atime; 77 double mtime; 78 } utime_check_t; 79 80 81 static int dummy_cb_count; 82 static int close_cb_count; 83 static int create_cb_count; 84 static int open_cb_count; 85 static int read_cb_count; 86 static int write_cb_count; 87 static int unlink_cb_count; 88 static int mkdir_cb_count; 89 static int mkdtemp_cb_count; 90 static int mkstemp_cb_count; 91 static int rmdir_cb_count; 92 static int scandir_cb_count; 93 static int stat_cb_count; 94 static int rename_cb_count; 95 static int fsync_cb_count; 96 static int fdatasync_cb_count; 97 static int ftruncate_cb_count; 98 static int sendfile_cb_count; 99 static int fstat_cb_count; 100 static int access_cb_count; 101 static int chmod_cb_count; 102 static int fchmod_cb_count; 103 static int chown_cb_count; 104 static int fchown_cb_count; 105 static int lchown_cb_count; 106 static int link_cb_count; 107 static int symlink_cb_count; 108 static int readlink_cb_count; 109 static int realpath_cb_count; 110 static int utime_cb_count; 111 static int futime_cb_count; 112 static int lutime_cb_count; 113 static int statfs_cb_count; 114 115 static uv_loop_t* loop; 116 117 static uv_fs_t open_req1; 118 static uv_fs_t open_req2; 119 static uv_fs_t open_req_noclose; 120 static uv_fs_t read_req; 121 static uv_fs_t write_req; 122 static uv_fs_t unlink_req; 123 static uv_fs_t close_req; 124 static uv_fs_t mkdir_req; 125 static uv_fs_t mkdtemp_req1; 126 static uv_fs_t mkdtemp_req2; 127 static uv_fs_t mkstemp_req1; 128 static uv_fs_t mkstemp_req2; 129 static uv_fs_t mkstemp_req3; 130 static uv_fs_t rmdir_req; 131 static uv_fs_t scandir_req; 132 static uv_fs_t stat_req; 133 static uv_fs_t rename_req; 134 static uv_fs_t fsync_req; 135 static uv_fs_t fdatasync_req; 136 static uv_fs_t ftruncate_req; 137 static uv_fs_t sendfile_req; 138 static uv_fs_t utime_req; 139 static uv_fs_t futime_req; 140 141 static char buf[32]; 142 static char buf2[32]; 143 static char test_buf[] = "test-buffer\n"; 144 static char test_buf2[] = "second-buffer\n"; 145 static uv_buf_t iov; 146 147 #ifdef _WIN32 148 int uv_test_getiovmax(void) { 149 return INT32_MAX; /* Emulated by libuv, so no real limit. */ 150 } 151 #else 152 int uv_test_getiovmax(void) { 153 #if defined(IOV_MAX) 154 return IOV_MAX; 155 #elif defined(_SC_IOV_MAX) 156 static int iovmax = -1; 157 if (iovmax == -1) { 158 iovmax = sysconf(_SC_IOV_MAX); 159 /* On some embedded devices (arm-linux-uclibc based ip camera), 160 * sysconf(_SC_IOV_MAX) can not get the correct value. The return 161 * value is -1 and the errno is EINPROGRESS. Degrade the value to 1. 162 */ 163 if (iovmax == -1) iovmax = 1; 164 } 165 return iovmax; 166 #else 167 return 1024; 168 #endif 169 } 170 #endif 171 172 #ifdef _WIN32 173 /* 174 * This tag and guid have no special meaning, and don't conflict with 175 * reserved ids. 176 */ 177 static unsigned REPARSE_TAG = 0x9913; 178 static GUID REPARSE_GUID = { 179 0x1bf6205f, 0x46ae, 0x4527, 180 { 0xb1, 0x0c, 0xc5, 0x09, 0xb7, 0x55, 0x22, 0x80 }}; 181 #endif 182 183 static void check_permission(const char* filename, unsigned int mode) { 184 int r; 185 uv_fs_t req; 186 uv_stat_t* s; 187 188 r = uv_fs_stat(NULL, &req, filename, NULL); 189 ASSERT_OK(r); 190 ASSERT_OK(req.result); 191 192 s = &req.statbuf; 193 #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__) 194 /* 195 * On Windows, chmod can only modify S_IWUSR (_S_IWRITE) bit, 196 * so only testing for the specified flags. 197 */ 198 ASSERT((s->st_mode & 0777) & mode); 199 #else 200 ASSERT((s->st_mode & 0777) == mode); 201 #endif 202 203 uv_fs_req_cleanup(&req); 204 } 205 206 207 static void dummy_cb(uv_fs_t* req) { 208 (void) req; 209 dummy_cb_count++; 210 } 211 212 213 static void link_cb(uv_fs_t* req) { 214 ASSERT_EQ(req->fs_type, UV_FS_LINK); 215 ASSERT_OK(req->result); 216 link_cb_count++; 217 uv_fs_req_cleanup(req); 218 } 219 220 221 static void symlink_cb(uv_fs_t* req) { 222 ASSERT_EQ(req->fs_type, UV_FS_SYMLINK); 223 ASSERT_OK(req->result); 224 symlink_cb_count++; 225 uv_fs_req_cleanup(req); 226 } 227 228 static void readlink_cb(uv_fs_t* req) { 229 ASSERT_EQ(req->fs_type, UV_FS_READLINK); 230 ASSERT_OK(req->result); 231 ASSERT_OK(strcmp(req->ptr, "test_file_symlink2")); 232 readlink_cb_count++; 233 uv_fs_req_cleanup(req); 234 } 235 236 237 static void realpath_cb(uv_fs_t* req) { 238 char test_file_abs_buf[PATHMAX]; 239 size_t test_file_abs_size = sizeof(test_file_abs_buf); 240 ASSERT_EQ(req->fs_type, UV_FS_REALPATH); 241 ASSERT_OK(req->result); 242 243 uv_cwd(test_file_abs_buf, &test_file_abs_size); 244 #ifdef _WIN32 245 strcat(test_file_abs_buf, "\\test_file"); 246 ASSERT_OK(_stricmp(req->ptr, test_file_abs_buf)); 247 #else 248 strcat(test_file_abs_buf, "/test_file"); 249 ASSERT_OK(strcmp(req->ptr, test_file_abs_buf)); 250 #endif 251 realpath_cb_count++; 252 uv_fs_req_cleanup(req); 253 } 254 255 256 static void access_cb(uv_fs_t* req) { 257 ASSERT_EQ(req->fs_type, UV_FS_ACCESS); 258 access_cb_count++; 259 uv_fs_req_cleanup(req); 260 } 261 262 263 static void fchmod_cb(uv_fs_t* req) { 264 ASSERT_EQ(req->fs_type, UV_FS_FCHMOD); 265 ASSERT_OK(req->result); 266 fchmod_cb_count++; 267 uv_fs_req_cleanup(req); 268 check_permission("test_file", *(int*)req->data); 269 } 270 271 272 static void chmod_cb(uv_fs_t* req) { 273 ASSERT_EQ(req->fs_type, UV_FS_CHMOD); 274 ASSERT_OK(req->result); 275 chmod_cb_count++; 276 uv_fs_req_cleanup(req); 277 check_permission("test_file", *(int*)req->data); 278 } 279 280 281 static void fchown_cb(uv_fs_t* req) { 282 ASSERT_EQ(req->fs_type, UV_FS_FCHOWN); 283 ASSERT_OK(req->result); 284 fchown_cb_count++; 285 uv_fs_req_cleanup(req); 286 } 287 288 289 static void chown_cb(uv_fs_t* req) { 290 ASSERT_EQ(req->fs_type, UV_FS_CHOWN); 291 ASSERT_OK(req->result); 292 chown_cb_count++; 293 uv_fs_req_cleanup(req); 294 } 295 296 static void lchown_cb(uv_fs_t* req) { 297 ASSERT_EQ(req->fs_type, UV_FS_LCHOWN); 298 ASSERT_OK(req->result); 299 lchown_cb_count++; 300 uv_fs_req_cleanup(req); 301 } 302 303 static void chown_root_cb(uv_fs_t* req) { 304 ASSERT_EQ(req->fs_type, UV_FS_CHOWN); 305 #if defined(_WIN32) || defined(__MSYS__) 306 /* On windows, chown is a no-op and always succeeds. */ 307 ASSERT_OK(req->result); 308 #else 309 /* On unix, chown'ing the root directory is not allowed - 310 * unless you're root, of course. 311 */ 312 if (geteuid() == 0) 313 ASSERT_OK(req->result); 314 else 315 # if defined(__CYGWIN__) 316 /* On Cygwin, uid 0 is invalid (no root). */ 317 ASSERT_EQ(req->result, UV_EINVAL); 318 # elif defined(__PASE__) 319 /* On IBMi PASE, there is no root user. uid 0 is user qsecofr. 320 * User may grant qsecofr's privileges, including changing 321 * the file's ownership to uid 0. 322 */ 323 ASSERT(req->result == 0 || req->result == UV_EPERM); 324 # else 325 ASSERT_EQ(req->result, UV_EPERM); 326 # endif 327 #endif 328 chown_cb_count++; 329 uv_fs_req_cleanup(req); 330 } 331 332 static void unlink_cb(uv_fs_t* req) { 333 ASSERT_PTR_EQ(req, &unlink_req); 334 ASSERT_EQ(req->fs_type, UV_FS_UNLINK); 335 ASSERT_OK(req->result); 336 unlink_cb_count++; 337 uv_fs_req_cleanup(req); 338 } 339 340 static void fstat_cb(uv_fs_t* req) { 341 uv_stat_t* s = req->ptr; 342 ASSERT_EQ(req->fs_type, UV_FS_FSTAT); 343 ASSERT_OK(req->result); 344 ASSERT_EQ(s->st_size, sizeof(test_buf)); 345 uv_fs_req_cleanup(req); 346 fstat_cb_count++; 347 } 348 349 350 static void statfs_cb(uv_fs_t* req) { 351 uv_statfs_t* stats; 352 353 ASSERT_EQ(req->fs_type, UV_FS_STATFS); 354 ASSERT_OK(req->result); 355 ASSERT_NOT_NULL(req->ptr); 356 stats = req->ptr; 357 358 #if defined(_WIN32) || defined(__sun) || defined(_AIX) || defined(__MVS__) || \ 359 defined(__OpenBSD__) || defined(__NetBSD__) 360 ASSERT_OK(stats->f_type); 361 #else 362 ASSERT_UINT64_GT(stats->f_type, 0); 363 #endif 364 365 ASSERT_GT(stats->f_bsize, 0); 366 ASSERT_GT(stats->f_blocks, 0); 367 ASSERT_LE(stats->f_bfree, stats->f_blocks); 368 ASSERT_LE(stats->f_bavail, stats->f_bfree); 369 370 #ifdef _WIN32 371 ASSERT_OK(stats->f_files); 372 ASSERT_OK(stats->f_ffree); 373 #else 374 /* There is no assertion for stats->f_files that makes sense, so ignore it. */ 375 ASSERT_LE(stats->f_ffree, stats->f_files); 376 #endif 377 uv_fs_req_cleanup(req); 378 ASSERT_NULL(req->ptr); 379 statfs_cb_count++; 380 } 381 382 383 static void close_cb(uv_fs_t* req) { 384 int r; 385 ASSERT_PTR_EQ(req, &close_req); 386 ASSERT_EQ(req->fs_type, UV_FS_CLOSE); 387 ASSERT_OK(req->result); 388 close_cb_count++; 389 uv_fs_req_cleanup(req); 390 if (close_cb_count == 3) { 391 r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb); 392 ASSERT_OK(r); 393 } 394 } 395 396 397 static void ftruncate_cb(uv_fs_t* req) { 398 int r; 399 ASSERT_PTR_EQ(req, &ftruncate_req); 400 ASSERT_EQ(req->fs_type, UV_FS_FTRUNCATE); 401 ASSERT_OK(req->result); 402 ftruncate_cb_count++; 403 uv_fs_req_cleanup(req); 404 r = uv_fs_close(loop, &close_req, open_req1.result, close_cb); 405 ASSERT_OK(r); 406 } 407 408 static void fail_cb(uv_fs_t* req) { 409 FATAL("fail_cb should not have been called"); 410 } 411 412 static void read_cb(uv_fs_t* req) { 413 int r; 414 ASSERT_PTR_EQ(req, &read_req); 415 ASSERT_EQ(req->fs_type, UV_FS_READ); 416 ASSERT_GE(req->result, 0); /* FIXME(bnoordhuis) Check if requested size? */ 417 read_cb_count++; 418 uv_fs_req_cleanup(req); 419 if (read_cb_count == 1) { 420 ASSERT_OK(strcmp(buf, test_buf)); 421 r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7, 422 ftruncate_cb); 423 } else { 424 ASSERT_OK(strcmp(buf, "test-bu")); 425 r = uv_fs_close(loop, &close_req, open_req1.result, close_cb); 426 } 427 ASSERT_OK(r); 428 } 429 430 431 static void open_cb(uv_fs_t* req) { 432 int r; 433 ASSERT_PTR_EQ(req, &open_req1); 434 ASSERT_EQ(req->fs_type, UV_FS_OPEN); 435 if (req->result < 0) { 436 fprintf(stderr, "async open error: %d\n", (int) req->result); 437 ASSERT(0); 438 } 439 open_cb_count++; 440 ASSERT(req->path); 441 ASSERT_OK(memcmp(req->path, "test_file2\0", 11)); 442 uv_fs_req_cleanup(req); 443 memset(buf, 0, sizeof(buf)); 444 iov = uv_buf_init(buf, sizeof(buf)); 445 r = uv_fs_read(loop, &read_req, open_req1.result, &iov, 1, -1, 446 read_cb); 447 ASSERT_OK(r); 448 } 449 450 451 static void open_cb_simple(uv_fs_t* req) { 452 ASSERT_EQ(req->fs_type, UV_FS_OPEN); 453 if (req->result < 0) { 454 fprintf(stderr, "async open error: %d\n", (int) req->result); 455 ASSERT(0); 456 } 457 open_cb_count++; 458 ASSERT(req->path); 459 uv_fs_req_cleanup(req); 460 } 461 462 463 static void fsync_cb(uv_fs_t* req) { 464 int r; 465 ASSERT_PTR_EQ(req, &fsync_req); 466 ASSERT_EQ(req->fs_type, UV_FS_FSYNC); 467 ASSERT_OK(req->result); 468 fsync_cb_count++; 469 uv_fs_req_cleanup(req); 470 r = uv_fs_close(loop, &close_req, open_req1.result, close_cb); 471 ASSERT_OK(r); 472 } 473 474 475 static void fdatasync_cb(uv_fs_t* req) { 476 int r; 477 ASSERT_PTR_EQ(req, &fdatasync_req); 478 ASSERT_EQ(req->fs_type, UV_FS_FDATASYNC); 479 ASSERT_OK(req->result); 480 fdatasync_cb_count++; 481 uv_fs_req_cleanup(req); 482 r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb); 483 ASSERT_OK(r); 484 } 485 486 487 static void write_cb(uv_fs_t* req) { 488 int r; 489 ASSERT_PTR_EQ(req, &write_req); 490 ASSERT_EQ(req->fs_type, UV_FS_WRITE); 491 ASSERT_GE(req->result, 0); /* FIXME(bnoordhuis) Check if requested size? */ 492 write_cb_count++; 493 uv_fs_req_cleanup(req); 494 r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb); 495 ASSERT_OK(r); 496 } 497 498 499 static void create_cb(uv_fs_t* req) { 500 int r; 501 ASSERT_PTR_EQ(req, &open_req1); 502 ASSERT_EQ(req->fs_type, UV_FS_OPEN); 503 ASSERT_GE(req->result, 0); 504 create_cb_count++; 505 uv_fs_req_cleanup(req); 506 iov = uv_buf_init(test_buf, sizeof(test_buf)); 507 r = uv_fs_write(loop, &write_req, req->result, &iov, 1, -1, write_cb); 508 ASSERT_OK(r); 509 } 510 511 512 static void rename_cb(uv_fs_t* req) { 513 ASSERT_PTR_EQ(req, &rename_req); 514 ASSERT_EQ(req->fs_type, UV_FS_RENAME); 515 ASSERT_OK(req->result); 516 rename_cb_count++; 517 uv_fs_req_cleanup(req); 518 } 519 520 521 static void mkdir_cb(uv_fs_t* req) { 522 ASSERT_PTR_EQ(req, &mkdir_req); 523 ASSERT_EQ(req->fs_type, UV_FS_MKDIR); 524 ASSERT_OK(req->result); 525 mkdir_cb_count++; 526 ASSERT(req->path); 527 ASSERT_OK(memcmp(req->path, "test_dir\0", 9)); 528 uv_fs_req_cleanup(req); 529 } 530 531 532 static void check_mkdtemp_result(uv_fs_t* req) { 533 int r; 534 535 ASSERT_EQ(req->fs_type, UV_FS_MKDTEMP); 536 ASSERT_OK(req->result); 537 ASSERT(req->path); 538 ASSERT_EQ(15, strlen(req->path)); 539 ASSERT_OK(memcmp(req->path, "test_dir_", 9)); 540 ASSERT_NE(0, memcmp(req->path + 9, "XXXXXX", 6)); 541 check_permission(req->path, 0700); 542 543 /* Check if req->path is actually a directory */ 544 r = uv_fs_stat(NULL, &stat_req, req->path, NULL); 545 ASSERT_OK(r); 546 ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR); 547 uv_fs_req_cleanup(&stat_req); 548 } 549 550 551 static void mkdtemp_cb(uv_fs_t* req) { 552 ASSERT_PTR_EQ(req, &mkdtemp_req1); 553 check_mkdtemp_result(req); 554 mkdtemp_cb_count++; 555 } 556 557 558 static void check_mkstemp_result(uv_fs_t* req) { 559 int r; 560 561 ASSERT_EQ(req->fs_type, UV_FS_MKSTEMP); 562 ASSERT_GE(req->result, 0); 563 ASSERT(req->path); 564 ASSERT_EQ(16, strlen(req->path)); 565 ASSERT_OK(memcmp(req->path, "test_file_", 10)); 566 ASSERT_NE(0, memcmp(req->path + 10, "XXXXXX", 6)); 567 check_permission(req->path, 0600); 568 569 /* Check if req->path is actually a file */ 570 r = uv_fs_stat(NULL, &stat_req, req->path, NULL); 571 ASSERT_OK(r); 572 ASSERT(stat_req.statbuf.st_mode & S_IFREG); 573 uv_fs_req_cleanup(&stat_req); 574 } 575 576 577 static void mkstemp_cb(uv_fs_t* req) { 578 ASSERT_PTR_EQ(req, &mkstemp_req1); 579 check_mkstemp_result(req); 580 mkstemp_cb_count++; 581 } 582 583 584 static void rmdir_cb(uv_fs_t* req) { 585 ASSERT_PTR_EQ(req, &rmdir_req); 586 ASSERT_EQ(req->fs_type, UV_FS_RMDIR); 587 ASSERT_OK(req->result); 588 rmdir_cb_count++; 589 ASSERT(req->path); 590 ASSERT_OK(memcmp(req->path, "test_dir\0", 9)); 591 uv_fs_req_cleanup(req); 592 } 593 594 595 static void assert_is_file_type(uv_dirent_t dent) { 596 #ifdef HAVE_DIRENT_TYPES 597 /* 598 * For Apple and Windows, we know getdents is expected to work but for other 599 * environments, the filesystem dictates whether or not getdents supports 600 * returning the file type. 601 * 602 * See: 603 * http://man7.org/linux/man-pages/man2/getdents.2.html 604 * https://github.com/libuv/libuv/issues/501 605 */ 606 #if defined(__APPLE__) || defined(_WIN32) 607 ASSERT_EQ(dent.type, UV_DIRENT_FILE); 608 #else 609 ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN); 610 #endif 611 #else 612 ASSERT_EQ(dent.type, UV_DIRENT_UNKNOWN); 613 #endif 614 } 615 616 617 static void scandir_cb(uv_fs_t* req) { 618 uv_dirent_t dent; 619 ASSERT_PTR_EQ(req, &scandir_req); 620 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); 621 ASSERT_EQ(2, req->result); 622 ASSERT(req->ptr); 623 624 while (UV_EOF != uv_fs_scandir_next(req, &dent)) { 625 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); 626 assert_is_file_type(dent); 627 } 628 scandir_cb_count++; 629 ASSERT(req->path); 630 ASSERT_OK(memcmp(req->path, "test_dir\0", 9)); 631 uv_fs_req_cleanup(req); 632 ASSERT(!req->ptr); 633 } 634 635 636 static void empty_scandir_cb(uv_fs_t* req) { 637 uv_dirent_t dent; 638 639 ASSERT_PTR_EQ(req, &scandir_req); 640 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); 641 ASSERT_OK(req->result); 642 ASSERT_NULL(req->ptr); 643 ASSERT_EQ(UV_EOF, uv_fs_scandir_next(req, &dent)); 644 uv_fs_req_cleanup(req); 645 scandir_cb_count++; 646 } 647 648 static void non_existent_scandir_cb(uv_fs_t* req) { 649 uv_dirent_t dent; 650 651 ASSERT_PTR_EQ(req, &scandir_req); 652 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); 653 ASSERT_EQ(req->result, UV_ENOENT); 654 ASSERT_NULL(req->ptr); 655 ASSERT_EQ(UV_ENOENT, uv_fs_scandir_next(req, &dent)); 656 uv_fs_req_cleanup(req); 657 scandir_cb_count++; 658 } 659 660 661 static void file_scandir_cb(uv_fs_t* req) { 662 ASSERT_PTR_EQ(req, &scandir_req); 663 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); 664 ASSERT_EQ(req->result, UV_ENOTDIR); 665 ASSERT_NULL(req->ptr); 666 uv_fs_req_cleanup(req); 667 scandir_cb_count++; 668 } 669 670 671 static void stat_cb(uv_fs_t* req) { 672 ASSERT_PTR_EQ(req, &stat_req); 673 ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT); 674 ASSERT_OK(req->result); 675 ASSERT(req->ptr); 676 stat_cb_count++; 677 uv_fs_req_cleanup(req); 678 ASSERT(!req->ptr); 679 } 680 681 static void stat_batch_cb(uv_fs_t* req) { 682 ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT); 683 ASSERT_OK(req->result); 684 ASSERT(req->ptr); 685 stat_cb_count++; 686 uv_fs_req_cleanup(req); 687 ASSERT(!req->ptr); 688 } 689 690 691 static void sendfile_cb(uv_fs_t* req) { 692 ASSERT_PTR_EQ(req, &sendfile_req); 693 ASSERT_EQ(req->fs_type, UV_FS_SENDFILE); 694 ASSERT_EQ(65545, req->result); 695 sendfile_cb_count++; 696 uv_fs_req_cleanup(req); 697 } 698 699 700 static void sendfile_nodata_cb(uv_fs_t* req) { 701 ASSERT_PTR_EQ(req, &sendfile_req); 702 ASSERT_EQ(req->fs_type, UV_FS_SENDFILE); 703 ASSERT_OK(req->result); 704 sendfile_cb_count++; 705 uv_fs_req_cleanup(req); 706 } 707 708 709 static void open_noent_cb(uv_fs_t* req) { 710 ASSERT_EQ(req->fs_type, UV_FS_OPEN); 711 ASSERT_EQ(req->result, UV_ENOENT); 712 open_cb_count++; 713 uv_fs_req_cleanup(req); 714 } 715 716 static void open_nametoolong_cb(uv_fs_t* req) { 717 ASSERT_EQ(req->fs_type, UV_FS_OPEN); 718 ASSERT_EQ(req->result, UV_ENAMETOOLONG); 719 open_cb_count++; 720 uv_fs_req_cleanup(req); 721 } 722 723 static void open_loop_cb(uv_fs_t* req) { 724 ASSERT_EQ(req->fs_type, UV_FS_OPEN); 725 ASSERT_EQ(req->result, UV_ELOOP); 726 open_cb_count++; 727 uv_fs_req_cleanup(req); 728 } 729 730 731 TEST_IMPL(fs_file_noent) { 732 uv_fs_t req; 733 int r; 734 735 loop = uv_default_loop(); 736 737 r = uv_fs_open(NULL, &req, "does_not_exist", UV_FS_O_RDONLY, 0, NULL); 738 ASSERT_EQ(r, UV_ENOENT); 739 ASSERT_EQ(req.result, UV_ENOENT); 740 uv_fs_req_cleanup(&req); 741 742 r = uv_fs_open(loop, &req, "does_not_exist", UV_FS_O_RDONLY, 0, 743 open_noent_cb); 744 ASSERT_OK(r); 745 746 ASSERT_OK(open_cb_count); 747 uv_run(loop, UV_RUN_DEFAULT); 748 ASSERT_EQ(1, open_cb_count); 749 750 /* TODO add EACCES test */ 751 752 MAKE_VALGRIND_HAPPY(loop); 753 return 0; 754 } 755 756 TEST_IMPL(fs_file_nametoolong) { 757 uv_fs_t req; 758 int r; 759 char name[TOO_LONG_NAME_LENGTH + 1]; 760 761 loop = uv_default_loop(); 762 763 memset(name, 'a', TOO_LONG_NAME_LENGTH); 764 name[TOO_LONG_NAME_LENGTH] = 0; 765 766 r = uv_fs_open(NULL, &req, name, UV_FS_O_RDONLY, 0, NULL); 767 ASSERT_EQ(r, UV_ENAMETOOLONG); 768 ASSERT_EQ(req.result, UV_ENAMETOOLONG); 769 uv_fs_req_cleanup(&req); 770 771 r = uv_fs_open(loop, &req, name, UV_FS_O_RDONLY, 0, open_nametoolong_cb); 772 ASSERT_OK(r); 773 774 ASSERT_OK(open_cb_count); 775 uv_run(loop, UV_RUN_DEFAULT); 776 ASSERT_EQ(1, open_cb_count); 777 778 MAKE_VALGRIND_HAPPY(loop); 779 return 0; 780 } 781 782 TEST_IMPL(fs_file_loop) { 783 uv_fs_t req; 784 int r; 785 786 loop = uv_default_loop(); 787 788 unlink("test_symlink"); 789 r = uv_fs_symlink(NULL, &req, "test_symlink", "test_symlink", 0, NULL); 790 #ifdef _WIN32 791 /* 792 * Symlinks are only suported but only when elevated, otherwise 793 * we'll see UV_EPERM. 794 */ 795 if (r == UV_EPERM) 796 return 0; 797 #elif defined(__MSYS__) 798 /* MSYS2's approximation of symlinks with copies does not work for broken 799 links. */ 800 if (r == UV_ENOENT) 801 return 0; 802 #endif 803 ASSERT_OK(r); 804 uv_fs_req_cleanup(&req); 805 806 r = uv_fs_open(NULL, &req, "test_symlink", UV_FS_O_RDONLY, 0, NULL); 807 ASSERT_EQ(r, UV_ELOOP); 808 ASSERT_EQ(req.result, UV_ELOOP); 809 uv_fs_req_cleanup(&req); 810 811 r = uv_fs_open(loop, &req, "test_symlink", UV_FS_O_RDONLY, 0, open_loop_cb); 812 ASSERT_OK(r); 813 814 ASSERT_OK(open_cb_count); 815 uv_run(loop, UV_RUN_DEFAULT); 816 ASSERT_EQ(1, open_cb_count); 817 818 unlink("test_symlink"); 819 820 MAKE_VALGRIND_HAPPY(loop); 821 return 0; 822 } 823 824 static void check_utime(const char* path, 825 double atime, 826 double mtime, 827 int test_lutime) { 828 uv_stat_t* s; 829 uv_fs_t req; 830 int r; 831 832 if (test_lutime) 833 r = uv_fs_lstat(loop, &req, path, NULL); 834 else 835 r = uv_fs_stat(loop, &req, path, NULL); 836 837 ASSERT_OK(r); 838 839 ASSERT_OK(req.result); 840 s = &req.statbuf; 841 842 if (isfinite(atime)) { 843 /* Test sub-second timestamps only when supported (such as Windows with 844 * NTFS). Some other platforms support sub-second timestamps, but that 845 * support is filesystem-dependent. Notably OS X (HFS Plus) does NOT 846 * support sub-second timestamps. But kernels may round or truncate in 847 * either direction, so we may accept either possible answer. 848 */ 849 if (s->st_atim.tv_nsec == 0) { 850 if (is_win32) 851 ASSERT_DOUBLE_EQ(atime, (long) atime); 852 if (atime > 0 || (long) atime == atime) 853 ASSERT_EQ(s->st_atim.tv_sec, (long) atime); 854 ASSERT_GE(s->st_atim.tv_sec, (long) atime - 1); 855 ASSERT_LE(s->st_atim.tv_sec, (long) atime); 856 } else { 857 double st_atim; 858 /* TODO(vtjnash): would it be better to normalize this? */ 859 if (!is_apple_or_sunpro_c) 860 ASSERT_DOUBLE_GE(s->st_atim.tv_nsec, 0); 861 st_atim = s->st_atim.tv_sec + s->st_atim.tv_nsec / 1e9; 862 /* Linux does not allow reading reliably the atime of a symlink 863 * since readlink() can update it 864 */ 865 if (!test_lutime) 866 ASSERT_DOUBLE_EQ(st_atim, atime); 867 } 868 } else if (isinf(atime)) { 869 /* We test with timestamps that are in the distant past 870 * (if you're a Gen Z-er) so check it's more recent than that. 871 */ 872 ASSERT_GT(s->st_atim.tv_sec, 1739710000); 873 } else { 874 ASSERT_OK(0); 875 } 876 877 if (isfinite(mtime)) { 878 /* Test sub-second timestamps only when supported (such as Windows with 879 * NTFS). Some other platforms support sub-second timestamps, but that 880 * support is filesystem-dependent. Notably OS X (HFS Plus) does NOT 881 * support sub-second timestamps. But kernels may round or truncate in 882 * either direction, so we may accept either possible answer. 883 */ 884 if (s->st_mtim.tv_nsec == 0) { 885 if (is_win32) 886 ASSERT_DOUBLE_EQ(mtime, (long) atime); 887 if (mtime > 0 || (long) mtime == mtime) 888 ASSERT_EQ(s->st_mtim.tv_sec, (long) mtime); 889 ASSERT_GE(s->st_mtim.tv_sec, (long) mtime - 1); 890 ASSERT_LE(s->st_mtim.tv_sec, (long) mtime); 891 } else { 892 double st_mtim; 893 /* TODO(vtjnash): would it be better to normalize this? */ 894 if (!is_apple_or_sunpro_c) 895 ASSERT_DOUBLE_GE(s->st_mtim.tv_nsec, 0); 896 st_mtim = s->st_mtim.tv_sec + s->st_mtim.tv_nsec / 1e9; 897 ASSERT_DOUBLE_EQ(st_mtim, mtime); 898 } 899 } else if (isinf(mtime)) { 900 /* We test with timestamps that are in the distant past 901 * (if you're a Gen Z-er) so check it's more recent than that. 902 */ 903 ASSERT_GT(s->st_mtim.tv_sec, 1739710000); 904 } else { 905 ASSERT_OK(0); 906 } 907 908 uv_fs_req_cleanup(&req); 909 } 910 911 912 static void utime_cb(uv_fs_t* req) { 913 utime_check_t* c; 914 915 ASSERT_PTR_EQ(req, &utime_req); 916 ASSERT_OK(req->result); 917 ASSERT_EQ(req->fs_type, UV_FS_UTIME); 918 919 c = req->data; 920 check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0); 921 922 uv_fs_req_cleanup(req); 923 utime_cb_count++; 924 } 925 926 927 static void futime_cb(uv_fs_t* req) { 928 utime_check_t* c; 929 930 ASSERT_PTR_EQ(req, &futime_req); 931 ASSERT_OK(req->result); 932 ASSERT_EQ(req->fs_type, UV_FS_FUTIME); 933 934 c = req->data; 935 check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0); 936 937 uv_fs_req_cleanup(req); 938 futime_cb_count++; 939 } 940 941 942 static void lutime_cb(uv_fs_t* req) { 943 utime_check_t* c; 944 945 ASSERT_OK(req->result); 946 ASSERT_EQ(req->fs_type, UV_FS_LUTIME); 947 948 c = req->data; 949 check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 1); 950 951 uv_fs_req_cleanup(req); 952 lutime_cb_count++; 953 } 954 955 956 TEST_IMPL(fs_file_async) { 957 int r; 958 959 /* Setup. */ 960 unlink("test_file"); 961 unlink("test_file2"); 962 963 loop = uv_default_loop(); 964 965 r = uv_fs_open(loop, &open_req1, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, 966 S_IRUSR | S_IWUSR, create_cb); 967 ASSERT_OK(r); 968 uv_run(loop, UV_RUN_DEFAULT); 969 970 ASSERT_EQ(1, create_cb_count); 971 ASSERT_EQ(1, write_cb_count); 972 ASSERT_EQ(1, fsync_cb_count); 973 ASSERT_EQ(1, fdatasync_cb_count); 974 ASSERT_EQ(1, close_cb_count); 975 976 r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", rename_cb); 977 ASSERT_OK(r); 978 979 uv_run(loop, UV_RUN_DEFAULT); 980 ASSERT_EQ(1, create_cb_count); 981 ASSERT_EQ(1, write_cb_count); 982 ASSERT_EQ(1, close_cb_count); 983 ASSERT_EQ(1, rename_cb_count); 984 985 r = uv_fs_open(loop, &open_req1, "test_file2", UV_FS_O_RDWR, 0, open_cb); 986 ASSERT_OK(r); 987 988 uv_run(loop, UV_RUN_DEFAULT); 989 ASSERT_EQ(1, open_cb_count); 990 ASSERT_EQ(1, read_cb_count); 991 ASSERT_EQ(2, close_cb_count); 992 ASSERT_EQ(1, rename_cb_count); 993 ASSERT_EQ(1, create_cb_count); 994 ASSERT_EQ(1, write_cb_count); 995 ASSERT_EQ(1, ftruncate_cb_count); 996 997 r = uv_fs_open(loop, &open_req1, "test_file2", UV_FS_O_RDONLY, 0, open_cb); 998 ASSERT_OK(r); 999 1000 uv_run(loop, UV_RUN_DEFAULT); 1001 ASSERT_EQ(2, open_cb_count); 1002 ASSERT_EQ(2, read_cb_count); 1003 ASSERT_EQ(3, close_cb_count); 1004 ASSERT_EQ(1, rename_cb_count); 1005 ASSERT_EQ(1, unlink_cb_count); 1006 ASSERT_EQ(1, create_cb_count); 1007 ASSERT_EQ(1, write_cb_count); 1008 ASSERT_EQ(1, ftruncate_cb_count); 1009 1010 /* Cleanup. */ 1011 unlink("test_file"); 1012 unlink("test_file2"); 1013 1014 MAKE_VALGRIND_HAPPY(loop); 1015 return 0; 1016 } 1017 1018 1019 static void fs_file_sync(int add_flags) { 1020 int r; 1021 1022 /* Setup. */ 1023 unlink("test_file"); 1024 unlink("test_file2"); 1025 1026 loop = uv_default_loop(); 1027 1028 r = uv_fs_open(loop, &open_req1, "test_file", 1029 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, 1030 NULL); 1031 ASSERT_GE(r, 0); 1032 ASSERT_GE(open_req1.result, 0); 1033 uv_fs_req_cleanup(&open_req1); 1034 1035 iov = uv_buf_init(test_buf, sizeof(test_buf)); 1036 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 1037 ASSERT_GE(r, 0); 1038 ASSERT_GE(write_req.result, 0); 1039 uv_fs_req_cleanup(&write_req); 1040 1041 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1042 ASSERT_OK(r); 1043 ASSERT_OK(close_req.result); 1044 uv_fs_req_cleanup(&close_req); 1045 1046 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDWR | add_flags, 0, 1047 NULL); 1048 ASSERT_GE(r, 0); 1049 ASSERT_GE(open_req1.result, 0); 1050 uv_fs_req_cleanup(&open_req1); 1051 1052 iov = uv_buf_init(buf, sizeof(buf)); 1053 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 1054 ASSERT_GE(r, 0); 1055 ASSERT_GE(read_req.result, 0); 1056 ASSERT_OK(strcmp(buf, test_buf)); 1057 uv_fs_req_cleanup(&read_req); 1058 1059 r = uv_fs_ftruncate(NULL, &ftruncate_req, open_req1.result, 7, NULL); 1060 ASSERT_OK(r); 1061 ASSERT_OK(ftruncate_req.result); 1062 uv_fs_req_cleanup(&ftruncate_req); 1063 1064 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1065 ASSERT_OK(r); 1066 ASSERT_OK(close_req.result); 1067 uv_fs_req_cleanup(&close_req); 1068 1069 r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL); 1070 ASSERT_OK(r); 1071 ASSERT_OK(rename_req.result); 1072 uv_fs_req_cleanup(&rename_req); 1073 1074 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDONLY | add_flags, 0, 1075 NULL); 1076 ASSERT_GE(r, 0); 1077 ASSERT_GE(open_req1.result, 0); 1078 uv_fs_req_cleanup(&open_req1); 1079 1080 memset(buf, 0, sizeof(buf)); 1081 iov = uv_buf_init(buf, sizeof(buf)); 1082 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 1083 ASSERT_GE(r, 0); 1084 ASSERT_GE(read_req.result, 0); 1085 ASSERT_OK(strcmp(buf, "test-bu")); 1086 uv_fs_req_cleanup(&read_req); 1087 1088 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1089 ASSERT_OK(r); 1090 ASSERT_OK(close_req.result); 1091 uv_fs_req_cleanup(&close_req); 1092 1093 r = uv_fs_unlink(NULL, &unlink_req, "test_file2", NULL); 1094 ASSERT_OK(r); 1095 ASSERT_OK(unlink_req.result); 1096 uv_fs_req_cleanup(&unlink_req); 1097 1098 /* Cleanup */ 1099 unlink("test_file"); 1100 unlink("test_file2"); 1101 } 1102 TEST_IMPL(fs_file_sync) { 1103 fs_file_sync(0); 1104 fs_file_sync(UV_FS_O_FILEMAP); 1105 1106 MAKE_VALGRIND_HAPPY(uv_default_loop()); 1107 return 0; 1108 } 1109 1110 TEST_IMPL(fs_posix_delete) { 1111 int r; 1112 1113 /* Setup. */ 1114 unlink("test_dir/file"); 1115 rmdir("test_dir"); 1116 1117 r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0755, NULL); 1118 ASSERT_OK(r); 1119 1120 r = uv_fs_open(NULL, &open_req_noclose, "test_dir/file", UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR, NULL); 1121 ASSERT_GE(r, 0); 1122 uv_fs_req_cleanup(&open_req_noclose); 1123 1124 /* should not be possible to delete the non-empty dir */ 1125 r = uv_fs_rmdir(NULL, &rmdir_req, "test_dir", NULL); 1126 ASSERT((r == UV_ENOTEMPTY) || (r == UV_EEXIST)); 1127 ASSERT_EQ(r, rmdir_req.result); 1128 uv_fs_req_cleanup(&rmdir_req); 1129 1130 r = uv_fs_rmdir(NULL, &rmdir_req, "test_dir/file", NULL); 1131 ASSERT((r == UV_ENOTDIR) || (r == UV_ENOENT)); 1132 ASSERT_EQ(r, rmdir_req.result); 1133 uv_fs_req_cleanup(&rmdir_req); 1134 1135 r = uv_fs_unlink(NULL, &unlink_req, "test_dir/file", NULL); 1136 ASSERT_OK(r); 1137 ASSERT_OK(unlink_req.result); 1138 uv_fs_req_cleanup(&unlink_req); 1139 1140 /* delete the dir while the file is still open, which should succeed on posix */ 1141 r = uv_fs_rmdir(NULL, &rmdir_req, "test_dir", NULL); 1142 ASSERT_OK(r); 1143 ASSERT_OK(rmdir_req.result); 1144 uv_fs_req_cleanup(&rmdir_req); 1145 1146 /* Cleanup */ 1147 r = uv_fs_close(NULL, &close_req, open_req_noclose.result, NULL); 1148 ASSERT_OK(r); 1149 uv_fs_req_cleanup(&close_req); 1150 1151 MAKE_VALGRIND_HAPPY(uv_default_loop()); 1152 return 0; 1153 } 1154 1155 static void fs_file_write_null_buffer(int add_flags) { 1156 int r; 1157 1158 /* Setup. */ 1159 unlink("test_file"); 1160 1161 loop = uv_default_loop(); 1162 1163 r = uv_fs_open(NULL, &open_req1, "test_file", 1164 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, 1165 NULL); 1166 ASSERT_GE(r, 0); 1167 ASSERT_GE(open_req1.result, 0); 1168 uv_fs_req_cleanup(&open_req1); 1169 1170 iov = uv_buf_init(NULL, 0); 1171 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 1172 ASSERT_OK(r); 1173 ASSERT_OK(write_req.result); 1174 uv_fs_req_cleanup(&write_req); 1175 1176 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1177 ASSERT_OK(r); 1178 ASSERT_OK(close_req.result); 1179 uv_fs_req_cleanup(&close_req); 1180 1181 unlink("test_file"); 1182 } 1183 TEST_IMPL(fs_file_write_null_buffer) { 1184 fs_file_write_null_buffer(0); 1185 fs_file_write_null_buffer(UV_FS_O_FILEMAP); 1186 1187 MAKE_VALGRIND_HAPPY(loop); 1188 return 0; 1189 } 1190 1191 1192 TEST_IMPL(fs_async_dir) { 1193 int r; 1194 uv_dirent_t dent; 1195 1196 /* Setup */ 1197 unlink("test_dir/file1"); 1198 unlink("test_dir/file2"); 1199 rmdir("test_dir"); 1200 1201 loop = uv_default_loop(); 1202 1203 r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb); 1204 ASSERT_OK(r); 1205 1206 uv_run(loop, UV_RUN_DEFAULT); 1207 ASSERT_EQ(1, mkdir_cb_count); 1208 1209 /* Create 2 files synchronously. */ 1210 r = uv_fs_open(NULL, &open_req1, "test_dir/file1", 1211 UV_FS_O_WRONLY | UV_FS_O_CREAT, 1212 S_IWUSR | S_IRUSR, NULL); 1213 ASSERT_GE(r, 0); 1214 uv_fs_req_cleanup(&open_req1); 1215 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1216 ASSERT_OK(r); 1217 uv_fs_req_cleanup(&close_req); 1218 1219 r = uv_fs_open(NULL, &open_req1, "test_dir/file2", 1220 UV_FS_O_WRONLY | UV_FS_O_CREAT, 1221 S_IWUSR | S_IRUSR, NULL); 1222 ASSERT_GE(r, 0); 1223 uv_fs_req_cleanup(&open_req1); 1224 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1225 ASSERT_OK(r); 1226 uv_fs_req_cleanup(&close_req); 1227 1228 r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, scandir_cb); 1229 ASSERT_OK(r); 1230 1231 uv_run(loop, UV_RUN_DEFAULT); 1232 ASSERT_EQ(1, scandir_cb_count); 1233 1234 /* sync uv_fs_scandir */ 1235 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); 1236 ASSERT_EQ(2, r); 1237 ASSERT_EQ(2, scandir_req.result); 1238 ASSERT(scandir_req.ptr); 1239 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { 1240 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); 1241 assert_is_file_type(dent); 1242 } 1243 uv_fs_req_cleanup(&scandir_req); 1244 ASSERT(!scandir_req.ptr); 1245 1246 r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb); 1247 ASSERT_OK(r); 1248 uv_run(loop, UV_RUN_DEFAULT); 1249 1250 r = uv_fs_stat(loop, &stat_req, "test_dir/", stat_cb); 1251 ASSERT_OK(r); 1252 uv_run(loop, UV_RUN_DEFAULT); 1253 1254 r = uv_fs_lstat(loop, &stat_req, "test_dir", stat_cb); 1255 ASSERT_OK(r); 1256 uv_run(loop, UV_RUN_DEFAULT); 1257 1258 r = uv_fs_lstat(loop, &stat_req, "test_dir/", stat_cb); 1259 ASSERT_OK(r); 1260 uv_run(loop, UV_RUN_DEFAULT); 1261 1262 ASSERT_EQ(4, stat_cb_count); 1263 1264 r = uv_fs_unlink(loop, &unlink_req, "test_dir/file1", unlink_cb); 1265 ASSERT_OK(r); 1266 uv_run(loop, UV_RUN_DEFAULT); 1267 ASSERT_EQ(1, unlink_cb_count); 1268 1269 r = uv_fs_unlink(loop, &unlink_req, "test_dir/file2", unlink_cb); 1270 ASSERT_OK(r); 1271 uv_run(loop, UV_RUN_DEFAULT); 1272 ASSERT_EQ(2, unlink_cb_count); 1273 1274 r = uv_fs_rmdir(loop, &rmdir_req, "test_dir", rmdir_cb); 1275 ASSERT_OK(r); 1276 uv_run(loop, UV_RUN_DEFAULT); 1277 ASSERT_EQ(1, rmdir_cb_count); 1278 1279 /* Cleanup */ 1280 unlink("test_dir/file1"); 1281 unlink("test_dir/file2"); 1282 rmdir("test_dir"); 1283 1284 MAKE_VALGRIND_HAPPY(loop); 1285 return 0; 1286 } 1287 1288 1289 static int test_sendfile(void (*setup)(int), uv_fs_cb cb, size_t expected_size) { 1290 int f, r; 1291 struct stat s1, s2; 1292 uv_fs_t req; 1293 char buf1[1]; 1294 1295 loop = uv_default_loop(); 1296 1297 /* Setup. */ 1298 unlink("test_file"); 1299 unlink("test_file2"); 1300 1301 f = open("test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR); 1302 ASSERT_NE(f, -1); 1303 1304 if (setup != NULL) 1305 setup(f); 1306 1307 r = close(f); 1308 ASSERT_OK(r); 1309 1310 /* Test starts here. */ 1311 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDWR, 0, NULL); 1312 ASSERT_GE(r, 0); 1313 ASSERT_GE(open_req1.result, 0); 1314 uv_fs_req_cleanup(&open_req1); 1315 1316 r = uv_fs_open(NULL, &open_req2, "test_file2", UV_FS_O_WRONLY | UV_FS_O_CREAT, 1317 S_IWUSR | S_IRUSR, NULL); 1318 ASSERT_GE(r, 0); 1319 ASSERT_GE(open_req2.result, 0); 1320 uv_fs_req_cleanup(&open_req2); 1321 1322 r = uv_fs_sendfile(loop, &sendfile_req, open_req2.result, open_req1.result, 1323 1, 131072, cb); 1324 ASSERT_OK(r); 1325 uv_run(loop, UV_RUN_DEFAULT); 1326 1327 ASSERT_EQ(1, sendfile_cb_count); 1328 1329 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 1330 ASSERT_OK(r); 1331 uv_fs_req_cleanup(&close_req); 1332 r = uv_fs_close(NULL, &close_req, open_req2.result, NULL); 1333 ASSERT_OK(r); 1334 uv_fs_req_cleanup(&close_req); 1335 1336 memset(&s1, 0, sizeof(s1)); 1337 memset(&s2, 0, sizeof(s2)); 1338 ASSERT_OK(stat("test_file", &s1)); 1339 ASSERT_OK(stat("test_file2", &s2)); 1340 ASSERT_EQ(s2.st_size, expected_size); 1341 1342 if (expected_size > 0) { 1343 ASSERT_UINT64_EQ(s1.st_size, s2.st_size + 1); 1344 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDWR, 0, NULL); 1345 ASSERT_GE(r, 0); 1346 ASSERT_GE(open_req1.result, 0); 1347 uv_fs_req_cleanup(&open_req1); 1348 1349 memset(buf1, 0, sizeof(buf1)); 1350 iov = uv_buf_init(buf1, sizeof(buf1)); 1351 r = uv_fs_read(NULL, &req, open_req1.result, &iov, 1, -1, NULL); 1352 ASSERT_GE(r, 0); 1353 ASSERT_GE(req.result, 0); 1354 ASSERT_EQ(buf1[0], 'e'); /* 'e' from begin */ 1355 uv_fs_req_cleanup(&req); 1356 } else { 1357 ASSERT_UINT64_EQ(s1.st_size, s2.st_size); 1358 } 1359 1360 /* Cleanup. */ 1361 unlink("test_file"); 1362 unlink("test_file2"); 1363 1364 MAKE_VALGRIND_HAPPY(loop); 1365 return 0; 1366 } 1367 1368 1369 static void sendfile_setup(int f) { 1370 ASSERT_EQ(6, write(f, "begin\n", 6)); 1371 ASSERT_EQ(65542, lseek(f, 65536, SEEK_CUR)); 1372 ASSERT_EQ(4, write(f, "end\n", 4)); 1373 } 1374 1375 1376 TEST_IMPL(fs_async_sendfile) { 1377 return test_sendfile(sendfile_setup, sendfile_cb, 65545); 1378 } 1379 1380 1381 TEST_IMPL(fs_async_sendfile_nodata) { 1382 return test_sendfile(NULL, sendfile_nodata_cb, 0); 1383 } 1384 1385 1386 TEST_IMPL(fs_mkdtemp) { 1387 int r; 1388 const char* path_template = "test_dir_XXXXXX"; 1389 1390 loop = uv_default_loop(); 1391 1392 r = uv_fs_mkdtemp(loop, &mkdtemp_req1, path_template, mkdtemp_cb); 1393 ASSERT_OK(r); 1394 1395 uv_run(loop, UV_RUN_DEFAULT); 1396 ASSERT_EQ(1, mkdtemp_cb_count); 1397 1398 /* sync mkdtemp */ 1399 r = uv_fs_mkdtemp(NULL, &mkdtemp_req2, path_template, NULL); 1400 ASSERT_OK(r); 1401 check_mkdtemp_result(&mkdtemp_req2); 1402 1403 /* mkdtemp return different values on subsequent calls */ 1404 ASSERT_NE(0, strcmp(mkdtemp_req1.path, mkdtemp_req2.path)); 1405 1406 /* Cleanup */ 1407 rmdir(mkdtemp_req1.path); 1408 rmdir(mkdtemp_req2.path); 1409 uv_fs_req_cleanup(&mkdtemp_req1); 1410 uv_fs_req_cleanup(&mkdtemp_req2); 1411 1412 MAKE_VALGRIND_HAPPY(loop); 1413 return 0; 1414 } 1415 1416 1417 TEST_IMPL(fs_mkstemp) { 1418 int r; 1419 int fd; 1420 const char path_template[] = "test_file_XXXXXX"; 1421 uv_fs_t req; 1422 1423 loop = uv_default_loop(); 1424 1425 r = uv_fs_mkstemp(loop, &mkstemp_req1, path_template, mkstemp_cb); 1426 ASSERT_OK(r); 1427 1428 uv_run(loop, UV_RUN_DEFAULT); 1429 ASSERT_EQ(1, mkstemp_cb_count); 1430 1431 /* sync mkstemp */ 1432 r = uv_fs_mkstemp(NULL, &mkstemp_req2, path_template, NULL); 1433 ASSERT_GE(r, 0); 1434 check_mkstemp_result(&mkstemp_req2); 1435 1436 /* mkstemp return different values on subsequent calls */ 1437 ASSERT_NE(0, strcmp(mkstemp_req1.path, mkstemp_req2.path)); 1438 1439 /* invalid template returns EINVAL */ 1440 ASSERT_EQ(UV_EINVAL, uv_fs_mkstemp(NULL, &mkstemp_req3, "test_file", NULL)); 1441 1442 /* Make sure that path is empty string */ 1443 ASSERT_OK(strlen(mkstemp_req3.path)); 1444 1445 uv_fs_req_cleanup(&mkstemp_req3); 1446 1447 /* We can write to the opened file */ 1448 iov = uv_buf_init(test_buf, sizeof(test_buf)); 1449 r = uv_fs_write(NULL, &req, mkstemp_req1.result, &iov, 1, -1, NULL); 1450 ASSERT_EQ(r, sizeof(test_buf)); 1451 ASSERT_EQ(req.result, sizeof(test_buf)); 1452 uv_fs_req_cleanup(&req); 1453 1454 /* Cleanup */ 1455 uv_fs_close(NULL, &req, mkstemp_req1.result, NULL); 1456 uv_fs_req_cleanup(&req); 1457 uv_fs_close(NULL, &req, mkstemp_req2.result, NULL); 1458 uv_fs_req_cleanup(&req); 1459 1460 fd = uv_fs_open(NULL, &req, mkstemp_req1.path, UV_FS_O_RDONLY, 0, NULL); 1461 ASSERT_GE(fd, 0); 1462 uv_fs_req_cleanup(&req); 1463 1464 memset(buf, 0, sizeof(buf)); 1465 iov = uv_buf_init(buf, sizeof(buf)); 1466 r = uv_fs_read(NULL, &req, fd, &iov, 1, -1, NULL); 1467 ASSERT_GE(r, 0); 1468 ASSERT_GE(req.result, 0); 1469 ASSERT_OK(strcmp(buf, test_buf)); 1470 uv_fs_req_cleanup(&req); 1471 1472 uv_fs_close(NULL, &req, fd, NULL); 1473 uv_fs_req_cleanup(&req); 1474 1475 unlink(mkstemp_req1.path); 1476 unlink(mkstemp_req2.path); 1477 uv_fs_req_cleanup(&mkstemp_req1); 1478 uv_fs_req_cleanup(&mkstemp_req2); 1479 1480 MAKE_VALGRIND_HAPPY(loop); 1481 return 0; 1482 } 1483 1484 1485 TEST_IMPL(fs_fstat) { 1486 int r; 1487 uv_fs_t req; 1488 uv_file file; 1489 uv_stat_t* s; 1490 #ifndef _WIN32 1491 struct stat t; 1492 #endif 1493 1494 #if defined(__s390__) && defined(__QEMU__) 1495 /* qemu-user-s390x has this weird bug where statx() reports nanoseconds 1496 * but plain fstat() does not. 1497 */ 1498 RETURN_SKIP("Test does not currently work in QEMU"); 1499 #endif 1500 1501 /* Setup. */ 1502 unlink("test_file"); 1503 1504 loop = uv_default_loop(); 1505 1506 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 1507 S_IWUSR | S_IRUSR, NULL); 1508 ASSERT_GE(r, 0); 1509 ASSERT_GE(req.result, 0); 1510 file = req.result; 1511 uv_fs_req_cleanup(&req); 1512 1513 #ifndef _WIN32 1514 memset(&t, 0, sizeof(t)); 1515 ASSERT_OK(fstat(file, &t)); 1516 ASSERT_OK(uv_fs_fstat(NULL, &req, file, NULL)); 1517 ASSERT_OK(req.result); 1518 s = req.ptr; 1519 # if defined(__APPLE__) 1520 ASSERT_EQ(s->st_birthtim.tv_sec, t.st_birthtimespec.tv_sec); 1521 ASSERT_EQ(s->st_birthtim.tv_nsec, t.st_birthtimespec.tv_nsec); 1522 # elif defined(__linux__) 1523 /* If statx() is supported, the birth time should be equal to the change time 1524 * because we just created the file. On older kernels, it's set to zero. 1525 */ 1526 ASSERT(s->st_birthtim.tv_sec == 0 || 1527 s->st_birthtim.tv_sec == t.st_ctim.tv_sec); 1528 ASSERT(s->st_birthtim.tv_nsec == 0 || 1529 s->st_birthtim.tv_nsec == t.st_ctim.tv_nsec); 1530 # endif 1531 #endif 1532 1533 iov = uv_buf_init(test_buf, sizeof(test_buf)); 1534 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); 1535 ASSERT_EQ(r, sizeof(test_buf)); 1536 ASSERT_EQ(req.result, sizeof(test_buf)); 1537 uv_fs_req_cleanup(&req); 1538 1539 memset(&req.statbuf, 0xaa, sizeof(req.statbuf)); 1540 r = uv_fs_fstat(NULL, &req, file, NULL); 1541 ASSERT_OK(r); 1542 ASSERT_OK(req.result); 1543 s = req.ptr; 1544 ASSERT_EQ(s->st_size, sizeof(test_buf)); 1545 1546 #ifndef _WIN32 1547 r = fstat(file, &t); 1548 ASSERT_OK(r); 1549 1550 ASSERT_EQ(s->st_dev, (uint64_t) t.st_dev); 1551 ASSERT_EQ(s->st_mode, (uint64_t) t.st_mode); 1552 ASSERT_EQ(s->st_nlink, (uint64_t) t.st_nlink); 1553 ASSERT_EQ(s->st_uid, (uint64_t) t.st_uid); 1554 ASSERT_EQ(s->st_gid, (uint64_t) t.st_gid); 1555 ASSERT_EQ(s->st_rdev, (uint64_t) t.st_rdev); 1556 ASSERT_EQ(s->st_ino, (uint64_t) t.st_ino); 1557 ASSERT_EQ(s->st_size, (uint64_t) t.st_size); 1558 ASSERT_EQ(s->st_blksize, (uint64_t) t.st_blksize); 1559 ASSERT_EQ(s->st_blocks, (uint64_t) t.st_blocks); 1560 #if defined(__APPLE__) 1561 ASSERT_EQ(s->st_atim.tv_sec, t.st_atimespec.tv_sec); 1562 ASSERT_EQ(s->st_atim.tv_nsec, t.st_atimespec.tv_nsec); 1563 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtimespec.tv_sec); 1564 ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtimespec.tv_nsec); 1565 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctimespec.tv_sec); 1566 ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctimespec.tv_nsec); 1567 #elif defined(_AIX) || \ 1568 defined(__MVS__) 1569 ASSERT_EQ(s->st_atim.tv_sec, t.st_atime); 1570 ASSERT_OK(s->st_atim.tv_nsec); 1571 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime); 1572 ASSERT_OK(s->st_mtim.tv_nsec); 1573 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime); 1574 ASSERT_OK(s->st_ctim.tv_nsec); 1575 #elif defined(__ANDROID__) 1576 ASSERT_EQ(s->st_atim.tv_sec, t.st_atime); 1577 ASSERT_EQ(s->st_atim.tv_nsec, t.st_atimensec); 1578 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime); 1579 ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtimensec); 1580 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime); 1581 ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctimensec); 1582 #elif defined(__sun) || \ 1583 defined(__DragonFly__) || \ 1584 defined(__FreeBSD__) || \ 1585 defined(__OpenBSD__) || \ 1586 defined(__NetBSD__) || \ 1587 defined(_GNU_SOURCE) || \ 1588 defined(_BSD_SOURCE) || \ 1589 defined(_SVID_SOURCE) || \ 1590 defined(_XOPEN_SOURCE) || \ 1591 defined(_DEFAULT_SOURCE) 1592 ASSERT_EQ(s->st_atim.tv_sec, t.st_atim.tv_sec); 1593 ASSERT_EQ(s->st_atim.tv_nsec, t.st_atim.tv_nsec); 1594 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtim.tv_sec); 1595 ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtim.tv_nsec); 1596 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctim.tv_sec); 1597 ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctim.tv_nsec); 1598 # if defined(__FreeBSD__) || \ 1599 defined(__NetBSD__) 1600 ASSERT_EQ(s->st_birthtim.tv_sec, t.st_birthtim.tv_sec); 1601 ASSERT_EQ(s->st_birthtim.tv_nsec, t.st_birthtim.tv_nsec); 1602 # endif 1603 #else 1604 ASSERT_EQ(s->st_atim.tv_sec, t.st_atime); 1605 ASSERT_OK(s->st_atim.tv_nsec); 1606 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime); 1607 ASSERT_OK(s->st_mtim.tv_nsec); 1608 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime); 1609 ASSERT_OK(s->st_ctim.tv_nsec); 1610 #endif 1611 #endif 1612 1613 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) 1614 ASSERT_EQ(s->st_flags, t.st_flags); 1615 ASSERT_EQ(s->st_gen, t.st_gen); 1616 #else 1617 ASSERT_OK(s->st_flags); 1618 ASSERT_OK(s->st_gen); 1619 #endif 1620 1621 uv_fs_req_cleanup(&req); 1622 1623 /* Now do the uv_fs_fstat call asynchronously */ 1624 r = uv_fs_fstat(loop, &req, file, fstat_cb); 1625 ASSERT_OK(r); 1626 uv_run(loop, UV_RUN_DEFAULT); 1627 ASSERT_EQ(1, fstat_cb_count); 1628 1629 1630 r = uv_fs_close(NULL, &req, file, NULL); 1631 ASSERT_OK(r); 1632 ASSERT_OK(req.result); 1633 uv_fs_req_cleanup(&req); 1634 1635 /* 1636 * Run the loop just to check we don't have make any extraneous uv_ref() 1637 * calls. This should drop out immediately. 1638 */ 1639 uv_run(loop, UV_RUN_DEFAULT); 1640 1641 /* Cleanup. */ 1642 unlink("test_file"); 1643 1644 MAKE_VALGRIND_HAPPY(loop); 1645 return 0; 1646 } 1647 1648 1649 TEST_IMPL(fs_fstat_st_dev) { 1650 uv_fs_t req; 1651 uv_fs_t req_link; 1652 uv_loop_t* loop = uv_default_loop(); 1653 char* test_file = "tmp_st_dev"; 1654 char* symlink_file = "tmp_st_dev_link"; 1655 1656 unlink(test_file); 1657 unlink(symlink_file); 1658 1659 // Create file 1660 int r = uv_fs_open(NULL, &req, test_file, UV_FS_O_RDWR | UV_FS_O_CREAT, 1661 S_IWUSR | S_IRUSR, NULL); 1662 ASSERT_GE(r, 0); 1663 ASSERT_GE(req.result, 0); 1664 uv_fs_req_cleanup(&req); 1665 1666 // Create a symlink 1667 r = uv_fs_symlink(loop, &req, test_file, symlink_file, 0, NULL); 1668 ASSERT_EQ(r, 0); 1669 uv_fs_req_cleanup(&req); 1670 1671 // Call uv_fs_fstat for file 1672 r = uv_fs_stat(loop, &req, test_file, NULL); 1673 ASSERT_EQ(r, 0); 1674 1675 // Call uv_fs_fstat for symlink 1676 r = uv_fs_stat(loop, &req_link, symlink_file, NULL); 1677 ASSERT_EQ(r, 0); 1678 1679 // Compare st_dev 1680 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_dev, ((uv_stat_t*)req_link.ptr)->st_dev); 1681 1682 // Cleanup 1683 uv_fs_req_cleanup(&req); 1684 uv_fs_req_cleanup(&req_link); 1685 unlink(test_file); 1686 unlink(symlink_file); 1687 1688 MAKE_VALGRIND_HAPPY(loop); 1689 return 0; 1690 } 1691 1692 1693 TEST_IMPL(fs_fstat_stdio) { 1694 int fd; 1695 int res; 1696 uv_fs_t req; 1697 #ifdef _WIN32 1698 uv_stat_t* st; 1699 DWORD ft; 1700 #endif 1701 1702 for (fd = 0; fd <= 2; ++fd) { 1703 res = uv_fs_fstat(NULL, &req, fd, NULL); 1704 ASSERT_OK(res); 1705 ASSERT_OK(req.result); 1706 1707 #ifdef _WIN32 1708 st = req.ptr; 1709 ft = uv_guess_handle(fd); 1710 switch (ft) { 1711 case UV_TTY: 1712 case UV_NAMED_PIPE: 1713 ASSERT_EQ(st->st_mode, (ft == UV_TTY ? S_IFCHR : S_IFIFO)); 1714 ASSERT_EQ(1, st->st_nlink); 1715 ASSERT_EQ(st->st_rdev, 1716 (ft == UV_TTY ? FILE_DEVICE_CONSOLE : FILE_DEVICE_NAMED_PIPE) 1717 << 16); 1718 break; 1719 default: 1720 break; 1721 } 1722 #endif 1723 1724 uv_fs_req_cleanup(&req); 1725 } 1726 1727 MAKE_VALGRIND_HAPPY(uv_default_loop()); 1728 return 0; 1729 } 1730 1731 1732 TEST_IMPL(fs_access) { 1733 int r; 1734 uv_fs_t req; 1735 uv_file file; 1736 1737 /* Setup. */ 1738 unlink("test_file"); 1739 rmdir("test_dir"); 1740 1741 loop = uv_default_loop(); 1742 1743 /* File should not exist */ 1744 r = uv_fs_access(NULL, &req, "test_file", F_OK, NULL); 1745 ASSERT_LT(r, 0); 1746 ASSERT_LT(req.result, 0); 1747 uv_fs_req_cleanup(&req); 1748 1749 /* File should not exist */ 1750 r = uv_fs_access(loop, &req, "test_file", F_OK, access_cb); 1751 ASSERT_OK(r); 1752 uv_run(loop, UV_RUN_DEFAULT); 1753 ASSERT_EQ(1, access_cb_count); 1754 access_cb_count = 0; /* reset for the next test */ 1755 1756 /* Create file */ 1757 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 1758 S_IWUSR | S_IRUSR, NULL); 1759 ASSERT_GE(r, 0); 1760 ASSERT_GE(req.result, 0); 1761 file = req.result; 1762 uv_fs_req_cleanup(&req); 1763 1764 /* File should exist */ 1765 r = uv_fs_access(NULL, &req, "test_file", F_OK, NULL); 1766 ASSERT_OK(r); 1767 ASSERT_OK(req.result); 1768 uv_fs_req_cleanup(&req); 1769 1770 /* File should exist */ 1771 r = uv_fs_access(loop, &req, "test_file", F_OK, access_cb); 1772 ASSERT_OK(r); 1773 uv_run(loop, UV_RUN_DEFAULT); 1774 ASSERT_EQ(1, access_cb_count); 1775 access_cb_count = 0; /* reset for the next test */ 1776 1777 /* Close file */ 1778 r = uv_fs_close(NULL, &req, file, NULL); 1779 ASSERT_OK(r); 1780 ASSERT_OK(req.result); 1781 uv_fs_req_cleanup(&req); 1782 1783 /* Directory access */ 1784 r = uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL); 1785 ASSERT_OK(r); 1786 uv_fs_req_cleanup(&req); 1787 1788 r = uv_fs_access(NULL, &req, "test_dir", W_OK, NULL); 1789 ASSERT_OK(r); 1790 ASSERT_OK(req.result); 1791 uv_fs_req_cleanup(&req); 1792 1793 /* 1794 * Run the loop just to check we don't have make any extraneous uv_ref() 1795 * calls. This should drop out immediately. 1796 */ 1797 uv_run(loop, UV_RUN_DEFAULT); 1798 1799 /* Cleanup. */ 1800 unlink("test_file"); 1801 rmdir("test_dir"); 1802 1803 MAKE_VALGRIND_HAPPY(loop); 1804 return 0; 1805 } 1806 1807 1808 TEST_IMPL(fs_chmod) { 1809 int r; 1810 uv_fs_t req; 1811 uv_file file; 1812 1813 /* Setup. */ 1814 unlink("test_file"); 1815 1816 loop = uv_default_loop(); 1817 1818 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 1819 S_IWUSR | S_IRUSR, NULL); 1820 ASSERT_GE(r, 0); 1821 ASSERT_GE(req.result, 0); 1822 file = req.result; 1823 uv_fs_req_cleanup(&req); 1824 1825 iov = uv_buf_init(test_buf, sizeof(test_buf)); 1826 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); 1827 ASSERT_EQ(r, sizeof(test_buf)); 1828 ASSERT_EQ(req.result, sizeof(test_buf)); 1829 uv_fs_req_cleanup(&req); 1830 1831 #ifndef _WIN32 1832 /* Make the file write-only */ 1833 r = uv_fs_chmod(NULL, &req, "test_file", 0200, NULL); 1834 ASSERT_OK(r); 1835 ASSERT_OK(req.result); 1836 uv_fs_req_cleanup(&req); 1837 1838 check_permission("test_file", 0200); 1839 #endif 1840 1841 /* Make the file read-only */ 1842 r = uv_fs_chmod(NULL, &req, "test_file", 0400, NULL); 1843 ASSERT_OK(r); 1844 ASSERT_OK(req.result); 1845 uv_fs_req_cleanup(&req); 1846 1847 check_permission("test_file", 0400); 1848 1849 /* Make the file read+write with sync uv_fs_fchmod */ 1850 r = uv_fs_fchmod(NULL, &req, file, 0600, NULL); 1851 ASSERT_OK(r); 1852 ASSERT_OK(req.result); 1853 uv_fs_req_cleanup(&req); 1854 1855 check_permission("test_file", 0600); 1856 1857 #ifndef _WIN32 1858 /* async chmod */ 1859 { 1860 static int mode = 0200; 1861 req.data = &mode; 1862 } 1863 r = uv_fs_chmod(loop, &req, "test_file", 0200, chmod_cb); 1864 ASSERT_OK(r); 1865 uv_run(loop, UV_RUN_DEFAULT); 1866 ASSERT_EQ(1, chmod_cb_count); 1867 chmod_cb_count = 0; /* reset for the next test */ 1868 #endif 1869 1870 /* async chmod */ 1871 { 1872 static int mode = 0400; 1873 req.data = &mode; 1874 } 1875 r = uv_fs_chmod(loop, &req, "test_file", 0400, chmod_cb); 1876 ASSERT_OK(r); 1877 uv_run(loop, UV_RUN_DEFAULT); 1878 ASSERT_EQ(1, chmod_cb_count); 1879 1880 /* async fchmod */ 1881 { 1882 static int mode = 0600; 1883 req.data = &mode; 1884 } 1885 r = uv_fs_fchmod(loop, &req, file, 0600, fchmod_cb); 1886 ASSERT_OK(r); 1887 uv_run(loop, UV_RUN_DEFAULT); 1888 ASSERT_EQ(1, fchmod_cb_count); 1889 1890 uv_fs_close(loop, &req, file, NULL); 1891 1892 /* 1893 * Run the loop just to check we don't have make any extraneous uv_ref() 1894 * calls. This should drop out immediately. 1895 */ 1896 uv_run(loop, UV_RUN_DEFAULT); 1897 1898 /* Cleanup. */ 1899 unlink("test_file"); 1900 1901 MAKE_VALGRIND_HAPPY(loop); 1902 return 0; 1903 } 1904 1905 1906 TEST_IMPL(fs_unlink_readonly) { 1907 int r; 1908 uv_fs_t req; 1909 uv_file file; 1910 1911 /* Setup. */ 1912 unlink("test_file"); 1913 1914 loop = uv_default_loop(); 1915 1916 r = uv_fs_open(NULL, 1917 &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 1918 S_IWUSR | S_IRUSR, 1919 NULL); 1920 ASSERT_GE(r, 0); 1921 ASSERT_GE(req.result, 0); 1922 file = req.result; 1923 uv_fs_req_cleanup(&req); 1924 1925 iov = uv_buf_init(test_buf, sizeof(test_buf)); 1926 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); 1927 ASSERT_EQ(r, sizeof(test_buf)); 1928 ASSERT_EQ(req.result, sizeof(test_buf)); 1929 uv_fs_req_cleanup(&req); 1930 1931 uv_fs_close(loop, &req, file, NULL); 1932 1933 /* Make the file read-only */ 1934 r = uv_fs_chmod(NULL, &req, "test_file", 0400, NULL); 1935 ASSERT_OK(r); 1936 ASSERT_OK(req.result); 1937 uv_fs_req_cleanup(&req); 1938 1939 check_permission("test_file", 0400); 1940 1941 /* Try to unlink the file */ 1942 r = uv_fs_unlink(NULL, &req, "test_file", NULL); 1943 ASSERT_OK(r); 1944 ASSERT_OK(req.result); 1945 uv_fs_req_cleanup(&req); 1946 1947 /* 1948 * Run the loop just to check we don't have make any extraneous uv_ref() 1949 * calls. This should drop out immediately. 1950 */ 1951 uv_run(loop, UV_RUN_DEFAULT); 1952 1953 /* Cleanup. */ 1954 uv_fs_chmod(NULL, &req, "test_file", 0600, NULL); 1955 uv_fs_req_cleanup(&req); 1956 unlink("test_file"); 1957 1958 MAKE_VALGRIND_HAPPY(loop); 1959 return 0; 1960 } 1961 1962 #ifdef _WIN32 1963 TEST_IMPL(fs_unlink_archive_readonly) { 1964 int r; 1965 uv_fs_t req; 1966 uv_file file; 1967 1968 /* Setup. */ 1969 unlink("test_file"); 1970 1971 loop = uv_default_loop(); 1972 1973 r = uv_fs_open(NULL, 1974 &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 1975 S_IWUSR | S_IRUSR, 1976 NULL); 1977 ASSERT_GE(r, 0); 1978 ASSERT_GE(req.result, 0); 1979 file = req.result; 1980 uv_fs_req_cleanup(&req); 1981 1982 iov = uv_buf_init(test_buf, sizeof(test_buf)); 1983 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); 1984 ASSERT_EQ(r, sizeof(test_buf)); 1985 ASSERT_EQ(req.result, sizeof(test_buf)); 1986 uv_fs_req_cleanup(&req); 1987 1988 uv_fs_close(loop, &req, file, NULL); 1989 1990 /* Make the file read-only and clear archive flag */ 1991 r = SetFileAttributes("test_file", FILE_ATTRIBUTE_READONLY); 1992 ASSERT(r); 1993 uv_fs_req_cleanup(&req); 1994 1995 check_permission("test_file", 0400); 1996 1997 /* Try to unlink the file */ 1998 r = uv_fs_unlink(NULL, &req, "test_file", NULL); 1999 ASSERT_OK(r); 2000 ASSERT_OK(req.result); 2001 uv_fs_req_cleanup(&req); 2002 2003 /* 2004 * Run the loop just to check we don't have make any extraneous uv_ref() 2005 * calls. This should drop out immediately. 2006 */ 2007 uv_run(loop, UV_RUN_DEFAULT); 2008 2009 /* Cleanup. */ 2010 uv_fs_chmod(NULL, &req, "test_file", 0600, NULL); 2011 uv_fs_req_cleanup(&req); 2012 unlink("test_file"); 2013 2014 MAKE_VALGRIND_HAPPY(loop); 2015 return 0; 2016 } 2017 #endif 2018 2019 TEST_IMPL(fs_chown) { 2020 int r; 2021 uv_fs_t req; 2022 uv_file file; 2023 2024 /* Setup. */ 2025 unlink("test_file"); 2026 unlink("test_file_link"); 2027 2028 loop = uv_default_loop(); 2029 2030 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 2031 S_IWUSR | S_IRUSR, NULL); 2032 ASSERT_GE(r, 0); 2033 ASSERT_GE(req.result, 0); 2034 file = req.result; 2035 uv_fs_req_cleanup(&req); 2036 2037 /* sync chown */ 2038 r = uv_fs_chown(NULL, &req, "test_file", -1, -1, NULL); 2039 ASSERT_OK(r); 2040 ASSERT_OK(req.result); 2041 uv_fs_req_cleanup(&req); 2042 2043 /* sync fchown */ 2044 r = uv_fs_fchown(NULL, &req, file, -1, -1, NULL); 2045 ASSERT_OK(r); 2046 ASSERT_OK(req.result); 2047 uv_fs_req_cleanup(&req); 2048 2049 /* async chown */ 2050 r = uv_fs_chown(loop, &req, "test_file", -1, -1, chown_cb); 2051 ASSERT_OK(r); 2052 uv_run(loop, UV_RUN_DEFAULT); 2053 ASSERT_EQ(1, chown_cb_count); 2054 2055 #ifndef __MVS__ 2056 /* chown to root (fail) */ 2057 chown_cb_count = 0; 2058 r = uv_fs_chown(loop, &req, "test_file", 0, 0, chown_root_cb); 2059 ASSERT_OK(r); 2060 uv_run(loop, UV_RUN_DEFAULT); 2061 ASSERT_EQ(1, chown_cb_count); 2062 #endif 2063 2064 /* async fchown */ 2065 r = uv_fs_fchown(loop, &req, file, -1, -1, fchown_cb); 2066 ASSERT_OK(r); 2067 uv_run(loop, UV_RUN_DEFAULT); 2068 ASSERT_EQ(1, fchown_cb_count); 2069 2070 #ifndef __HAIKU__ 2071 /* Haiku doesn't support hardlink */ 2072 /* sync link */ 2073 r = uv_fs_link(NULL, &req, "test_file", "test_file_link", NULL); 2074 ASSERT_OK(r); 2075 ASSERT_OK(req.result); 2076 uv_fs_req_cleanup(&req); 2077 2078 /* sync lchown */ 2079 r = uv_fs_lchown(NULL, &req, "test_file_link", -1, -1, NULL); 2080 ASSERT_OK(r); 2081 ASSERT_OK(req.result); 2082 uv_fs_req_cleanup(&req); 2083 2084 /* async lchown */ 2085 r = uv_fs_lchown(loop, &req, "test_file_link", -1, -1, lchown_cb); 2086 ASSERT_OK(r); 2087 uv_run(loop, UV_RUN_DEFAULT); 2088 ASSERT_EQ(1, lchown_cb_count); 2089 #endif 2090 2091 /* Close file */ 2092 r = uv_fs_close(NULL, &req, file, NULL); 2093 ASSERT_OK(r); 2094 ASSERT_OK(req.result); 2095 uv_fs_req_cleanup(&req); 2096 2097 /* 2098 * Run the loop just to check we don't have make any extraneous uv_ref() 2099 * calls. This should drop out immediately. 2100 */ 2101 uv_run(loop, UV_RUN_DEFAULT); 2102 2103 /* Cleanup. */ 2104 unlink("test_file"); 2105 unlink("test_file_link"); 2106 2107 MAKE_VALGRIND_HAPPY(loop); 2108 return 0; 2109 } 2110 2111 2112 TEST_IMPL(fs_link) { 2113 int r; 2114 uv_fs_t req; 2115 uv_file file; 2116 uv_file link; 2117 2118 /* Setup. */ 2119 unlink("test_file"); 2120 unlink("test_file_link"); 2121 unlink("test_file_link2"); 2122 2123 loop = uv_default_loop(); 2124 2125 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 2126 S_IWUSR | S_IRUSR, NULL); 2127 ASSERT_GE(r, 0); 2128 ASSERT_GE(req.result, 0); 2129 file = req.result; 2130 uv_fs_req_cleanup(&req); 2131 2132 iov = uv_buf_init(test_buf, sizeof(test_buf)); 2133 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); 2134 ASSERT_EQ(r, sizeof(test_buf)); 2135 ASSERT_EQ(req.result, sizeof(test_buf)); 2136 uv_fs_req_cleanup(&req); 2137 2138 uv_fs_close(loop, &req, file, NULL); 2139 2140 /* sync link */ 2141 r = uv_fs_link(NULL, &req, "test_file", "test_file_link", NULL); 2142 ASSERT_OK(r); 2143 ASSERT_OK(req.result); 2144 uv_fs_req_cleanup(&req); 2145 2146 r = uv_fs_open(NULL, &req, "test_file_link", UV_FS_O_RDWR, 0, NULL); 2147 ASSERT_GE(r, 0); 2148 ASSERT_GE(req.result, 0); 2149 link = req.result; 2150 uv_fs_req_cleanup(&req); 2151 2152 memset(buf, 0, sizeof(buf)); 2153 iov = uv_buf_init(buf, sizeof(buf)); 2154 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); 2155 ASSERT_GE(r, 0); 2156 ASSERT_GE(req.result, 0); 2157 ASSERT_OK(strcmp(buf, test_buf)); 2158 2159 close(link); 2160 2161 /* async link */ 2162 r = uv_fs_link(loop, &req, "test_file", "test_file_link2", link_cb); 2163 ASSERT_OK(r); 2164 uv_run(loop, UV_RUN_DEFAULT); 2165 ASSERT_EQ(1, link_cb_count); 2166 2167 r = uv_fs_open(NULL, &req, "test_file_link2", UV_FS_O_RDWR, 0, NULL); 2168 ASSERT_GE(r, 0); 2169 ASSERT_GE(req.result, 0); 2170 link = req.result; 2171 uv_fs_req_cleanup(&req); 2172 2173 memset(buf, 0, sizeof(buf)); 2174 iov = uv_buf_init(buf, sizeof(buf)); 2175 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); 2176 ASSERT_GE(r, 0); 2177 ASSERT_GE(req.result, 0); 2178 ASSERT_OK(strcmp(buf, test_buf)); 2179 2180 uv_fs_close(loop, &req, link, NULL); 2181 2182 /* 2183 * Run the loop just to check we don't have make any extraneous uv_ref() 2184 * calls. This should drop out immediately. 2185 */ 2186 uv_run(loop, UV_RUN_DEFAULT); 2187 2188 /* Cleanup. */ 2189 unlink("test_file"); 2190 unlink("test_file_link"); 2191 unlink("test_file_link2"); 2192 2193 MAKE_VALGRIND_HAPPY(loop); 2194 return 0; 2195 } 2196 2197 2198 TEST_IMPL(fs_readlink) { 2199 /* Must return UV_ENOENT on an inexistent file */ 2200 { 2201 uv_fs_t req; 2202 2203 loop = uv_default_loop(); 2204 ASSERT_OK(uv_fs_readlink(loop, &req, "no_such_file", dummy_cb)); 2205 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); 2206 ASSERT_EQ(1, dummy_cb_count); 2207 ASSERT_NULL(req.ptr); 2208 ASSERT_EQ(req.result, UV_ENOENT); 2209 uv_fs_req_cleanup(&req); 2210 2211 ASSERT_EQ(UV_ENOENT, uv_fs_readlink(NULL, &req, "no_such_file", NULL)); 2212 ASSERT_NULL(req.ptr); 2213 ASSERT_EQ(req.result, UV_ENOENT); 2214 uv_fs_req_cleanup(&req); 2215 } 2216 2217 /* Must return UV_EINVAL on a non-symlink file */ 2218 { 2219 int r; 2220 uv_fs_t req; 2221 uv_file file; 2222 2223 /* Setup */ 2224 2225 /* Create a non-symlink file */ 2226 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 2227 S_IWUSR | S_IRUSR, NULL); 2228 ASSERT_GE(r, 0); 2229 ASSERT_GE(req.result, 0); 2230 file = req.result; 2231 uv_fs_req_cleanup(&req); 2232 2233 r = uv_fs_close(NULL, &req, file, NULL); 2234 ASSERT_OK(r); 2235 ASSERT_OK(req.result); 2236 uv_fs_req_cleanup(&req); 2237 2238 /* Test */ 2239 r = uv_fs_readlink(NULL, &req, "test_file", NULL); 2240 ASSERT_EQ(r, UV_EINVAL); 2241 uv_fs_req_cleanup(&req); 2242 2243 /* Cleanup */ 2244 unlink("test_file"); 2245 } 2246 2247 MAKE_VALGRIND_HAPPY(loop); 2248 return 0; 2249 } 2250 2251 2252 TEST_IMPL(fs_realpath) { 2253 uv_fs_t req; 2254 2255 loop = uv_default_loop(); 2256 ASSERT_OK(uv_fs_realpath(loop, &req, "no_such_file", dummy_cb)); 2257 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); 2258 ASSERT_EQ(1, dummy_cb_count); 2259 ASSERT_NULL(req.ptr); 2260 ASSERT_EQ(req.result, UV_ENOENT); 2261 uv_fs_req_cleanup(&req); 2262 2263 ASSERT_EQ(UV_ENOENT, uv_fs_realpath(NULL, &req, "no_such_file", NULL)); 2264 ASSERT_NULL(req.ptr); 2265 ASSERT_EQ(req.result, UV_ENOENT); 2266 uv_fs_req_cleanup(&req); 2267 2268 MAKE_VALGRIND_HAPPY(loop); 2269 return 0; 2270 } 2271 2272 2273 TEST_IMPL(fs_symlink) { 2274 int r; 2275 uv_fs_t req; 2276 uv_file file; 2277 uv_file link; 2278 char test_file_abs_buf[PATHMAX]; 2279 size_t test_file_abs_size; 2280 2281 /* Setup. */ 2282 unlink("test_file"); 2283 unlink("test_file_symlink"); 2284 unlink("test_file_symlink2"); 2285 unlink("test_file_symlink_symlink"); 2286 unlink("test_file_symlink2_symlink"); 2287 test_file_abs_size = sizeof(test_file_abs_buf); 2288 #ifdef _WIN32 2289 uv_cwd(test_file_abs_buf, &test_file_abs_size); 2290 strcat(test_file_abs_buf, "\\test_file"); 2291 #else 2292 uv_cwd(test_file_abs_buf, &test_file_abs_size); 2293 strcat(test_file_abs_buf, "/test_file"); 2294 #endif 2295 2296 loop = uv_default_loop(); 2297 2298 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 2299 S_IWUSR | S_IRUSR, NULL); 2300 ASSERT_GE(r, 0); 2301 ASSERT_GE(req.result, 0); 2302 file = req.result; 2303 uv_fs_req_cleanup(&req); 2304 2305 iov = uv_buf_init(test_buf, sizeof(test_buf)); 2306 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); 2307 ASSERT_EQ(r, sizeof(test_buf)); 2308 ASSERT_EQ(req.result, sizeof(test_buf)); 2309 uv_fs_req_cleanup(&req); 2310 2311 uv_fs_close(loop, &req, file, NULL); 2312 2313 /* sync symlink */ 2314 r = uv_fs_symlink(NULL, &req, "test_file", "test_file_symlink", 0, NULL); 2315 #ifdef _WIN32 2316 if (r < 0) { 2317 if (r == UV_ENOTSUP) { 2318 /* 2319 * Windows doesn't support symlinks on older versions. 2320 * We just pass the test and bail out early if we get ENOTSUP. 2321 */ 2322 return 0; 2323 } else if (r == UV_EPERM) { 2324 /* 2325 * Creating a symlink is only allowed when running elevated. 2326 * We pass the test and bail out early if we get UV_EPERM. 2327 */ 2328 return 0; 2329 } 2330 } 2331 #endif 2332 ASSERT_OK(r); 2333 ASSERT_OK(req.result); 2334 uv_fs_req_cleanup(&req); 2335 2336 r = uv_fs_open(NULL, &req, "test_file_symlink", UV_FS_O_RDWR, 0, NULL); 2337 ASSERT_GE(r, 0); 2338 ASSERT_GE(req.result, 0); 2339 link = req.result; 2340 uv_fs_req_cleanup(&req); 2341 2342 memset(buf, 0, sizeof(buf)); 2343 iov = uv_buf_init(buf, sizeof(buf)); 2344 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); 2345 ASSERT_GE(r, 0); 2346 ASSERT_GE(req.result, 0); 2347 ASSERT_OK(strcmp(buf, test_buf)); 2348 2349 uv_fs_close(loop, &req, link, NULL); 2350 2351 r = uv_fs_symlink(NULL, 2352 &req, 2353 "test_file_symlink", 2354 "test_file_symlink_symlink", 2355 0, 2356 NULL); 2357 ASSERT_OK(r); 2358 uv_fs_req_cleanup(&req); 2359 2360 #if defined(__MSYS__) 2361 RETURN_SKIP("symlink reading is not supported on MSYS2"); 2362 #endif 2363 2364 r = uv_fs_readlink(NULL, &req, "test_file_symlink_symlink", NULL); 2365 ASSERT_OK(r); 2366 ASSERT_OK(strcmp(req.ptr, "test_file_symlink")); 2367 uv_fs_req_cleanup(&req); 2368 2369 r = uv_fs_realpath(NULL, &req, "test_file_symlink_symlink", NULL); 2370 ASSERT_OK(r); 2371 #ifdef _WIN32 2372 ASSERT_OK(_stricmp(req.ptr, test_file_abs_buf)); 2373 #else 2374 ASSERT_OK(strcmp(req.ptr, test_file_abs_buf)); 2375 #endif 2376 uv_fs_req_cleanup(&req); 2377 2378 /* async link */ 2379 r = uv_fs_symlink(loop, 2380 &req, 2381 "test_file", 2382 "test_file_symlink2", 2383 0, 2384 symlink_cb); 2385 ASSERT_OK(r); 2386 uv_run(loop, UV_RUN_DEFAULT); 2387 ASSERT_EQ(1, symlink_cb_count); 2388 2389 r = uv_fs_open(NULL, &req, "test_file_symlink2", UV_FS_O_RDWR, 0, NULL); 2390 ASSERT_GE(r, 0); 2391 ASSERT_GE(req.result, 0); 2392 link = req.result; 2393 uv_fs_req_cleanup(&req); 2394 2395 memset(buf, 0, sizeof(buf)); 2396 iov = uv_buf_init(buf, sizeof(buf)); 2397 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); 2398 ASSERT_GE(r, 0); 2399 ASSERT_GE(req.result, 0); 2400 ASSERT_OK(strcmp(buf, test_buf)); 2401 2402 uv_fs_close(loop, &req, link, NULL); 2403 2404 r = uv_fs_symlink(NULL, 2405 &req, 2406 "test_file_symlink2", 2407 "test_file_symlink2_symlink", 2408 0, 2409 NULL); 2410 ASSERT_OK(r); 2411 uv_fs_req_cleanup(&req); 2412 2413 r = uv_fs_readlink(loop, &req, "test_file_symlink2_symlink", readlink_cb); 2414 ASSERT_OK(r); 2415 uv_run(loop, UV_RUN_DEFAULT); 2416 ASSERT_EQ(1, readlink_cb_count); 2417 2418 r = uv_fs_realpath(loop, &req, "test_file", realpath_cb); 2419 ASSERT_OK(r); 2420 uv_run(loop, UV_RUN_DEFAULT); 2421 ASSERT_EQ(1, realpath_cb_count); 2422 2423 /* 2424 * Run the loop just to check we don't have make any extraneous uv_ref() 2425 * calls. This should drop out immediately. 2426 */ 2427 uv_run(loop, UV_RUN_DEFAULT); 2428 2429 /* Cleanup. */ 2430 unlink("test_file"); 2431 unlink("test_file_symlink"); 2432 unlink("test_file_symlink_symlink"); 2433 unlink("test_file_symlink2"); 2434 unlink("test_file_symlink2_symlink"); 2435 2436 MAKE_VALGRIND_HAPPY(loop); 2437 return 0; 2438 } 2439 2440 2441 int test_symlink_dir_impl(int type) { 2442 uv_fs_t req; 2443 int r; 2444 char* test_dir; 2445 uv_dirent_t dent; 2446 static char test_dir_abs_buf[PATHMAX]; 2447 size_t test_dir_abs_size; 2448 2449 /* set-up */ 2450 unlink("test_dir/file1"); 2451 unlink("test_dir/file2"); 2452 rmdir("test_dir"); 2453 rmdir("test_dir_symlink"); 2454 test_dir_abs_size = sizeof(test_dir_abs_buf); 2455 2456 loop = uv_default_loop(); 2457 2458 uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL); 2459 uv_fs_req_cleanup(&req); 2460 2461 #ifdef _WIN32 2462 strcpy(test_dir_abs_buf, "\\\\?\\"); 2463 uv_cwd(test_dir_abs_buf + 4, &test_dir_abs_size); 2464 test_dir_abs_size += 4; 2465 strcat(test_dir_abs_buf, "\\test_dir"); 2466 test_dir_abs_size += strlen("\\test_dir"); 2467 test_dir = test_dir_abs_buf; 2468 #else 2469 uv_cwd(test_dir_abs_buf, &test_dir_abs_size); 2470 strcat(test_dir_abs_buf, "/test_dir"); 2471 test_dir_abs_size += strlen("/test_dir"); 2472 test_dir = "test_dir"; 2473 #endif 2474 2475 r = uv_fs_symlink(NULL, &req, test_dir, "test_dir_symlink", type, NULL); 2476 if (type == UV_FS_SYMLINK_DIR && (r == UV_ENOTSUP || r == UV_EPERM)) { 2477 uv_fs_req_cleanup(&req); 2478 RETURN_SKIP("this version of Windows doesn't support unprivileged " 2479 "creation of directory symlinks"); 2480 } 2481 fprintf(stderr, "r == %i\n", r); 2482 ASSERT_OK(r); 2483 ASSERT_OK(req.result); 2484 uv_fs_req_cleanup(&req); 2485 2486 r = uv_fs_stat(NULL, &req, "test_dir_symlink", NULL); 2487 ASSERT_OK(r); 2488 ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFDIR); 2489 uv_fs_req_cleanup(&req); 2490 2491 r = uv_fs_lstat(NULL, &req, "test_dir_symlink", NULL); 2492 ASSERT_OK(r); 2493 #if defined(__MSYS__) 2494 RETURN_SKIP("symlink reading is not supported on MSYS2"); 2495 #endif 2496 ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFLNK); 2497 #ifdef _WIN32 2498 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen(test_dir + 4)); 2499 #else 2500 # ifdef __PASE__ 2501 /* On IBMi PASE, st_size returns the length of the symlink itself. */ 2502 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen("test_dir_symlink")); 2503 # else 2504 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen(test_dir)); 2505 # endif 2506 #endif 2507 uv_fs_req_cleanup(&req); 2508 2509 r = uv_fs_readlink(NULL, &req, "test_dir_symlink", NULL); 2510 ASSERT_OK(r); 2511 #ifdef _WIN32 2512 ASSERT_OK(strcmp(req.ptr, test_dir + 4)); 2513 #else 2514 ASSERT_OK(strcmp(req.ptr, test_dir)); 2515 #endif 2516 uv_fs_req_cleanup(&req); 2517 2518 r = uv_fs_realpath(NULL, &req, "test_dir_symlink", NULL); 2519 ASSERT_OK(r); 2520 #ifdef _WIN32 2521 ASSERT_EQ(strlen(req.ptr), test_dir_abs_size - 4); 2522 ASSERT_OK(_strnicmp(req.ptr, test_dir + 4, test_dir_abs_size - 4)); 2523 #else 2524 ASSERT_OK(strcmp(req.ptr, test_dir_abs_buf)); 2525 #endif 2526 uv_fs_req_cleanup(&req); 2527 2528 r = uv_fs_open(NULL, &open_req1, "test_dir/file1", 2529 UV_FS_O_WRONLY | UV_FS_O_CREAT, 2530 S_IWUSR | S_IRUSR, NULL); 2531 ASSERT_GE(r, 0); 2532 uv_fs_req_cleanup(&open_req1); 2533 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 2534 ASSERT_OK(r); 2535 uv_fs_req_cleanup(&close_req); 2536 2537 r = uv_fs_open(NULL, &open_req1, "test_dir/file2", 2538 UV_FS_O_WRONLY | UV_FS_O_CREAT, 2539 S_IWUSR | S_IRUSR, NULL); 2540 ASSERT_GE(r, 0); 2541 uv_fs_req_cleanup(&open_req1); 2542 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 2543 ASSERT_OK(r); 2544 uv_fs_req_cleanup(&close_req); 2545 2546 r = uv_fs_scandir(NULL, &scandir_req, "test_dir_symlink", 0, NULL); 2547 ASSERT_EQ(2, r); 2548 ASSERT_EQ(2, scandir_req.result); 2549 ASSERT(scandir_req.ptr); 2550 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { 2551 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); 2552 assert_is_file_type(dent); 2553 } 2554 uv_fs_req_cleanup(&scandir_req); 2555 ASSERT(!scandir_req.ptr); 2556 2557 /* unlink will remove the directory symlink */ 2558 r = uv_fs_unlink(NULL, &req, "test_dir_symlink", NULL); 2559 ASSERT_OK(r); 2560 uv_fs_req_cleanup(&req); 2561 2562 r = uv_fs_scandir(NULL, &scandir_req, "test_dir_symlink", 0, NULL); 2563 ASSERT_EQ(r, UV_ENOENT); 2564 uv_fs_req_cleanup(&scandir_req); 2565 2566 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); 2567 ASSERT_EQ(2, r); 2568 ASSERT_EQ(2, scandir_req.result); 2569 ASSERT(scandir_req.ptr); 2570 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { 2571 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); 2572 assert_is_file_type(dent); 2573 } 2574 uv_fs_req_cleanup(&scandir_req); 2575 ASSERT(!scandir_req.ptr); 2576 2577 /* clean-up */ 2578 unlink("test_dir/file1"); 2579 unlink("test_dir/file2"); 2580 rmdir("test_dir"); 2581 rmdir("test_dir_symlink"); 2582 2583 MAKE_VALGRIND_HAPPY(loop); 2584 return 0; 2585 } 2586 2587 TEST_IMPL(fs_symlink_dir) { 2588 return test_symlink_dir_impl(UV_FS_SYMLINK_DIR); 2589 } 2590 2591 TEST_IMPL(fs_symlink_junction) { 2592 return test_symlink_dir_impl(UV_FS_SYMLINK_JUNCTION); 2593 } 2594 2595 #ifdef _WIN32 2596 TEST_IMPL(fs_non_symlink_reparse_point) { 2597 uv_fs_t req; 2598 int r; 2599 HANDLE file_handle; 2600 REPARSE_GUID_DATA_BUFFER reparse_buffer; 2601 DWORD bytes_returned; 2602 uv_dirent_t dent; 2603 2604 /* set-up */ 2605 unlink("test_dir/test_file"); 2606 rmdir("test_dir"); 2607 2608 loop = uv_default_loop(); 2609 2610 uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL); 2611 uv_fs_req_cleanup(&req); 2612 2613 file_handle = CreateFile("test_dir/test_file", 2614 GENERIC_WRITE | FILE_WRITE_ATTRIBUTES, 2615 0, 2616 NULL, 2617 CREATE_ALWAYS, 2618 FILE_FLAG_OPEN_REPARSE_POINT | 2619 FILE_FLAG_BACKUP_SEMANTICS, 2620 NULL); 2621 ASSERT_PTR_NE(file_handle, INVALID_HANDLE_VALUE); 2622 2623 memset(&reparse_buffer, 0, REPARSE_GUID_DATA_BUFFER_HEADER_SIZE); 2624 reparse_buffer.ReparseTag = REPARSE_TAG; 2625 reparse_buffer.ReparseDataLength = 0; 2626 reparse_buffer.ReparseGuid = REPARSE_GUID; 2627 2628 r = DeviceIoControl(file_handle, 2629 FSCTL_SET_REPARSE_POINT, 2630 &reparse_buffer, 2631 REPARSE_GUID_DATA_BUFFER_HEADER_SIZE, 2632 NULL, 2633 0, 2634 &bytes_returned, 2635 NULL); 2636 ASSERT(r); 2637 2638 CloseHandle(file_handle); 2639 2640 r = uv_fs_readlink(NULL, &req, "test_dir/test_file", NULL); 2641 ASSERT(r == UV_EINVAL && GetLastError() == ERROR_SYMLINK_NOT_SUPPORTED); 2642 uv_fs_req_cleanup(&req); 2643 2644 /* 2645 Placeholder tests for exercising the behavior fixed in issue #995. 2646 To run, update the path with the IP address of a Mac with the hard drive 2647 shared via SMB as "Macintosh HD". 2648 2649 r = uv_fs_stat(NULL, &req, "\\\\<mac_ip>\\Macintosh HD\\.DS_Store", NULL); 2650 ASSERT_OK(r); 2651 uv_fs_req_cleanup(&req); 2652 2653 r = uv_fs_lstat(NULL, &req, "\\\\<mac_ip>\\Macintosh HD\\.DS_Store", NULL); 2654 ASSERT_OK(r); 2655 uv_fs_req_cleanup(&req); 2656 */ 2657 2658 /* 2659 uv_fs_stat and uv_fs_lstat can only work on non-symlink reparse 2660 points when a minifilter driver is registered which intercepts 2661 associated filesystem requests. Installing a driver is beyond 2662 the scope of this test. 2663 2664 r = uv_fs_stat(NULL, &req, "test_dir/test_file", NULL); 2665 ASSERT_OK(r); 2666 uv_fs_req_cleanup(&req); 2667 2668 r = uv_fs_lstat(NULL, &req, "test_dir/test_file", NULL); 2669 ASSERT_OK(r); 2670 uv_fs_req_cleanup(&req); 2671 */ 2672 2673 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); 2674 ASSERT_EQ(1, r); 2675 ASSERT_EQ(1, scandir_req.result); 2676 ASSERT(scandir_req.ptr); 2677 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { 2678 ASSERT_OK(strcmp(dent.name, "test_file")); 2679 /* uv_fs_scandir incorrectly identifies non-symlink reparse points 2680 as links because it doesn't open the file and verify the reparse 2681 point tag. The PowerShell Get-ChildItem command shares this 2682 behavior, so it's reasonable to leave it as is. */ 2683 ASSERT_EQ(dent.type, UV_DIRENT_LINK); 2684 } 2685 uv_fs_req_cleanup(&scandir_req); 2686 ASSERT(!scandir_req.ptr); 2687 2688 /* clean-up */ 2689 unlink("test_dir/test_file"); 2690 rmdir("test_dir"); 2691 2692 MAKE_VALGRIND_HAPPY(loop); 2693 return 0; 2694 } 2695 2696 TEST_IMPL(fs_lstat_windows_store_apps) { 2697 uv_loop_t* loop; 2698 char localappdata[MAX_PATH]; 2699 char windowsapps_path[MAX_PATH]; 2700 char file_path[MAX_PATH]; 2701 size_t len; 2702 int r; 2703 uv_fs_t req; 2704 uv_fs_t stat_req; 2705 uv_dirent_t dirent; 2706 2707 loop = uv_default_loop(); 2708 ASSERT_NOT_NULL(loop); 2709 len = sizeof(localappdata); 2710 r = uv_os_getenv("LOCALAPPDATA", localappdata, &len); 2711 if (r == UV_ENOENT) { 2712 MAKE_VALGRIND_HAPPY(loop); 2713 return TEST_SKIP; 2714 } 2715 ASSERT_OK(r); 2716 r = snprintf(windowsapps_path, 2717 sizeof(localappdata), 2718 "%s\\Microsoft\\WindowsApps", 2719 localappdata); 2720 ASSERT_GT(r, 0); 2721 if (uv_fs_opendir(loop, &req, windowsapps_path, NULL) != 0) { 2722 /* If we cannot read the directory, skip the test. */ 2723 MAKE_VALGRIND_HAPPY(loop); 2724 return TEST_SKIP; 2725 } 2726 if (uv_fs_scandir(loop, &req, windowsapps_path, 0, NULL) <= 0) { 2727 MAKE_VALGRIND_HAPPY(loop); 2728 return TEST_SKIP; 2729 } 2730 while (uv_fs_scandir_next(&req, &dirent) != UV_EOF) { 2731 if (dirent.type != UV_DIRENT_LINK) { 2732 continue; 2733 } 2734 if (snprintf(file_path, 2735 sizeof(file_path), 2736 "%s\\%s", 2737 windowsapps_path, 2738 dirent.name) < 0) { 2739 continue; 2740 } 2741 ASSERT_OK(uv_fs_lstat(loop, &stat_req, file_path, NULL)); 2742 } 2743 MAKE_VALGRIND_HAPPY(loop); 2744 return 0; 2745 } 2746 #endif 2747 2748 2749 TEST_IMPL(fs_utime) { 2750 utime_check_t checkme; 2751 const char* path = "test_file"; 2752 double atime; 2753 double mtime; 2754 uv_fs_t req; 2755 int r; 2756 2757 /* Setup. */ 2758 loop = uv_default_loop(); 2759 unlink(path); 2760 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, 2761 S_IWUSR | S_IRUSR, 2762 NULL); 2763 ASSERT_GE(r, 0); 2764 ASSERT_GE(req.result, 0); 2765 uv_fs_req_cleanup(&req); 2766 uv_fs_close(loop, &req, r, NULL); 2767 2768 atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */ 2769 2770 ASSERT_OK(uv_fs_utime(NULL, &req, path, atime, mtime, NULL)); 2771 ASSERT_OK(req.result); 2772 uv_fs_req_cleanup(&req); 2773 check_utime(path, atime, mtime, /* test_lutime */ 0); 2774 2775 ASSERT_OK(uv_fs_utime(NULL, 2776 &req, 2777 path, 2778 UV_FS_UTIME_OMIT, 2779 UV_FS_UTIME_OMIT, 2780 NULL)); 2781 ASSERT_OK(req.result); 2782 uv_fs_req_cleanup(&req); 2783 check_utime(path, atime, mtime, /* test_lutime */ 0); 2784 2785 ASSERT_OK(uv_fs_utime(NULL, 2786 &req, 2787 path, 2788 UV_FS_UTIME_NOW, 2789 UV_FS_UTIME_OMIT, 2790 NULL)); 2791 ASSERT_OK(req.result); 2792 uv_fs_req_cleanup(&req); 2793 check_utime(path, UV_FS_UTIME_NOW, mtime, /* test_lutime */ 0); 2794 2795 ASSERT_OK(uv_fs_utime(NULL, &req, path, atime, mtime, NULL)); 2796 ASSERT_OK(req.result); 2797 uv_fs_req_cleanup(&req); 2798 check_utime(path, atime, mtime, /* test_lutime */ 0); 2799 2800 ASSERT_OK(uv_fs_utime(NULL, 2801 &req, 2802 path, 2803 UV_FS_UTIME_OMIT, 2804 UV_FS_UTIME_NOW, 2805 NULL)); 2806 ASSERT_OK(req.result); 2807 uv_fs_req_cleanup(&req); 2808 check_utime(path, atime, UV_FS_UTIME_NOW, /* test_lutime */ 0); 2809 2810 atime = mtime = 1291404900.25; /* 2010-12-03 20:35:00.25 - mees <3 */ 2811 checkme.path = path; 2812 checkme.atime = atime; 2813 checkme.mtime = mtime; 2814 2815 /* async utime */ 2816 utime_req.data = &checkme; 2817 r = uv_fs_utime(loop, &utime_req, path, atime, mtime, utime_cb); 2818 ASSERT_OK(r); 2819 uv_run(loop, UV_RUN_DEFAULT); 2820 ASSERT_EQ(1, utime_cb_count); 2821 2822 /* Cleanup. */ 2823 unlink(path); 2824 2825 MAKE_VALGRIND_HAPPY(loop); 2826 return 0; 2827 } 2828 2829 2830 TEST_IMPL(fs_utime_round) { 2831 const char path[] = "test_file"; 2832 double atime; 2833 double mtime; 2834 uv_fs_t req; 2835 int r; 2836 2837 loop = uv_default_loop(); 2838 unlink(path); 2839 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, 2840 S_IWUSR | S_IRUSR, 2841 NULL); 2842 ASSERT_GE(r, 0); 2843 ASSERT_GE(req.result, 0); 2844 uv_fs_req_cleanup(&req); 2845 ASSERT_OK(uv_fs_close(loop, &req, r, NULL)); 2846 2847 atime = mtime = -14245440.25; /* 1969-07-20T02:56:00.25Z */ 2848 2849 r = uv_fs_utime(NULL, &req, path, atime, mtime, NULL); 2850 #if !defined(__linux__) && \ 2851 !defined(_WIN32) && \ 2852 !defined(__APPLE__) && \ 2853 !defined(__FreeBSD__) && \ 2854 !defined(__sun) 2855 if (r != 0) { 2856 ASSERT_EQ(r, UV_EINVAL); 2857 RETURN_SKIP("utime on some OS (z/OS, IBM i PASE, AIX) or filesystems may reject pre-epoch timestamps"); 2858 } 2859 #endif 2860 ASSERT_OK(r); 2861 ASSERT_OK(req.result); 2862 uv_fs_req_cleanup(&req); 2863 check_utime(path, atime, mtime, /* test_lutime */ 0); 2864 unlink(path); 2865 2866 MAKE_VALGRIND_HAPPY(loop); 2867 return 0; 2868 } 2869 2870 2871 #ifdef _WIN32 2872 TEST_IMPL(fs_stat_root) { 2873 int r; 2874 2875 r = uv_fs_stat(NULL, &stat_req, "\\", NULL); 2876 ASSERT_OK(r); 2877 2878 r = uv_fs_stat(NULL, &stat_req, "..\\..\\..\\..\\..\\..\\..", NULL); 2879 ASSERT_OK(r); 2880 2881 r = uv_fs_stat(NULL, &stat_req, "..", NULL); 2882 ASSERT_OK(r); 2883 2884 r = uv_fs_stat(NULL, &stat_req, "..\\", NULL); 2885 ASSERT_OK(r); 2886 2887 /* stats the current directory on c: */ 2888 r = uv_fs_stat(NULL, &stat_req, "c:", NULL); 2889 ASSERT_OK(r); 2890 2891 r = uv_fs_stat(NULL, &stat_req, "c:\\", NULL); 2892 ASSERT_OK(r); 2893 2894 r = uv_fs_stat(NULL, &stat_req, "\\\\?\\C:\\", NULL); 2895 ASSERT_OK(r); 2896 2897 MAKE_VALGRIND_HAPPY(uv_default_loop()); 2898 return 0; 2899 } 2900 #endif 2901 2902 2903 TEST_IMPL(fs_futime) { 2904 utime_check_t checkme; 2905 const char* path = "test_file"; 2906 double atime; 2907 double mtime; 2908 uv_file file; 2909 uv_fs_t req; 2910 int r; 2911 #if defined(_AIX) && !defined(_AIX71) 2912 RETURN_SKIP("futime is not implemented for AIX versions below 7.1"); 2913 #endif 2914 2915 /* Setup. */ 2916 loop = uv_default_loop(); 2917 unlink(path); 2918 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, 2919 S_IWUSR | S_IRUSR, 2920 NULL); 2921 ASSERT_GE(r, 0); 2922 ASSERT_GE(req.result, 0); 2923 uv_fs_req_cleanup(&req); 2924 uv_fs_close(loop, &req, r, NULL); 2925 2926 atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */ 2927 2928 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR, 0, NULL); 2929 ASSERT_GE(r, 0); 2930 ASSERT_GE(req.result, 0); 2931 file = req.result; /* FIXME probably not how it's supposed to be used */ 2932 uv_fs_req_cleanup(&req); 2933 2934 r = uv_fs_futime(NULL, &req, file, atime, mtime, NULL); 2935 #if defined(__CYGWIN__) || defined(__MSYS__) 2936 ASSERT_EQ(r, UV_ENOSYS); 2937 RETURN_SKIP("futime not supported on Cygwin"); 2938 #else 2939 ASSERT_OK(r); 2940 ASSERT_OK(req.result); 2941 #endif 2942 uv_fs_req_cleanup(&req); 2943 check_utime(path, atime, mtime, /* test_lutime */ 0); 2944 2945 ASSERT_OK(uv_fs_futime(NULL, 2946 &req, 2947 file, 2948 UV_FS_UTIME_OMIT, 2949 UV_FS_UTIME_OMIT, 2950 NULL)); 2951 ASSERT_OK(req.result); 2952 uv_fs_req_cleanup(&req); 2953 check_utime(path, atime, mtime, /* test_lutime */ 0); 2954 2955 ASSERT_OK(uv_fs_futime(NULL, 2956 &req, 2957 file, 2958 UV_FS_UTIME_NOW, 2959 UV_FS_UTIME_OMIT, 2960 NULL)); 2961 ASSERT_OK(req.result); 2962 uv_fs_req_cleanup(&req); 2963 check_utime(path, UV_FS_UTIME_NOW, mtime, /* test_lutime */ 0); 2964 2965 ASSERT_OK(uv_fs_futime(NULL, &req, file, atime, mtime, NULL)); 2966 ASSERT_OK(req.result); 2967 uv_fs_req_cleanup(&req); 2968 check_utime(path, atime, mtime, /* test_lutime */ 0); 2969 2970 ASSERT_OK(uv_fs_futime(NULL, 2971 &req, 2972 file, 2973 UV_FS_UTIME_OMIT, 2974 UV_FS_UTIME_NOW, 2975 NULL)); 2976 ASSERT_OK(req.result); 2977 uv_fs_req_cleanup(&req); 2978 check_utime(path, atime, UV_FS_UTIME_NOW, /* test_lutime */ 0); 2979 2980 atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */ 2981 2982 checkme.atime = atime; 2983 checkme.mtime = mtime; 2984 checkme.path = path; 2985 2986 /* async futime */ 2987 futime_req.data = &checkme; 2988 r = uv_fs_futime(loop, &futime_req, file, atime, mtime, futime_cb); 2989 ASSERT_OK(r); 2990 uv_run(loop, UV_RUN_DEFAULT); 2991 ASSERT_EQ(1, futime_cb_count); 2992 2993 /* Cleanup. */ 2994 unlink(path); 2995 2996 MAKE_VALGRIND_HAPPY(loop); 2997 return 0; 2998 } 2999 3000 3001 TEST_IMPL(fs_lutime) { 3002 utime_check_t checkme; 3003 const char* path = "test_file"; 3004 const char* symlink_path = "test_file_symlink"; 3005 double atime; 3006 double mtime; 3007 uv_fs_t req; 3008 int r, s; 3009 3010 3011 /* Setup */ 3012 loop = uv_default_loop(); 3013 unlink(path); 3014 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, 3015 S_IWUSR | S_IRUSR, 3016 NULL); 3017 ASSERT_GE(r, 0); 3018 ASSERT_GE(req.result, 0); 3019 uv_fs_req_cleanup(&req); 3020 uv_fs_close(loop, &req, r, NULL); 3021 3022 unlink(symlink_path); 3023 s = uv_fs_symlink(NULL, &req, path, symlink_path, 0, NULL); 3024 #ifdef _WIN32 3025 if (s == UV_EPERM) { 3026 /* 3027 * Creating a symlink before Windows 10 Creators Update was only allowed 3028 * when running elevated console (with admin rights) 3029 */ 3030 RETURN_SKIP( 3031 "Symlink creation requires elevated console (with admin rights)"); 3032 } 3033 #endif 3034 ASSERT_OK(s); 3035 ASSERT_OK(req.result); 3036 uv_fs_req_cleanup(&req); 3037 3038 /* Test the synchronous version. */ 3039 atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */ 3040 3041 r = uv_fs_lutime(NULL, &req, symlink_path, atime, mtime, NULL); 3042 #if (defined(_AIX) && !defined(_AIX71)) || defined(__MVS__) 3043 ASSERT_EQ(r, UV_ENOSYS); 3044 RETURN_SKIP("lutime is not implemented for z/OS and AIX versions below 7.1"); 3045 #endif 3046 ASSERT_OK(r); 3047 ASSERT_OK(req.result); 3048 uv_fs_req_cleanup(&req); 3049 check_utime(symlink_path, atime, mtime, /* test_lutime */ 1); 3050 3051 ASSERT_OK(uv_fs_lutime(NULL, 3052 &req, 3053 symlink_path, 3054 UV_FS_UTIME_OMIT, 3055 UV_FS_UTIME_OMIT, 3056 NULL)); 3057 ASSERT_OK(req.result); 3058 uv_fs_req_cleanup(&req); 3059 check_utime(symlink_path, atime, mtime, /* test_lutime */ 1); 3060 3061 ASSERT_OK(uv_fs_lutime(NULL, 3062 &req, 3063 symlink_path, 3064 UV_FS_UTIME_NOW, 3065 UV_FS_UTIME_OMIT, 3066 NULL)); 3067 ASSERT_OK(req.result); 3068 uv_fs_req_cleanup(&req); 3069 check_utime(symlink_path, UV_FS_UTIME_NOW, mtime, /* test_lutime */ 1); 3070 3071 ASSERT_OK(uv_fs_lutime(NULL, &req, symlink_path, atime, mtime, NULL)); 3072 ASSERT_OK(req.result); 3073 uv_fs_req_cleanup(&req); 3074 check_utime(symlink_path, atime, mtime, /* test_lutime */ 1); 3075 3076 ASSERT_OK(uv_fs_lutime(NULL, 3077 &req, 3078 symlink_path, 3079 UV_FS_UTIME_OMIT, 3080 UV_FS_UTIME_NOW, 3081 NULL)); 3082 ASSERT_OK(req.result); 3083 uv_fs_req_cleanup(&req); 3084 check_utime(symlink_path, atime, UV_FS_UTIME_NOW, /* test_lutime */ 1); 3085 3086 /* Test the asynchronous version. */ 3087 atime = mtime = 1291404900; /* 2010-12-03 20:35:00 */ 3088 3089 checkme.atime = atime; 3090 checkme.mtime = mtime; 3091 checkme.path = symlink_path; 3092 req.data = &checkme; 3093 3094 r = uv_fs_lutime(loop, &req, symlink_path, atime, mtime, lutime_cb); 3095 ASSERT_OK(r); 3096 uv_run(loop, UV_RUN_DEFAULT); 3097 ASSERT_EQ(1, lutime_cb_count); 3098 3099 /* Cleanup. */ 3100 unlink(path); 3101 unlink(symlink_path); 3102 3103 MAKE_VALGRIND_HAPPY(loop); 3104 return 0; 3105 } 3106 3107 3108 TEST_IMPL(fs_stat_missing_path) { 3109 uv_fs_t req; 3110 int r; 3111 3112 loop = uv_default_loop(); 3113 3114 r = uv_fs_stat(NULL, &req, "non_existent_file", NULL); 3115 ASSERT_EQ(r, UV_ENOENT); 3116 ASSERT_EQ(req.result, UV_ENOENT); 3117 uv_fs_req_cleanup(&req); 3118 3119 MAKE_VALGRIND_HAPPY(loop); 3120 return 0; 3121 } 3122 3123 3124 TEST_IMPL(fs_scandir_empty_dir) { 3125 const char* path; 3126 uv_fs_t req; 3127 uv_dirent_t dent; 3128 int r; 3129 3130 path = "./empty_dir/"; 3131 loop = uv_default_loop(); 3132 3133 uv_fs_mkdir(NULL, &req, path, 0777, NULL); 3134 uv_fs_req_cleanup(&req); 3135 3136 /* Fill the req to ensure that required fields are cleaned up */ 3137 memset(&req, 0xdb, sizeof(req)); 3138 3139 r = uv_fs_scandir(NULL, &req, path, 0, NULL); 3140 ASSERT_OK(r); 3141 ASSERT_OK(req.result); 3142 ASSERT_NULL(req.ptr); 3143 ASSERT_EQ(UV_EOF, uv_fs_scandir_next(&req, &dent)); 3144 uv_fs_req_cleanup(&req); 3145 3146 r = uv_fs_scandir(loop, &scandir_req, path, 0, empty_scandir_cb); 3147 ASSERT_OK(r); 3148 3149 ASSERT_OK(scandir_cb_count); 3150 uv_run(loop, UV_RUN_DEFAULT); 3151 ASSERT_EQ(1, scandir_cb_count); 3152 3153 uv_fs_rmdir(NULL, &req, path, NULL); 3154 uv_fs_req_cleanup(&req); 3155 3156 MAKE_VALGRIND_HAPPY(loop); 3157 return 0; 3158 } 3159 3160 3161 TEST_IMPL(fs_scandir_non_existent_dir) { 3162 const char* path; 3163 uv_fs_t req; 3164 uv_dirent_t dent; 3165 int r; 3166 3167 path = "./non_existent_dir/"; 3168 loop = uv_default_loop(); 3169 3170 uv_fs_rmdir(NULL, &req, path, NULL); 3171 uv_fs_req_cleanup(&req); 3172 3173 /* Fill the req to ensure that required fields are cleaned up */ 3174 memset(&req, 0xdb, sizeof(req)); 3175 3176 r = uv_fs_scandir(NULL, &req, path, 0, NULL); 3177 ASSERT_EQ(r, UV_ENOENT); 3178 ASSERT_EQ(req.result, UV_ENOENT); 3179 ASSERT_NULL(req.ptr); 3180 ASSERT_EQ(UV_ENOENT, uv_fs_scandir_next(&req, &dent)); 3181 uv_fs_req_cleanup(&req); 3182 3183 r = uv_fs_scandir(loop, &scandir_req, path, 0, non_existent_scandir_cb); 3184 ASSERT_OK(r); 3185 3186 ASSERT_OK(scandir_cb_count); 3187 uv_run(loop, UV_RUN_DEFAULT); 3188 ASSERT_EQ(1, scandir_cb_count); 3189 3190 MAKE_VALGRIND_HAPPY(loop); 3191 return 0; 3192 } 3193 3194 TEST_IMPL(fs_scandir_file) { 3195 const char* path; 3196 int r; 3197 3198 path = "test/fixtures/empty_file"; 3199 loop = uv_default_loop(); 3200 3201 r = uv_fs_scandir(NULL, &scandir_req, path, 0, NULL); 3202 ASSERT_EQ(r, UV_ENOTDIR); 3203 uv_fs_req_cleanup(&scandir_req); 3204 3205 r = uv_fs_scandir(loop, &scandir_req, path, 0, file_scandir_cb); 3206 ASSERT_OK(r); 3207 3208 ASSERT_OK(scandir_cb_count); 3209 uv_run(loop, UV_RUN_DEFAULT); 3210 ASSERT_EQ(1, scandir_cb_count); 3211 3212 MAKE_VALGRIND_HAPPY(loop); 3213 return 0; 3214 } 3215 3216 3217 /* Run in Valgrind. Should not leak when the iterator isn't exhausted. */ 3218 TEST_IMPL(fs_scandir_early_exit) { 3219 uv_dirent_t d; 3220 uv_fs_t req; 3221 3222 ASSERT_LT(0, uv_fs_scandir(NULL, &req, "test/fixtures/one_file", 0, NULL)); 3223 ASSERT_NE(UV_EOF, uv_fs_scandir_next(&req, &d)); 3224 uv_fs_req_cleanup(&req); 3225 3226 ASSERT_LT(0, uv_fs_scandir(NULL, &req, "test/fixtures", 0, NULL)); 3227 ASSERT_NE(UV_EOF, uv_fs_scandir_next(&req, &d)); 3228 uv_fs_req_cleanup(&req); 3229 3230 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3231 return 0; 3232 } 3233 3234 3235 TEST_IMPL(fs_open_dir) { 3236 const char* path; 3237 uv_fs_t req; 3238 int r, file; 3239 3240 path = "."; 3241 loop = uv_default_loop(); 3242 3243 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDONLY, 0, NULL); 3244 ASSERT_GE(r, 0); 3245 ASSERT_GE(req.result, 0); 3246 ASSERT_NULL(req.ptr); 3247 file = r; 3248 uv_fs_req_cleanup(&req); 3249 3250 r = uv_fs_close(NULL, &req, file, NULL); 3251 ASSERT_OK(r); 3252 3253 r = uv_fs_open(loop, &req, path, UV_FS_O_RDONLY, 0, open_cb_simple); 3254 ASSERT_OK(r); 3255 3256 ASSERT_OK(open_cb_count); 3257 uv_run(loop, UV_RUN_DEFAULT); 3258 ASSERT_EQ(1, open_cb_count); 3259 3260 MAKE_VALGRIND_HAPPY(loop); 3261 return 0; 3262 } 3263 3264 3265 static void fs_file_open_append(int add_flags) { 3266 int r; 3267 3268 /* Setup. */ 3269 unlink("test_file"); 3270 3271 loop = uv_default_loop(); 3272 3273 r = uv_fs_open(NULL, &open_req1, "test_file", 3274 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, 3275 NULL); 3276 ASSERT_GE(r, 0); 3277 ASSERT_GE(open_req1.result, 0); 3278 uv_fs_req_cleanup(&open_req1); 3279 3280 iov = uv_buf_init(test_buf, sizeof(test_buf)); 3281 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 3282 ASSERT_GE(r, 0); 3283 ASSERT_GE(write_req.result, 0); 3284 uv_fs_req_cleanup(&write_req); 3285 3286 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3287 ASSERT_OK(r); 3288 ASSERT_OK(close_req.result); 3289 uv_fs_req_cleanup(&close_req); 3290 3291 r = uv_fs_open(NULL, &open_req1, "test_file", 3292 UV_FS_O_RDWR | UV_FS_O_APPEND | add_flags, 0, NULL); 3293 ASSERT_GE(r, 0); 3294 ASSERT_GE(open_req1.result, 0); 3295 uv_fs_req_cleanup(&open_req1); 3296 3297 iov = uv_buf_init(test_buf, sizeof(test_buf)); 3298 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 3299 ASSERT_GE(r, 0); 3300 ASSERT_GE(write_req.result, 0); 3301 uv_fs_req_cleanup(&write_req); 3302 3303 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3304 ASSERT_OK(r); 3305 ASSERT_OK(close_req.result); 3306 uv_fs_req_cleanup(&close_req); 3307 3308 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 3309 S_IRUSR, NULL); 3310 ASSERT_GE(r, 0); 3311 ASSERT_GE(open_req1.result, 0); 3312 uv_fs_req_cleanup(&open_req1); 3313 3314 iov = uv_buf_init(buf, sizeof(buf)); 3315 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 3316 printf("read = %d\n", r); 3317 ASSERT_EQ(26, r); 3318 ASSERT_EQ(26, read_req.result); 3319 ASSERT_OK(memcmp(buf, 3320 "test-buffer\n\0test-buffer\n\0", 3321 sizeof("test-buffer\n\0test-buffer\n\0") - 1)); 3322 uv_fs_req_cleanup(&read_req); 3323 3324 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3325 ASSERT_OK(r); 3326 ASSERT_OK(close_req.result); 3327 uv_fs_req_cleanup(&close_req); 3328 3329 /* Cleanup */ 3330 unlink("test_file"); 3331 } 3332 TEST_IMPL(fs_file_open_append) { 3333 fs_file_open_append(0); 3334 fs_file_open_append(UV_FS_O_FILEMAP); 3335 3336 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3337 return 0; 3338 } 3339 3340 3341 TEST_IMPL(fs_rename_to_existing_file) { 3342 int r; 3343 3344 /* Setup. */ 3345 unlink("test_file"); 3346 unlink("test_file2"); 3347 3348 loop = uv_default_loop(); 3349 3350 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, 3351 S_IWUSR | S_IRUSR, NULL); 3352 ASSERT_GE(r, 0); 3353 ASSERT_GE(open_req1.result, 0); 3354 uv_fs_req_cleanup(&open_req1); 3355 3356 iov = uv_buf_init(test_buf, sizeof(test_buf)); 3357 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 3358 ASSERT_GE(r, 0); 3359 ASSERT_GE(write_req.result, 0); 3360 uv_fs_req_cleanup(&write_req); 3361 3362 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3363 ASSERT_OK(r); 3364 ASSERT_OK(close_req.result); 3365 uv_fs_req_cleanup(&close_req); 3366 3367 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_WRONLY | UV_FS_O_CREAT, 3368 S_IWUSR | S_IRUSR, NULL); 3369 ASSERT_GE(r, 0); 3370 ASSERT_GE(open_req1.result, 0); 3371 uv_fs_req_cleanup(&open_req1); 3372 3373 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3374 ASSERT_OK(r); 3375 ASSERT_OK(close_req.result); 3376 uv_fs_req_cleanup(&close_req); 3377 3378 r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL); 3379 ASSERT_OK(r); 3380 ASSERT_OK(rename_req.result); 3381 uv_fs_req_cleanup(&rename_req); 3382 3383 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDONLY, 0, NULL); 3384 ASSERT_GE(r, 0); 3385 ASSERT_GE(open_req1.result, 0); 3386 uv_fs_req_cleanup(&open_req1); 3387 3388 memset(buf, 0, sizeof(buf)); 3389 iov = uv_buf_init(buf, sizeof(buf)); 3390 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 3391 ASSERT_GE(r, 0); 3392 ASSERT_GE(read_req.result, 0); 3393 ASSERT_OK(strcmp(buf, test_buf)); 3394 uv_fs_req_cleanup(&read_req); 3395 3396 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3397 ASSERT_OK(r); 3398 ASSERT_OK(close_req.result); 3399 uv_fs_req_cleanup(&close_req); 3400 3401 /* Cleanup */ 3402 unlink("test_file"); 3403 unlink("test_file2"); 3404 3405 MAKE_VALGRIND_HAPPY(loop); 3406 return 0; 3407 } 3408 3409 3410 static void fs_read_bufs(int add_flags) { 3411 char scratch[768]; 3412 uv_buf_t bufs[4]; 3413 3414 ASSERT_LE(0, uv_fs_open(NULL, &open_req1, 3415 "test/fixtures/lorem_ipsum.txt", 3416 UV_FS_O_RDONLY | add_flags, 0, NULL)); 3417 ASSERT_GE(open_req1.result, 0); 3418 uv_fs_req_cleanup(&open_req1); 3419 3420 ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result, 3421 NULL, 0, 0, NULL)); 3422 ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result, 3423 NULL, 1, 0, NULL)); 3424 ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result, 3425 bufs, 0, 0, NULL)); 3426 3427 bufs[0] = uv_buf_init(scratch + 0, 256); 3428 bufs[1] = uv_buf_init(scratch + 256, 256); 3429 bufs[2] = uv_buf_init(scratch + 512, 128); 3430 bufs[3] = uv_buf_init(scratch + 640, 128); 3431 3432 ASSERT_EQ(446, uv_fs_read(NULL, 3433 &read_req, 3434 open_req1.result, 3435 bufs + 0, 3436 2, /* 2x 256 bytes. */ 3437 0, /* Positional read. */ 3438 NULL)); 3439 ASSERT_EQ(446, read_req.result); 3440 uv_fs_req_cleanup(&read_req); 3441 3442 ASSERT_EQ(190, uv_fs_read(NULL, 3443 &read_req, 3444 open_req1.result, 3445 bufs + 2, 3446 2, /* 2x 128 bytes. */ 3447 256, /* Positional read. */ 3448 NULL)); 3449 ASSERT_EQ(read_req.result, /* 446 - 256 */ 190); 3450 uv_fs_req_cleanup(&read_req); 3451 3452 ASSERT_OK(memcmp(bufs[1].base + 0, bufs[2].base, 128)); 3453 ASSERT_OK(memcmp(bufs[1].base + 128, bufs[3].base, 190 - 128)); 3454 3455 ASSERT_OK(uv_fs_close(NULL, &close_req, open_req1.result, NULL)); 3456 ASSERT_OK(close_req.result); 3457 uv_fs_req_cleanup(&close_req); 3458 } 3459 TEST_IMPL(fs_read_bufs) { 3460 fs_read_bufs(0); 3461 fs_read_bufs(UV_FS_O_FILEMAP); 3462 3463 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3464 return 0; 3465 } 3466 3467 3468 static void fs_read_file_eof(int add_flags) { 3469 #if defined(__CYGWIN__) || defined(__MSYS__) 3470 RETURN_SKIP("Cygwin pread at EOF may (incorrectly) return data!"); 3471 #endif 3472 int r; 3473 3474 /* Setup. */ 3475 unlink("test_file"); 3476 3477 loop = uv_default_loop(); 3478 3479 r = uv_fs_open(NULL, &open_req1, "test_file", 3480 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, 3481 NULL); 3482 ASSERT_GE(r, 0); 3483 ASSERT_GE(open_req1.result, 0); 3484 uv_fs_req_cleanup(&open_req1); 3485 3486 iov = uv_buf_init(test_buf, sizeof(test_buf)); 3487 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 3488 ASSERT_GE(r, 0); 3489 ASSERT_GE(write_req.result, 0); 3490 uv_fs_req_cleanup(&write_req); 3491 3492 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3493 ASSERT_OK(r); 3494 ASSERT_OK(close_req.result); 3495 uv_fs_req_cleanup(&close_req); 3496 3497 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0, 3498 NULL); 3499 ASSERT_GE(r, 0); 3500 ASSERT_GE(open_req1.result, 0); 3501 uv_fs_req_cleanup(&open_req1); 3502 3503 memset(buf, 0, sizeof(buf)); 3504 iov = uv_buf_init(buf, sizeof(buf)); 3505 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 3506 ASSERT_GE(r, 0); 3507 ASSERT_GE(read_req.result, 0); 3508 ASSERT_OK(strcmp(buf, test_buf)); 3509 uv_fs_req_cleanup(&read_req); 3510 3511 iov = uv_buf_init(buf, sizeof(buf)); 3512 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 3513 read_req.result, NULL); 3514 ASSERT_OK(r); 3515 ASSERT_OK(read_req.result); 3516 uv_fs_req_cleanup(&read_req); 3517 3518 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3519 ASSERT_OK(r); 3520 ASSERT_OK(close_req.result); 3521 uv_fs_req_cleanup(&close_req); 3522 3523 /* Cleanup */ 3524 unlink("test_file"); 3525 } 3526 TEST_IMPL(fs_read_file_eof) { 3527 fs_read_file_eof(0); 3528 fs_read_file_eof(UV_FS_O_FILEMAP); 3529 3530 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3531 return 0; 3532 } 3533 3534 3535 static void fs_write_multiple_bufs(int add_flags) { 3536 uv_buf_t iovs[2]; 3537 int r; 3538 3539 /* Setup. */ 3540 unlink("test_file"); 3541 3542 loop = uv_default_loop(); 3543 3544 r = uv_fs_open(NULL, &open_req1, "test_file", 3545 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, 3546 NULL); 3547 ASSERT_GE(r, 0); 3548 ASSERT_GE(open_req1.result, 0); 3549 uv_fs_req_cleanup(&open_req1); 3550 3551 iovs[0] = uv_buf_init(test_buf, sizeof(test_buf)); 3552 iovs[1] = uv_buf_init(test_buf2, sizeof(test_buf2)); 3553 r = uv_fs_write(NULL, &write_req, open_req1.result, iovs, 2, 0, NULL); 3554 ASSERT_GE(r, 0); 3555 ASSERT_GE(write_req.result, 0); 3556 uv_fs_req_cleanup(&write_req); 3557 3558 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3559 ASSERT_OK(r); 3560 ASSERT_OK(close_req.result); 3561 uv_fs_req_cleanup(&close_req); 3562 3563 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0, 3564 NULL); 3565 ASSERT_GE(r, 0); 3566 ASSERT_GE(open_req1.result, 0); 3567 uv_fs_req_cleanup(&open_req1); 3568 3569 memset(buf, 0, sizeof(buf)); 3570 memset(buf2, 0, sizeof(buf2)); 3571 /* Read the strings back to separate buffers. */ 3572 iovs[0] = uv_buf_init(buf, sizeof(test_buf)); 3573 iovs[1] = uv_buf_init(buf2, sizeof(test_buf2)); 3574 ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR)); 3575 r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, 2, -1, NULL); 3576 ASSERT_GE(r, 0); 3577 ASSERT_EQ(read_req.result, sizeof(test_buf) + sizeof(test_buf2)); 3578 ASSERT_OK(strcmp(buf, test_buf)); 3579 ASSERT_OK(strcmp(buf2, test_buf2)); 3580 uv_fs_req_cleanup(&read_req); 3581 3582 iov = uv_buf_init(buf, sizeof(buf)); 3583 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 3584 ASSERT_OK(r); 3585 ASSERT_OK(read_req.result); 3586 uv_fs_req_cleanup(&read_req); 3587 3588 /* Read the strings back to separate buffers. */ 3589 iovs[0] = uv_buf_init(buf, sizeof(test_buf)); 3590 iovs[1] = uv_buf_init(buf2, sizeof(test_buf2)); 3591 r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, 2, 0, NULL); 3592 ASSERT_GE(r, 0); 3593 if (read_req.result == sizeof(test_buf)) { 3594 /* Infer that preadv is not available. */ 3595 uv_fs_req_cleanup(&read_req); 3596 r = uv_fs_read(NULL, &read_req, open_req1.result, &iovs[1], 1, read_req.result, NULL); 3597 ASSERT_GE(r, 0); 3598 ASSERT_EQ(read_req.result, sizeof(test_buf2)); 3599 } else { 3600 ASSERT_EQ(read_req.result, sizeof(test_buf) + sizeof(test_buf2)); 3601 } 3602 ASSERT_OK(strcmp(buf, test_buf)); 3603 ASSERT_OK(strcmp(buf2, test_buf2)); 3604 uv_fs_req_cleanup(&read_req); 3605 3606 iov = uv_buf_init(buf, sizeof(buf)); 3607 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 3608 sizeof(test_buf) + sizeof(test_buf2), NULL); 3609 ASSERT_OK(r); 3610 ASSERT_OK(read_req.result); 3611 uv_fs_req_cleanup(&read_req); 3612 3613 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3614 ASSERT_OK(r); 3615 ASSERT_OK(close_req.result); 3616 uv_fs_req_cleanup(&close_req); 3617 3618 /* Cleanup */ 3619 unlink("test_file"); 3620 } 3621 TEST_IMPL(fs_write_multiple_bufs) { 3622 fs_write_multiple_bufs(0); 3623 fs_write_multiple_bufs(UV_FS_O_FILEMAP); 3624 3625 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3626 return 0; 3627 } 3628 3629 3630 static void fs_write_alotof_bufs(int add_flags) { 3631 size_t iovcount; 3632 size_t iovmax; 3633 uv_buf_t* iovs; 3634 char* buffer; 3635 size_t index; 3636 int r; 3637 3638 iovcount = 54321; 3639 3640 /* Setup. */ 3641 unlink("test_file"); 3642 3643 loop = uv_default_loop(); 3644 3645 iovs = malloc(sizeof(*iovs) * iovcount); 3646 ASSERT_NOT_NULL(iovs); 3647 iovmax = uv_test_getiovmax(); 3648 3649 r = uv_fs_open(NULL, 3650 &open_req1, 3651 "test_file", 3652 UV_FS_O_RDWR | UV_FS_O_CREAT | add_flags, 3653 S_IWUSR | S_IRUSR, 3654 NULL); 3655 ASSERT_GE(r, 0); 3656 ASSERT_GE(open_req1.result, 0); 3657 uv_fs_req_cleanup(&open_req1); 3658 3659 for (index = 0; index < iovcount; ++index) 3660 iovs[index] = uv_buf_init(test_buf, sizeof(test_buf)); 3661 3662 r = uv_fs_write(NULL, 3663 &write_req, 3664 open_req1.result, 3665 iovs, 3666 iovcount, 3667 -1, 3668 NULL); 3669 ASSERT_GE(r, 0); 3670 ASSERT_EQ((size_t)write_req.result, sizeof(test_buf) * iovcount); 3671 uv_fs_req_cleanup(&write_req); 3672 3673 /* Read the strings back to separate buffers. */ 3674 buffer = malloc(sizeof(test_buf) * iovcount); 3675 ASSERT_NOT_NULL(buffer); 3676 3677 for (index = 0; index < iovcount; ++index) 3678 iovs[index] = uv_buf_init(buffer + index * sizeof(test_buf), 3679 sizeof(test_buf)); 3680 3681 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3682 ASSERT_OK(r); 3683 ASSERT_OK(close_req.result); 3684 uv_fs_req_cleanup(&close_req); 3685 3686 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0, 3687 NULL); 3688 ASSERT_GE(r, 0); 3689 ASSERT_GE(open_req1.result, 0); 3690 uv_fs_req_cleanup(&open_req1); 3691 3692 r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, iovcount, -1, NULL); 3693 if (iovcount > iovmax) 3694 iovcount = iovmax; 3695 ASSERT_GE(r, 0); 3696 ASSERT_EQ((size_t)read_req.result, sizeof(test_buf) * iovcount); 3697 3698 for (index = 0; index < iovcount; ++index) 3699 ASSERT_OK(strncmp(buffer + index * sizeof(test_buf), 3700 test_buf, 3701 sizeof(test_buf))); 3702 3703 uv_fs_req_cleanup(&read_req); 3704 free(buffer); 3705 3706 ASSERT_EQ(lseek(open_req1.result, write_req.result, SEEK_SET), 3707 write_req.result); 3708 iov = uv_buf_init(buf, sizeof(buf)); 3709 r = uv_fs_read(NULL, 3710 &read_req, 3711 open_req1.result, 3712 &iov, 3713 1, 3714 -1, 3715 NULL); 3716 ASSERT_OK(r); 3717 ASSERT_OK(read_req.result); 3718 uv_fs_req_cleanup(&read_req); 3719 3720 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3721 ASSERT_OK(r); 3722 ASSERT_OK(close_req.result); 3723 uv_fs_req_cleanup(&close_req); 3724 3725 /* Cleanup */ 3726 unlink("test_file"); 3727 free(iovs); 3728 } 3729 TEST_IMPL(fs_write_alotof_bufs) { 3730 fs_write_alotof_bufs(0); 3731 fs_write_alotof_bufs(UV_FS_O_FILEMAP); 3732 3733 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3734 return 0; 3735 } 3736 3737 3738 static void fs_write_alotof_bufs_with_offset(int add_flags) { 3739 size_t iovcount; 3740 size_t iovmax; 3741 uv_buf_t* iovs; 3742 char* buffer; 3743 size_t index; 3744 int r; 3745 int64_t offset; 3746 char* filler; 3747 int filler_len; 3748 3749 filler = "0123456789"; 3750 filler_len = strlen(filler); 3751 iovcount = 54321; 3752 3753 /* Setup. */ 3754 unlink("test_file"); 3755 3756 loop = uv_default_loop(); 3757 3758 iovs = malloc(sizeof(*iovs) * iovcount); 3759 ASSERT_NOT_NULL(iovs); 3760 iovmax = uv_test_getiovmax(); 3761 3762 r = uv_fs_open(NULL, 3763 &open_req1, 3764 "test_file", 3765 UV_FS_O_RDWR | UV_FS_O_CREAT | add_flags, 3766 S_IWUSR | S_IRUSR, 3767 NULL); 3768 ASSERT_GE(r, 0); 3769 ASSERT_GE(open_req1.result, 0); 3770 uv_fs_req_cleanup(&open_req1); 3771 3772 iov = uv_buf_init(filler, filler_len); 3773 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 3774 ASSERT_EQ(r, filler_len); 3775 ASSERT_EQ(write_req.result, filler_len); 3776 uv_fs_req_cleanup(&write_req); 3777 offset = (int64_t)r; 3778 3779 for (index = 0; index < iovcount; ++index) 3780 iovs[index] = uv_buf_init(test_buf, sizeof(test_buf)); 3781 3782 r = uv_fs_write(NULL, 3783 &write_req, 3784 open_req1.result, 3785 iovs, 3786 iovcount, 3787 offset, 3788 NULL); 3789 ASSERT_GE(r, 0); 3790 ASSERT_EQ((size_t)write_req.result, sizeof(test_buf) * iovcount); 3791 uv_fs_req_cleanup(&write_req); 3792 3793 /* Read the strings back to separate buffers. */ 3794 buffer = malloc(sizeof(test_buf) * iovcount); 3795 ASSERT_NOT_NULL(buffer); 3796 3797 for (index = 0; index < iovcount; ++index) 3798 iovs[index] = uv_buf_init(buffer + index * sizeof(test_buf), 3799 sizeof(test_buf)); 3800 3801 r = uv_fs_read(NULL, &read_req, open_req1.result, 3802 iovs, iovcount, offset, NULL); 3803 ASSERT_GE(r, 0); 3804 if (r == sizeof(test_buf)) 3805 iovcount = 1; /* Infer that preadv is not available. */ 3806 else if (iovcount > iovmax) 3807 iovcount = iovmax; 3808 ASSERT_EQ((size_t)read_req.result, sizeof(test_buf) * iovcount); 3809 3810 for (index = 0; index < iovcount; ++index) 3811 ASSERT_OK(strncmp(buffer + index * sizeof(test_buf), 3812 test_buf, 3813 sizeof(test_buf))); 3814 3815 uv_fs_req_cleanup(&read_req); 3816 free(buffer); 3817 3818 r = uv_fs_stat(NULL, &stat_req, "test_file", NULL); 3819 ASSERT_OK(r); 3820 ASSERT_EQ((int64_t)((uv_stat_t*)stat_req.ptr)->st_size, 3821 offset + (int64_t)write_req.result); 3822 uv_fs_req_cleanup(&stat_req); 3823 3824 iov = uv_buf_init(buf, sizeof(buf)); 3825 r = uv_fs_read(NULL, 3826 &read_req, 3827 open_req1.result, 3828 &iov, 3829 1, 3830 offset + write_req.result, 3831 NULL); 3832 ASSERT_OK(r); 3833 ASSERT_OK(read_req.result); 3834 uv_fs_req_cleanup(&read_req); 3835 3836 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3837 ASSERT_OK(r); 3838 ASSERT_OK(close_req.result); 3839 uv_fs_req_cleanup(&close_req); 3840 3841 /* Cleanup */ 3842 unlink("test_file"); 3843 free(iovs); 3844 } 3845 TEST_IMPL(fs_write_alotof_bufs_with_offset) { 3846 fs_write_alotof_bufs_with_offset(0); 3847 fs_write_alotof_bufs_with_offset(UV_FS_O_FILEMAP); 3848 3849 MAKE_VALGRIND_HAPPY(uv_default_loop()); 3850 return 0; 3851 } 3852 3853 TEST_IMPL(fs_read_dir) { 3854 int r; 3855 char buf[2]; 3856 loop = uv_default_loop(); 3857 3858 /* Setup */ 3859 rmdir("test_dir"); 3860 r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb); 3861 ASSERT_OK(r); 3862 uv_run(loop, UV_RUN_DEFAULT); 3863 ASSERT_EQ(1, mkdir_cb_count); 3864 /* Setup Done Here */ 3865 3866 /* Get a file descriptor for the directory */ 3867 r = uv_fs_open(loop, 3868 &open_req1, 3869 "test_dir", 3870 UV_FS_O_RDONLY | UV_FS_O_DIRECTORY, 3871 S_IWUSR | S_IRUSR, 3872 NULL); 3873 ASSERT_GE(r, 0); 3874 uv_fs_req_cleanup(&open_req1); 3875 3876 /* Try to read data from the directory */ 3877 iov = uv_buf_init(buf, sizeof(buf)); 3878 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 0, NULL); 3879 #if defined(__FreeBSD__) || \ 3880 defined(__OpenBSD__) || \ 3881 defined(__NetBSD__) || \ 3882 defined(__DragonFly__) || \ 3883 defined(_AIX) || \ 3884 defined(__sun) || \ 3885 defined(__MVS__) 3886 /* 3887 * As of now, these operating systems support reading from a directory, 3888 * that too depends on the filesystem this temporary test directory is 3889 * created on. That is why this assertion is a bit lenient. 3890 */ 3891 ASSERT((r >= 0) || (r == UV_EISDIR)); 3892 #else 3893 ASSERT_EQ(r, UV_EISDIR); 3894 #endif 3895 uv_fs_req_cleanup(&read_req); 3896 3897 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 3898 ASSERT_OK(r); 3899 uv_fs_req_cleanup(&close_req); 3900 3901 /* Cleanup */ 3902 rmdir("test_dir"); 3903 3904 MAKE_VALGRIND_HAPPY(loop); 3905 return 0; 3906 } 3907 3908 #ifdef _WIN32 3909 3910 TEST_IMPL(fs_partial_read) { 3911 RETURN_SKIP("Test not implemented on Windows."); 3912 } 3913 3914 TEST_IMPL(fs_partial_write) { 3915 RETURN_SKIP("Test not implemented on Windows."); 3916 } 3917 3918 #else /* !_WIN32 */ 3919 3920 struct thread_ctx { 3921 pthread_t pid; 3922 int fd; 3923 char* data; 3924 int size; 3925 int interval; 3926 int doread; 3927 }; 3928 3929 static void thread_main(void* arg) { 3930 const struct thread_ctx* ctx; 3931 int size; 3932 char* data; 3933 3934 ctx = (struct thread_ctx*)arg; 3935 size = ctx->size; 3936 data = ctx->data; 3937 3938 while (size > 0) { 3939 ssize_t result; 3940 int nbytes; 3941 nbytes = size < ctx->interval ? size : ctx->interval; 3942 if (ctx->doread) { 3943 result = write(ctx->fd, data, nbytes); 3944 /* Should not see EINTR (or other errors) */ 3945 ASSERT_EQ(result, nbytes); 3946 } else { 3947 result = read(ctx->fd, data, nbytes); 3948 /* Should not see EINTR (or other errors), 3949 * but might get a partial read if we are faster than the writer 3950 */ 3951 ASSERT(result > 0 && result <= nbytes); 3952 } 3953 3954 pthread_kill(ctx->pid, SIGUSR1); 3955 size -= result; 3956 data += result; 3957 } 3958 } 3959 3960 static void sig_func(uv_signal_t* handle, int signum) { 3961 uv_signal_stop(handle); 3962 } 3963 3964 static size_t uv_test_fs_buf_offset(uv_buf_t* bufs, size_t size) { 3965 size_t offset; 3966 /* Figure out which bufs are done */ 3967 for (offset = 0; size > 0 && bufs[offset].len <= size; ++offset) 3968 size -= bufs[offset].len; 3969 3970 /* Fix a partial read/write */ 3971 if (size > 0) { 3972 bufs[offset].base += size; 3973 bufs[offset].len -= size; 3974 } 3975 return offset; 3976 } 3977 3978 static void test_fs_partial(int doread) { 3979 struct thread_ctx ctx; 3980 uv_thread_t thread; 3981 uv_signal_t signal; 3982 int pipe_fds[2]; 3983 size_t iovcount; 3984 uv_buf_t* iovs; 3985 char* buffer; 3986 size_t index; 3987 3988 iovcount = 54321; 3989 3990 iovs = malloc(sizeof(*iovs) * iovcount); 3991 ASSERT_NOT_NULL(iovs); 3992 3993 ctx.pid = pthread_self(); 3994 ctx.doread = doread; 3995 ctx.interval = 1000; 3996 ctx.size = sizeof(test_buf) * iovcount; 3997 ctx.data = calloc(ctx.size, 1); 3998 ASSERT_NOT_NULL(ctx.data); 3999 buffer = calloc(ctx.size, 1); 4000 ASSERT_NOT_NULL(buffer); 4001 4002 for (index = 0; index < iovcount; ++index) 4003 iovs[index] = uv_buf_init(buffer + index * sizeof(test_buf), sizeof(test_buf)); 4004 4005 loop = uv_default_loop(); 4006 4007 ASSERT_OK(uv_signal_init(loop, &signal)); 4008 ASSERT_OK(uv_signal_start(&signal, sig_func, SIGUSR1)); 4009 4010 ASSERT_OK(pipe(pipe_fds)); 4011 4012 ctx.fd = pipe_fds[doread]; 4013 ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx)); 4014 4015 if (doread) { 4016 uv_buf_t* read_iovs; 4017 int nread; 4018 read_iovs = iovs; 4019 nread = 0; 4020 while (nread < ctx.size) { 4021 int result; 4022 result = uv_fs_read(loop, &read_req, pipe_fds[0], read_iovs, iovcount, -1, NULL); 4023 if (result > 0) { 4024 size_t read_iovcount; 4025 read_iovcount = uv_test_fs_buf_offset(read_iovs, result); 4026 read_iovs += read_iovcount; 4027 iovcount -= read_iovcount; 4028 nread += result; 4029 } else { 4030 ASSERT_EQ(result, UV_EINTR); 4031 } 4032 uv_fs_req_cleanup(&read_req); 4033 } 4034 } else { 4035 int result; 4036 result = uv_fs_write(loop, &write_req, pipe_fds[1], iovs, iovcount, -1, NULL); 4037 ASSERT_EQ(write_req.result, result); 4038 ASSERT_EQ(result, ctx.size); 4039 uv_fs_req_cleanup(&write_req); 4040 } 4041 4042 ASSERT_OK(uv_thread_join(&thread)); 4043 4044 ASSERT_MEM_EQ(buffer, ctx.data, ctx.size); 4045 4046 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); 4047 4048 ASSERT_OK(close(pipe_fds[1])); 4049 uv_close((uv_handle_t*) &signal, NULL); 4050 4051 { /* Make sure we read everything that we wrote. */ 4052 int result; 4053 result = uv_fs_read(loop, &read_req, pipe_fds[0], iovs, 1, -1, NULL); 4054 ASSERT_OK(result); 4055 uv_fs_req_cleanup(&read_req); 4056 } 4057 ASSERT_OK(close(pipe_fds[0])); 4058 4059 free(iovs); 4060 free(buffer); 4061 free(ctx.data); 4062 4063 MAKE_VALGRIND_HAPPY(loop); 4064 } 4065 4066 TEST_IMPL(fs_partial_read) { 4067 test_fs_partial(1); 4068 return 0; 4069 } 4070 4071 TEST_IMPL(fs_partial_write) { 4072 test_fs_partial(0); 4073 return 0; 4074 } 4075 4076 #endif/* _WIN32 */ 4077 4078 TEST_IMPL(fs_read_write_null_arguments) { 4079 int r; 4080 4081 r = uv_fs_read(NULL, &read_req, 0, NULL, 0, -1, NULL); 4082 ASSERT_EQ(r, UV_EINVAL); 4083 uv_fs_req_cleanup(&read_req); 4084 4085 r = uv_fs_write(NULL, &write_req, 0, NULL, 0, -1, NULL); 4086 /* Validate some memory management on failed input validation before sending 4087 fs work to the thread pool. */ 4088 ASSERT_EQ(r, UV_EINVAL); 4089 ASSERT_NULL(write_req.path); 4090 ASSERT_NULL(write_req.ptr); 4091 #ifdef _WIN32 4092 ASSERT_NULL(write_req.file.pathw); 4093 ASSERT_NULL(write_req.fs.info.new_pathw); 4094 ASSERT_NULL(write_req.fs.info.bufs); 4095 #else 4096 ASSERT_NULL(write_req.new_path); 4097 ASSERT_NULL(write_req.bufs); 4098 #endif 4099 uv_fs_req_cleanup(&write_req); 4100 4101 iov = uv_buf_init(NULL, 0); 4102 r = uv_fs_read(NULL, &read_req, 0, &iov, 0, -1, NULL); 4103 ASSERT_EQ(r, UV_EINVAL); 4104 uv_fs_req_cleanup(&read_req); 4105 4106 iov = uv_buf_init(NULL, 0); 4107 r = uv_fs_write(NULL, &write_req, 0, &iov, 0, -1, NULL); 4108 ASSERT_EQ(r, UV_EINVAL); 4109 uv_fs_req_cleanup(&write_req); 4110 4111 /* If the arguments are invalid, the loop should not be kept open */ 4112 loop = uv_default_loop(); 4113 4114 r = uv_fs_read(loop, &read_req, 0, NULL, 0, -1, fail_cb); 4115 ASSERT_EQ(r, UV_EINVAL); 4116 uv_run(loop, UV_RUN_DEFAULT); 4117 uv_fs_req_cleanup(&read_req); 4118 4119 r = uv_fs_write(loop, &write_req, 0, NULL, 0, -1, fail_cb); 4120 ASSERT_EQ(r, UV_EINVAL); 4121 uv_run(loop, UV_RUN_DEFAULT); 4122 uv_fs_req_cleanup(&write_req); 4123 4124 iov = uv_buf_init(NULL, 0); 4125 r = uv_fs_read(loop, &read_req, 0, &iov, 0, -1, fail_cb); 4126 ASSERT_EQ(r, UV_EINVAL); 4127 uv_run(loop, UV_RUN_DEFAULT); 4128 uv_fs_req_cleanup(&read_req); 4129 4130 iov = uv_buf_init(NULL, 0); 4131 r = uv_fs_write(loop, &write_req, 0, &iov, 0, -1, fail_cb); 4132 ASSERT_EQ(r, UV_EINVAL); 4133 uv_run(loop, UV_RUN_DEFAULT); 4134 uv_fs_req_cleanup(&write_req); 4135 4136 MAKE_VALGRIND_HAPPY(loop); 4137 return 0; 4138 } 4139 4140 4141 TEST_IMPL(get_osfhandle_valid_handle) { 4142 int r; 4143 uv_os_fd_t fd; 4144 4145 /* Setup. */ 4146 unlink("test_file"); 4147 4148 loop = uv_default_loop(); 4149 4150 r = uv_fs_open(NULL, 4151 &open_req1, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 4152 S_IWUSR | S_IRUSR, 4153 NULL); 4154 ASSERT_GE(r, 0); 4155 ASSERT_GE(open_req1.result, 0); 4156 uv_fs_req_cleanup(&open_req1); 4157 4158 fd = uv_get_osfhandle(open_req1.result); 4159 #ifdef _WIN32 4160 ASSERT_PTR_NE(fd, INVALID_HANDLE_VALUE); 4161 #else 4162 ASSERT_GE(fd, 0); 4163 #endif 4164 4165 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4166 ASSERT_OK(r); 4167 ASSERT_OK(close_req.result); 4168 uv_fs_req_cleanup(&close_req); 4169 4170 /* Cleanup. */ 4171 unlink("test_file"); 4172 4173 MAKE_VALGRIND_HAPPY(loop); 4174 return 0; 4175 } 4176 4177 TEST_IMPL(open_osfhandle_valid_handle) { 4178 int r; 4179 uv_os_fd_t handle; 4180 int fd; 4181 4182 /* Setup. */ 4183 unlink("test_file"); 4184 4185 loop = uv_default_loop(); 4186 4187 r = uv_fs_open(NULL, 4188 &open_req1, 4189 "test_file", 4190 UV_FS_O_RDWR | UV_FS_O_CREAT, 4191 S_IWUSR | S_IRUSR, 4192 NULL); 4193 ASSERT_GE(r, 0); 4194 ASSERT_GE(open_req1.result, 0); 4195 uv_fs_req_cleanup(&open_req1); 4196 4197 handle = uv_get_osfhandle(open_req1.result); 4198 #ifdef _WIN32 4199 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); 4200 #else 4201 ASSERT_GE(handle, 0); 4202 #endif 4203 4204 fd = uv_open_osfhandle(handle); 4205 #ifdef _WIN32 4206 ASSERT_GT(fd, 0); 4207 #else 4208 ASSERT_EQ(fd, open_req1.result); 4209 #endif 4210 4211 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4212 ASSERT_OK(r); 4213 ASSERT_OK(close_req.result); 4214 uv_fs_req_cleanup(&close_req); 4215 4216 /* Cleanup. */ 4217 unlink("test_file"); 4218 4219 MAKE_VALGRIND_HAPPY(loop); 4220 return 0; 4221 } 4222 4223 TEST_IMPL(fs_file_pos_after_op_with_offset) { 4224 int r; 4225 4226 /* Setup. */ 4227 unlink("test_file"); 4228 loop = uv_default_loop(); 4229 4230 r = uv_fs_open(loop, 4231 &open_req1, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, 4232 S_IWUSR | S_IRUSR, 4233 NULL); 4234 ASSERT_GT(r, 0); 4235 uv_fs_req_cleanup(&open_req1); 4236 4237 iov = uv_buf_init(test_buf, sizeof(test_buf)); 4238 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 0, NULL); 4239 ASSERT_EQ(r, sizeof(test_buf)); 4240 ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR)); 4241 uv_fs_req_cleanup(&write_req); 4242 4243 iov = uv_buf_init(buf, sizeof(buf)); 4244 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 0, NULL); 4245 ASSERT_EQ(r, sizeof(test_buf)); 4246 ASSERT_OK(strcmp(buf, test_buf)); 4247 ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR)); 4248 uv_fs_req_cleanup(&read_req); 4249 4250 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4251 ASSERT_OK(r); 4252 uv_fs_req_cleanup(&close_req); 4253 4254 /* Cleanup */ 4255 unlink("test_file"); 4256 4257 MAKE_VALGRIND_HAPPY(loop); 4258 return 0; 4259 } 4260 4261 #ifdef _WIN32 4262 static void fs_file_pos_common(void) { 4263 int r; 4264 4265 iov = uv_buf_init("abc", 3); 4266 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 4267 ASSERT_EQ(3, r); 4268 uv_fs_req_cleanup(&write_req); 4269 4270 /* Read with offset should not change the position */ 4271 iov = uv_buf_init(buf, 1); 4272 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 1, NULL); 4273 ASSERT_EQ(1, r); 4274 ASSERT_EQ(buf[0], 'b'); 4275 uv_fs_req_cleanup(&read_req); 4276 4277 iov = uv_buf_init(buf, sizeof(buf)); 4278 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 4279 ASSERT_OK(r); 4280 uv_fs_req_cleanup(&read_req); 4281 4282 /* Write without offset should change the position */ 4283 iov = uv_buf_init("d", 1); 4284 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); 4285 ASSERT_EQ(1, r); 4286 uv_fs_req_cleanup(&write_req); 4287 4288 iov = uv_buf_init(buf, sizeof(buf)); 4289 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 4290 ASSERT_OK(r); 4291 uv_fs_req_cleanup(&read_req); 4292 } 4293 4294 static void fs_file_pos_close_check(const char *contents, int size) { 4295 int r; 4296 4297 /* Close */ 4298 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4299 ASSERT_OK(r); 4300 uv_fs_req_cleanup(&close_req); 4301 4302 /* Confirm file contents */ 4303 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY, 0, NULL); 4304 ASSERT_GE(r, 0); 4305 ASSERT_GE(open_req1.result, 0); 4306 uv_fs_req_cleanup(&open_req1); 4307 4308 iov = uv_buf_init(buf, sizeof(buf)); 4309 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 4310 ASSERT_EQ(r, size); 4311 ASSERT_OK(strncmp(buf, contents, size)); 4312 uv_fs_req_cleanup(&read_req); 4313 4314 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4315 ASSERT_OK(r); 4316 uv_fs_req_cleanup(&close_req); 4317 4318 /* Cleanup */ 4319 unlink("test_file"); 4320 } 4321 4322 static void fs_file_pos_write(int add_flags) { 4323 int r; 4324 4325 /* Setup. */ 4326 unlink("test_file"); 4327 4328 r = uv_fs_open(NULL, 4329 &open_req1, 4330 "test_file", 4331 UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_RDWR | add_flags, 4332 S_IWUSR | S_IRUSR, 4333 NULL); 4334 ASSERT_GT(r, 0); 4335 uv_fs_req_cleanup(&open_req1); 4336 4337 fs_file_pos_common(); 4338 4339 /* Write with offset should not change the position */ 4340 iov = uv_buf_init("e", 1); 4341 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 1, NULL); 4342 ASSERT_EQ(1, r); 4343 uv_fs_req_cleanup(&write_req); 4344 4345 iov = uv_buf_init(buf, sizeof(buf)); 4346 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 4347 ASSERT_OK(r); 4348 uv_fs_req_cleanup(&read_req); 4349 4350 fs_file_pos_close_check("aecd", 4); 4351 } 4352 TEST_IMPL(fs_file_pos_write) { 4353 fs_file_pos_write(0); 4354 fs_file_pos_write(UV_FS_O_FILEMAP); 4355 4356 MAKE_VALGRIND_HAPPY(uv_default_loop()); 4357 return 0; 4358 } 4359 4360 static void fs_file_pos_append(int add_flags) { 4361 int r; 4362 4363 /* Setup. */ 4364 unlink("test_file"); 4365 4366 r = uv_fs_open(NULL, 4367 &open_req1, 4368 "test_file", 4369 UV_FS_O_APPEND | UV_FS_O_CREAT | UV_FS_O_RDWR | add_flags, 4370 S_IWUSR | S_IRUSR, 4371 NULL); 4372 ASSERT_GT(r, 0); 4373 uv_fs_req_cleanup(&open_req1); 4374 4375 fs_file_pos_common(); 4376 4377 /* Write with offset appends (ignoring offset) 4378 * but does not change the position */ 4379 iov = uv_buf_init("e", 1); 4380 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 1, NULL); 4381 ASSERT_EQ(1, r); 4382 uv_fs_req_cleanup(&write_req); 4383 4384 iov = uv_buf_init(buf, sizeof(buf)); 4385 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); 4386 ASSERT_EQ(1, r); 4387 ASSERT_EQ(buf[0], 'e'); 4388 uv_fs_req_cleanup(&read_req); 4389 4390 fs_file_pos_close_check("abcde", 5); 4391 } 4392 TEST_IMPL(fs_file_pos_append) { 4393 fs_file_pos_append(0); 4394 fs_file_pos_append(UV_FS_O_FILEMAP); 4395 4396 MAKE_VALGRIND_HAPPY(uv_default_loop()); 4397 return 0; 4398 } 4399 #endif 4400 4401 TEST_IMPL(fs_null_req) { 4402 /* Verify that all fs functions return UV_EINVAL when the request is NULL. */ 4403 int r; 4404 4405 r = uv_fs_open(NULL, NULL, NULL, 0, 0, NULL); 4406 ASSERT_EQ(r, UV_EINVAL); 4407 4408 r = uv_fs_close(NULL, NULL, 0, NULL); 4409 ASSERT_EQ(r, UV_EINVAL); 4410 4411 r = uv_fs_read(NULL, NULL, 0, NULL, 0, -1, NULL); 4412 ASSERT_EQ(r, UV_EINVAL); 4413 4414 r = uv_fs_write(NULL, NULL, 0, NULL, 0, -1, NULL); 4415 ASSERT_EQ(r, UV_EINVAL); 4416 4417 r = uv_fs_unlink(NULL, NULL, NULL, NULL); 4418 ASSERT_EQ(r, UV_EINVAL); 4419 4420 r = uv_fs_mkdir(NULL, NULL, NULL, 0, NULL); 4421 ASSERT_EQ(r, UV_EINVAL); 4422 4423 r = uv_fs_mkdtemp(NULL, NULL, NULL, NULL); 4424 ASSERT_EQ(r, UV_EINVAL); 4425 4426 r = uv_fs_mkstemp(NULL, NULL, NULL, NULL); 4427 ASSERT_EQ(r, UV_EINVAL); 4428 4429 r = uv_fs_rmdir(NULL, NULL, NULL, NULL); 4430 ASSERT_EQ(r, UV_EINVAL); 4431 4432 r = uv_fs_scandir(NULL, NULL, NULL, 0, NULL); 4433 ASSERT_EQ(r, UV_EINVAL); 4434 4435 r = uv_fs_link(NULL, NULL, NULL, NULL, NULL); 4436 ASSERT_EQ(r, UV_EINVAL); 4437 4438 r = uv_fs_symlink(NULL, NULL, NULL, NULL, 0, NULL); 4439 ASSERT_EQ(r, UV_EINVAL); 4440 4441 r = uv_fs_readlink(NULL, NULL, NULL, NULL); 4442 ASSERT_EQ(r, UV_EINVAL); 4443 4444 r = uv_fs_realpath(NULL, NULL, NULL, NULL); 4445 ASSERT_EQ(r, UV_EINVAL); 4446 4447 r = uv_fs_chown(NULL, NULL, NULL, 0, 0, NULL); 4448 ASSERT_EQ(r, UV_EINVAL); 4449 4450 r = uv_fs_fchown(NULL, NULL, 0, 0, 0, NULL); 4451 ASSERT_EQ(r, UV_EINVAL); 4452 4453 r = uv_fs_stat(NULL, NULL, NULL, NULL); 4454 ASSERT_EQ(r, UV_EINVAL); 4455 4456 r = uv_fs_lstat(NULL, NULL, NULL, NULL); 4457 ASSERT_EQ(r, UV_EINVAL); 4458 4459 r = uv_fs_fstat(NULL, NULL, 0, NULL); 4460 ASSERT_EQ(r, UV_EINVAL); 4461 4462 r = uv_fs_rename(NULL, NULL, NULL, NULL, NULL); 4463 ASSERT_EQ(r, UV_EINVAL); 4464 4465 r = uv_fs_fsync(NULL, NULL, 0, NULL); 4466 ASSERT_EQ(r, UV_EINVAL); 4467 4468 r = uv_fs_fdatasync(NULL, NULL, 0, NULL); 4469 ASSERT_EQ(r, UV_EINVAL); 4470 4471 r = uv_fs_ftruncate(NULL, NULL, 0, 0, NULL); 4472 ASSERT_EQ(r, UV_EINVAL); 4473 4474 r = uv_fs_copyfile(NULL, NULL, NULL, NULL, 0, NULL); 4475 ASSERT_EQ(r, UV_EINVAL); 4476 4477 r = uv_fs_sendfile(NULL, NULL, 0, 0, 0, 0, NULL); 4478 ASSERT_EQ(r, UV_EINVAL); 4479 4480 r = uv_fs_access(NULL, NULL, NULL, 0, NULL); 4481 ASSERT_EQ(r, UV_EINVAL); 4482 4483 r = uv_fs_chmod(NULL, NULL, NULL, 0, NULL); 4484 ASSERT_EQ(r, UV_EINVAL); 4485 4486 r = uv_fs_fchmod(NULL, NULL, 0, 0, NULL); 4487 ASSERT_EQ(r, UV_EINVAL); 4488 4489 r = uv_fs_utime(NULL, NULL, NULL, 0.0, 0.0, NULL); 4490 ASSERT_EQ(r, UV_EINVAL); 4491 4492 r = uv_fs_futime(NULL, NULL, 0, 0.0, 0.0, NULL); 4493 ASSERT_EQ(r, UV_EINVAL); 4494 4495 r = uv_fs_statfs(NULL, NULL, NULL, NULL); 4496 ASSERT_EQ(r, UV_EINVAL); 4497 4498 /* This should be a no-op. */ 4499 uv_fs_req_cleanup(NULL); 4500 4501 return 0; 4502 } 4503 4504 #ifdef _WIN32 4505 TEST_IMPL(fs_exclusive_sharing_mode) { 4506 int r; 4507 4508 /* Setup. */ 4509 unlink("test_file"); 4510 4511 ASSERT_GT(UV_FS_O_EXLOCK, 0); 4512 4513 r = uv_fs_open(NULL, 4514 &open_req1, 4515 "test_file", 4516 UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_EXLOCK, 4517 S_IWUSR | S_IRUSR, 4518 NULL); 4519 ASSERT_GE(r, 0); 4520 ASSERT_GE(open_req1.result, 0); 4521 uv_fs_req_cleanup(&open_req1); 4522 4523 r = uv_fs_open(NULL, 4524 &open_req2, 4525 "test_file", UV_FS_O_RDONLY | UV_FS_O_EXLOCK, 4526 S_IWUSR | S_IRUSR, 4527 NULL); 4528 ASSERT_LT(r, 0); 4529 ASSERT_LT(open_req2.result, 0); 4530 uv_fs_req_cleanup(&open_req2); 4531 4532 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4533 ASSERT_OK(r); 4534 ASSERT_OK(close_req.result); 4535 uv_fs_req_cleanup(&close_req); 4536 4537 r = uv_fs_open(NULL, 4538 &open_req2, 4539 "test_file", UV_FS_O_RDONLY | UV_FS_O_EXLOCK, 4540 S_IWUSR | S_IRUSR, 4541 NULL); 4542 ASSERT_GE(r, 0); 4543 ASSERT_GE(open_req2.result, 0); 4544 uv_fs_req_cleanup(&open_req2); 4545 4546 r = uv_fs_close(NULL, &close_req, open_req2.result, NULL); 4547 ASSERT_OK(r); 4548 ASSERT_OK(close_req.result); 4549 uv_fs_req_cleanup(&close_req); 4550 4551 /* Cleanup */ 4552 unlink("test_file"); 4553 4554 MAKE_VALGRIND_HAPPY(uv_default_loop()); 4555 return 0; 4556 } 4557 #endif 4558 4559 #ifdef _WIN32 4560 TEST_IMPL(fs_file_flag_no_buffering) { 4561 int r; 4562 4563 /* Setup. */ 4564 unlink("test_file"); 4565 4566 ASSERT_GT(UV_FS_O_APPEND, 0); 4567 ASSERT_GT(UV_FS_O_CREAT, 0); 4568 ASSERT_GT(UV_FS_O_DIRECT, 0); 4569 ASSERT_GT(UV_FS_O_RDWR, 0); 4570 4571 /* FILE_APPEND_DATA must be excluded from FILE_GENERIC_WRITE: */ 4572 r = uv_fs_open(NULL, 4573 &open_req1, 4574 "test_file", 4575 UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_DIRECT, 4576 S_IWUSR | S_IRUSR, 4577 NULL); 4578 ASSERT_GE(r, 0); 4579 ASSERT_GE(open_req1.result, 0); 4580 uv_fs_req_cleanup(&open_req1); 4581 4582 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4583 ASSERT_OK(r); 4584 ASSERT_OK(close_req.result); 4585 uv_fs_req_cleanup(&close_req); 4586 4587 /* FILE_APPEND_DATA and FILE_FLAG_NO_BUFFERING are mutually exclusive: */ 4588 r = uv_fs_open(NULL, 4589 &open_req2, 4590 "test_file", 4591 UV_FS_O_APPEND | UV_FS_O_DIRECT, 4592 S_IWUSR | S_IRUSR, 4593 NULL); 4594 ASSERT_EQ(r, UV_EINVAL); 4595 ASSERT_EQ(open_req2.result, UV_EINVAL); 4596 uv_fs_req_cleanup(&open_req2); 4597 4598 /* Cleanup */ 4599 unlink("test_file"); 4600 4601 MAKE_VALGRIND_HAPPY(uv_default_loop()); 4602 return 0; 4603 } 4604 #endif 4605 4606 #ifdef _WIN32 4607 int call_icacls(const char* command, ...) { 4608 char icacls_command[1024]; 4609 va_list args; 4610 4611 va_start(args, command); 4612 vsnprintf(icacls_command, ARRAYSIZE(icacls_command), command, args); 4613 va_end(args); 4614 return system(icacls_command); 4615 } 4616 4617 TEST_IMPL(fs_open_readonly_acl) { 4618 uv_passwd_t pwd; 4619 uv_fs_t req; 4620 int r; 4621 4622 /* 4623 Based on Node.js test from 4624 https://github.com/nodejs/node/commit/3ba81e34e86a5c32658e218cb6e65b13e8326bc5 4625 4626 If anything goes wrong, you can delte the test_fle_icacls with: 4627 4628 icacls test_file_icacls /remove "%USERNAME%" /inheritance:e 4629 attrib -r test_file_icacls 4630 del test_file_icacls 4631 */ 4632 4633 /* Setup - clear the ACL and remove the file */ 4634 loop = uv_default_loop(); 4635 r = uv_os_get_passwd(&pwd); 4636 ASSERT_OK(r); 4637 call_icacls("icacls test_file_icacls /remove \"%s\" /inheritance:e", 4638 pwd.username); 4639 uv_fs_chmod(loop, &req, "test_file_icacls", S_IWUSR, NULL); 4640 unlink("test_file_icacls"); 4641 4642 /* Create the file */ 4643 r = uv_fs_open(loop, 4644 &open_req1, 4645 "test_file_icacls", 4646 UV_FS_O_RDONLY | UV_FS_O_CREAT, 4647 S_IRUSR, 4648 NULL); 4649 ASSERT_GE(r, 0); 4650 ASSERT_GE(open_req1.result, 0); 4651 uv_fs_req_cleanup(&open_req1); 4652 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4653 ASSERT_OK(r); 4654 ASSERT_OK(close_req.result); 4655 uv_fs_req_cleanup(&close_req); 4656 4657 /* Set up ACL */ 4658 r = call_icacls("icacls test_file_icacls /inheritance:r /remove \"%s\"", 4659 pwd.username); 4660 if (r != 0) { 4661 goto acl_cleanup; 4662 } 4663 r = call_icacls("icacls test_file_icacls /grant \"%s\":RX", pwd.username); 4664 if (r != 0) { 4665 goto acl_cleanup; 4666 } 4667 4668 /* Try opening the file */ 4669 r = uv_fs_open(NULL, &open_req1, "test_file_icacls", UV_FS_O_RDONLY, 0, 4670 NULL); 4671 if (r < 0) { 4672 goto acl_cleanup; 4673 } 4674 uv_fs_req_cleanup(&open_req1); 4675 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4676 if (r != 0) { 4677 goto acl_cleanup; 4678 } 4679 uv_fs_req_cleanup(&close_req); 4680 4681 acl_cleanup: 4682 /* Cleanup */ 4683 call_icacls("icacls test_file_icacls /remove \"%s\" /inheritance:e", 4684 pwd.username); 4685 unlink("test_file_icacls"); 4686 uv_os_free_passwd(&pwd); 4687 ASSERT_OK(r); 4688 MAKE_VALGRIND_HAPPY(loop); 4689 return 0; 4690 } 4691 4692 TEST_IMPL(fs_stat_no_permission) { 4693 uv_passwd_t pwd; 4694 uv_fs_t req; 4695 int r; 4696 char* filename = "test_file_no_permission.txt"; 4697 4698 /* Setup - clear the ACL and remove the file */ 4699 loop = uv_default_loop(); 4700 r = uv_os_get_passwd(&pwd); 4701 ASSERT_OK(r); 4702 call_icacls("icacls %s /remove *S-1-1-0:(F)", filename); 4703 unlink(filename); 4704 4705 /* Create the file */ 4706 r = uv_fs_open(loop, 4707 &open_req1, 4708 filename, 4709 UV_FS_O_RDONLY | UV_FS_O_CREAT, 4710 S_IRUSR, 4711 NULL); 4712 ASSERT_GE(r, 0); 4713 ASSERT_GE(open_req1.result, 0); 4714 uv_fs_req_cleanup(&open_req1); 4715 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); 4716 ASSERT_OK(r); 4717 ASSERT_OK(close_req.result); 4718 uv_fs_req_cleanup(&close_req); 4719 4720 /* Set up ACL */ 4721 r = call_icacls("icacls %s /deny *S-1-1-0:(F)", filename); 4722 if (r != 0) { 4723 goto acl_cleanup; 4724 } 4725 4726 /* Read file stats */ 4727 r = uv_fs_stat(NULL, &req, filename, NULL); 4728 if (r != 0) { 4729 goto acl_cleanup; 4730 } 4731 4732 uv_fs_req_cleanup(&req); 4733 4734 acl_cleanup: 4735 /* Cleanup */ 4736 call_icacls("icacls %s /reset", filename); 4737 uv_fs_unlink(NULL, &unlink_req, filename, NULL); 4738 uv_fs_req_cleanup(&unlink_req); 4739 unlink(filename); 4740 uv_os_free_passwd(&pwd); 4741 ASSERT_OK(r); 4742 MAKE_VALGRIND_HAPPY(loop); 4743 return 0; 4744 } 4745 #endif 4746 4747 #ifdef _WIN32 4748 TEST_IMPL(fs_fchmod_archive_readonly) { 4749 uv_fs_t req; 4750 uv_file file; 4751 int r; 4752 /* Test clearing read-only flag from files with Archive flag cleared */ 4753 4754 /* Setup*/ 4755 unlink("test_file"); 4756 r = uv_fs_open(NULL, 4757 &req, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, 4758 S_IWUSR | S_IRUSR, 4759 NULL); 4760 ASSERT_GE(r, 0); 4761 ASSERT_GE(req.result, 0); 4762 file = req.result; 4763 uv_fs_req_cleanup(&req); 4764 r = uv_fs_close(NULL, &req, file, NULL); 4765 ASSERT_OK(r); 4766 uv_fs_req_cleanup(&req); 4767 /* Make the file read-only and clear archive flag */ 4768 r = SetFileAttributes("test_file", FILE_ATTRIBUTE_READONLY); 4769 ASSERT(r); 4770 check_permission("test_file", 0400); 4771 /* Try fchmod */ 4772 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDONLY, 0, NULL); 4773 ASSERT_GE(r, 0); 4774 ASSERT_GE(req.result, 0); 4775 file = req.result; 4776 uv_fs_req_cleanup(&req); 4777 r = uv_fs_fchmod(NULL, &req, file, S_IWUSR, NULL); 4778 ASSERT_OK(r); 4779 ASSERT_OK(req.result); 4780 uv_fs_req_cleanup(&req); 4781 r = uv_fs_close(NULL, &req, file, NULL); 4782 ASSERT_OK(r); 4783 uv_fs_req_cleanup(&req); 4784 check_permission("test_file", S_IWUSR); 4785 4786 /* Restore Archive flag for rest of the tests */ 4787 r = SetFileAttributes("test_file", FILE_ATTRIBUTE_ARCHIVE); 4788 ASSERT(r); 4789 4790 return 0; 4791 } 4792 4793 TEST_IMPL(fs_invalid_mkdir_name) { 4794 uv_loop_t* loop; 4795 uv_fs_t req; 4796 int r; 4797 4798 loop = uv_default_loop(); 4799 r = uv_fs_mkdir(loop, &req, "invalid>", 0, NULL); 4800 ASSERT_EQ(r, UV_EINVAL); 4801 ASSERT_EQ(UV_EINVAL, uv_fs_mkdir(loop, &req, "test:lol", 0, NULL)); 4802 4803 return 0; 4804 } 4805 #endif 4806 4807 TEST_IMPL(fs_statfs) { 4808 uv_fs_t req; 4809 int r; 4810 4811 loop = uv_default_loop(); 4812 4813 /* Test the synchronous version. */ 4814 r = uv_fs_statfs(NULL, &req, ".", NULL); 4815 ASSERT_OK(r); 4816 statfs_cb(&req); 4817 ASSERT_EQ(1, statfs_cb_count); 4818 4819 /* Test the asynchronous version. */ 4820 r = uv_fs_statfs(loop, &req, ".", statfs_cb); 4821 ASSERT_OK(r); 4822 uv_run(loop, UV_RUN_DEFAULT); 4823 ASSERT_EQ(2, statfs_cb_count); 4824 4825 MAKE_VALGRIND_HAPPY(loop); 4826 return 0; 4827 } 4828 4829 TEST_IMPL(fs_get_system_error) { 4830 uv_fs_t req; 4831 int r; 4832 int system_error; 4833 4834 r = uv_fs_statfs(NULL, &req, "non_existing_file", NULL); 4835 ASSERT(r); 4836 4837 system_error = uv_fs_get_system_error(&req); 4838 #ifdef _WIN32 4839 ASSERT_EQ(system_error, ERROR_FILE_NOT_FOUND); 4840 #else 4841 ASSERT_EQ(system_error, ENOENT); 4842 #endif 4843 4844 return 0; 4845 } 4846 4847 4848 TEST_IMPL(fs_stat_batch_multiple) { 4849 uv_fs_t req[300]; 4850 int r; 4851 int i; 4852 4853 rmdir("test_dir"); 4854 4855 r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0755, NULL); 4856 ASSERT_OK(r); 4857 4858 loop = uv_default_loop(); 4859 4860 for (i = 0; i < (int) ARRAY_SIZE(req); ++i) { 4861 r = uv_fs_stat(loop, &req[i], "test_dir", stat_batch_cb); 4862 ASSERT_OK(r); 4863 } 4864 4865 uv_run(loop, UV_RUN_DEFAULT); 4866 ASSERT_EQ(stat_cb_count, ARRAY_SIZE(req)); 4867 4868 MAKE_VALGRIND_HAPPY(loop); 4869 return 0; 4870 } 4871 4872 4873 #ifdef _WIN32 4874 TEST_IMPL(fs_wtf) { 4875 int r; 4876 HANDLE file_handle; 4877 uv_dirent_t dent; 4878 static char test_file_buf[PATHMAX]; 4879 4880 /* set-up */ 4881 _wunlink(L"test_dir/hi\xD801\x0037"); 4882 rmdir("test_dir"); 4883 4884 loop = uv_default_loop(); 4885 4886 r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0777, NULL); 4887 ASSERT_OK(r); 4888 uv_fs_req_cleanup(&mkdir_req); 4889 4890 file_handle = CreateFileW(L"test_dir/hi\xD801\x0037", 4891 GENERIC_WRITE | FILE_WRITE_ATTRIBUTES, 4892 0, 4893 NULL, 4894 CREATE_ALWAYS, 4895 FILE_FLAG_OPEN_REPARSE_POINT | 4896 FILE_FLAG_BACKUP_SEMANTICS, 4897 NULL); 4898 ASSERT_PTR_NE(file_handle, INVALID_HANDLE_VALUE); 4899 4900 CloseHandle(file_handle); 4901 4902 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); 4903 ASSERT_EQ(1, r); 4904 ASSERT_EQ(1, scandir_req.result); 4905 ASSERT_NOT_NULL(scandir_req.ptr); 4906 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { 4907 snprintf(test_file_buf, sizeof(test_file_buf), "test_dir\\%s", dent.name); 4908 printf("stat %s\n", test_file_buf); 4909 r = uv_fs_stat(NULL, &stat_req, test_file_buf, NULL); 4910 ASSERT_OK(r); 4911 } 4912 uv_fs_req_cleanup(&scandir_req); 4913 ASSERT_NULL(scandir_req.ptr); 4914 4915 /* clean-up */ 4916 _wunlink(L"test_dir/hi\xD801\x0037"); 4917 rmdir("test_dir"); 4918 4919 MAKE_VALGRIND_HAPPY(loop); 4920 return 0; 4921 } 4922 #endif 4923
Indexes created Mon Mar 30 00:23:01 UTC 2026