Lines Matching refs:req
40 #include "req-inl.h"
52 if (req == NULL) \
54 uv__fs_req_init(loop, req, subtype, cb); \
61 uv__req_register(loop, req); \
63 &req->work_req, \
69 uv__fs_work(&req->work_req); \
70 return req->result; \
75 #define SET_REQ_RESULT(req, result_value) \
77 req->result = (result_value); \
78 assert(req->result != -1); \
81 #define SET_REQ_WIN32_ERROR(req, sys_errno) \
83 req->sys_errno_ = (sys_errno); \
84 req->result = uv_translate_sys_error(req->sys_errno_); \
87 #define SET_REQ_UV_ERROR(req, uv_errno, sys_errno) \
89 req->result = (uv_errno); \
90 req->sys_errno_ = (sys_errno); \
93 #define VERIFY_FD(fd, req) \
95 req->result = UV_EBADF; \
96 req->sys_errno_ = ERROR_INVALID_HANDLE; \
287 INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
320 req->file.pathw = NULL;
321 req->fs.info.new_pathw = NULL;
322 req->path = NULL;
335 req->file.pathw = pos;
338 req->file.pathw = NULL;
343 req->fs.info.new_pathw = pos;
346 req->fs.info.new_pathw = NULL;
349 req->path = path;
353 req->path = (char*) pos;
356 req->flags |= UV_FS_FREE_PATHS;
362 INLINE static void uv__fs_req_init(uv_loop_t* loop, uv_fs_t* req,
365 UV_REQ_INIT(req, UV_FS);
366 req->loop = loop;
367 req->flags = 0;
368 req->fs_type = fs_type;
369 req->sys_errno_ = 0;
370 req->result = 0;
371 req->ptr = NULL;
372 req->path = NULL;
373 req->cb = cb;
374 memset(&req->fs, 0, sizeof(req->fs));
378 void fs__open(uv_fs_t* req) {
385 int flags = req->fs.info.file_flags;
474 if (!((req->fs.info.mode & ~current_umask) & _S_IWRITE)) {
546 file = CreateFileW(req->file.pathw,
559 SET_REQ_UV_ERROR(req, UV_EISDIR, error);
561 SET_REQ_WIN32_ERROR(req, GetLastError());
573 SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES);
575 SET_REQ_WIN32_ERROR(req, GetLastError());
577 SET_REQ_WIN32_ERROR(req, (DWORD) UV_UNKNOWN);
588 SET_REQ_WIN32_ERROR(req, GetLastError());
599 SET_REQ_WIN32_ERROR(req, GetLastError());
616 SET_REQ_WIN32_ERROR(req, GetLastError());
626 SET_REQ_RESULT(req, fd);
630 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
633 void fs__close(uv_fs_t* req) {
634 int fd = req->file.fd;
638 VERIFY_FD(fd, req);
656 SET_REQ_UV_ERROR(req, UV_EBADF, ERROR_INVALID_HANDLE);
658 SET_REQ_RESULT(req, 0);
683 void fs__read_filemap(uv_fs_t* req, struct uv__fd_info_s* fd_info) {
684 int fd = req->file.fd; /* VERIFY_FD done in fs__read */
695 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FLAGS);
699 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION);
703 if (req->fs.info.offset == -1) {
706 pos.QuadPart = req->fs.info.offset;
711 SET_REQ_RESULT(req, 0);
716 for (index = 0; index < req->fs.info.nbufs; ++index) {
717 read_size += req->fs.info.bufs[index].len;
722 SET_REQ_RESULT(req, 0);
736 SET_REQ_WIN32_ERROR(req, GetLastError());
742 index < req->fs.info.nbufs && done_read < read_size;
744 size_t this_read_size = MIN(req->fs.info.bufs[index].len,
750 memcpy(req->fs.info.bufs[index].base,
757 SET_REQ_WIN32_ERROR(req, err);
767 SET_REQ_WIN32_ERROR(req, GetLastError());
771 if (req->fs.info.offset == -1) {
776 SET_REQ_RESULT(req, read_size);
780 void fs__read(uv_fs_t* req) {
781 int fd = req->file.fd;
782 int64_t offset = req->fs.info.offset;
795 VERIFY_FD(fd, req);
798 fs__read_filemap(req, &fd_info);
807 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
834 req->fs.info.bufs[index].base,
835 req->fs.info.bufs[index].len,
840 } while (result && index < req->fs.info.nbufs);
846 SET_REQ_RESULT(req, bytes);
854 SET_REQ_RESULT(req, bytes);
856 SET_REQ_WIN32_ERROR(req, error);
862 void fs__write_filemap(uv_fs_t* req, HANDLE file,
864 int fd = req->file.fd; /* VERIFY_FD done in fs__write */
877 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FLAGS);
881 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION);
886 for (index = 0; index < req->fs.info.nbufs; ++index) {
887 write_size += req->fs.info.bufs[index].len;
891 SET_REQ_RESULT(req, 0);
897 } else if (req->fs.info.offset == -1) {
900 pos.QuadPart = req->fs.info.offset;
918 SET_REQ_WIN32_ERROR(req, GetLastError());
939 SET_REQ_WIN32_ERROR(req, GetLastError());
944 for (index = 0; index < req->fs.info.nbufs; ++index) {
950 req->fs.info.bufs[index].base,
951 req->fs.info.bufs[index].len);
956 SET_REQ_WIN32_ERROR(req, err);
961 done_write += req->fs.info.bufs[index].len;
966 SET_REQ_WIN32_ERROR(req, GetLastError());
971 SET_REQ_WIN32_ERROR(req, GetLastError());
975 if (req->fs.info.offset == -1) {
983 SET_REQ_RESULT(req, done_write);
986 void fs__write(uv_fs_t* req) {
987 int fd = req->file.fd;
988 int64_t offset = req->fs.info.offset;
1001 VERIFY_FD(fd, req);
1007 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
1012 fs__write_filemap(req, handle, &fd_info);
1039 req->fs.info.bufs[index].base,
1040 req->fs.info.bufs[index].len,
1045 } while (result && index < req->fs.info.nbufs);
1051 SET_REQ_RESULT(req, bytes);
1059 SET_REQ_WIN32_ERROR(req, error);
1064 void fs__rmdir(uv_fs_t* req) {
1065 int result = _wrmdir(req->file.pathw);
1067 SET_REQ_WIN32_ERROR(req, _doserrno);
1069 SET_REQ_RESULT(req, 0);
1073 void fs__unlink(uv_fs_t* req) {
1074 const WCHAR* pathw = req->file.pathw;
1090 SET_REQ_WIN32_ERROR(req, GetLastError());
1095 SET_REQ_WIN32_ERROR(req, GetLastError());
1107 SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);
1118 SET_REQ_WIN32_ERROR(req, error);
1137 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
1151 SET_REQ_SUCCESS(req);
1153 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
1160 void fs__mkdir(uv_fs_t* req) {
1161 /* TODO: use req->mode. */
1162 if (CreateDirectoryW(req->file.pathw, NULL)) {
1163 SET_REQ_RESULT(req, 0);
1165 SET_REQ_WIN32_ERROR(req, GetLastError());
1166 if (req->sys_errno_ == ERROR_INVALID_NAME ||
1167 req->sys_errno_ == ERROR_DIRECTORY)
1168 req->result = UV_EINVAL;
1172 typedef int (*uv__fs_mktemp_func)(uv_fs_t* req);
1175 void fs__mktemp(uv_fs_t* req, uv__fs_mktemp_func func) {
1186 path = (char*)req->path;
1187 len = wcslen(req->file.pathw);
1188 ep = req->file.pathw + len;
1190 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
1197 SET_REQ_UV_ERROR(req, UV_EIO, ERROR_IO_DEVICE);
1207 if (func(req)) {
1208 if (req->result >= 0) {
1216 SET_REQ_WIN32_ERROR(req, GetLastError());
1223 static int fs__mkdtemp_func(uv_fs_t* req) {
1225 if (CreateDirectoryW(req->file.pathw, NULL)) {
1226 SET_REQ_RESULT(req, 0);
1231 SET_REQ_WIN32_ERROR(req, error);
1239 void fs__mkdtemp(uv_fs_t* req) {
1240 fs__mktemp(req, fs__mkdtemp_func);
1244 static int fs__mkstemp_func(uv_fs_t* req) {
1248 file = CreateFileW(req->file.pathw,
1263 SET_REQ_WIN32_ERROR(req, error);
1277 SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES);
1279 SET_REQ_WIN32_ERROR(req, GetLastError());
1281 SET_REQ_WIN32_ERROR(req, UV_UNKNOWN);
1286 SET_REQ_RESULT(req, fd);
1292 void fs__mkstemp(uv_fs_t* req) {
1293 fs__mktemp(req, fs__mkstemp_func);
1297 void fs__scandir(uv_fs_t* req) {
1326 CreateFileW(req->file.pathw,
1462 req->ptr = dirents;
1464 req->flags |= UV_FS_FREE_PTR;
1466 SET_REQ_RESULT(req, dirents_used);
1469 req->fs.info.nbufs = 0;
1474 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
1478 SET_REQ_WIN32_ERROR(req, GetLastError());
1482 SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
1486 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
1498 void fs__opendir(uv_fs_t* req) {
1505 pathw = req->file.pathw;
1511 SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
1517 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
1532 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
1542 SET_REQ_WIN32_ERROR(req, GetLastError());
1547 req->ptr = dir;
1548 SET_REQ_RESULT(req, 0);
1554 req->ptr = NULL;
1557 void fs__readdir(uv_fs_t* req) {
1566 req->flags |= UV_FS_FREE_PTR;
1567 dir = req->ptr;
1610 SET_REQ_RESULT(req, dirent_idx);
1614 SET_REQ_WIN32_ERROR(req, GetLastError());
1621 void fs__closedir(uv_fs_t* req) {
1624 dir = req->ptr;
1626 uv__free(req->ptr);
1627 SET_REQ_RESULT(req, 0);
1845 INLINE static void fs__stat_impl(uv_fs_t* req, int do_lstat) {
1848 error = fs__stat_impl_from_path(req->file.pathw, do_lstat, &req->statbuf);
1854 fs__stat_impl(req, 0);
1857 SET_REQ_WIN32_ERROR(req, error);
1863 req->ptr = &req->statbuf;
1864 SET_REQ_RESULT(req, 0);
1899 static void fs__stat(uv_fs_t* req) {
1900 fs__stat_prepare_path(req->file.pathw);
1901 fs__stat_impl(req, 0);
1905 static void fs__lstat(uv_fs_t* req) {
1906 fs__stat_prepare_path(req->file.pathw);
1907 fs__stat_impl(req, 1);
1911 static void fs__fstat(uv_fs_t* req) {
1912 int fd = req->file.fd;
1915 VERIFY_FD(fd, req);
1920 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
1924 if (fs__fstat_handle(fd, handle, &req->statbuf) != 0) {
1925 SET_REQ_WIN32_ERROR(req, GetLastError());
1929 req->ptr = &req->statbuf;
1930 SET_REQ_RESULT(req, 0);
1934 static void fs__rename(uv_fs_t* req) {
1935 if (!MoveFileExW(req->file.pathw, req->fs.info.new_pathw, MOVEFILE_REPLACE_EXISTING)) {
1936 SET_REQ_WIN32_ERROR(req, GetLastError());
1940 SET_REQ_RESULT(req, 0);
1944 INLINE static void fs__sync_impl(uv_fs_t* req) {
1945 int fd = req->file.fd;
1948 VERIFY_FD(fd, req);
1952 SET_REQ_WIN32_ERROR(req, GetLastError());
1954 SET_REQ_RESULT(req, result);
1959 static void fs__fsync(uv_fs_t* req) {
1960 fs__sync_impl(req);
1964 static void fs__fdatasync(uv_fs_t* req) {
1965 fs__sync_impl(req);
1969 static void fs__ftruncate(uv_fs_t* req) {
1970 int fd = req->file.fd;
1977 VERIFY_FD(fd, req);
1983 SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);
1992 eof_info.EndOfFile.QuadPart = req->fs.info.offset;
2001 SET_REQ_RESULT(req, 0);
2003 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
2030 SET_REQ_WIN32_ERROR(req, GetLastError());
2045 static void fs__copyfile(uv_fs_t* req) {
2051 flags = req->fs.info.file_flags;
2054 SET_REQ_UV_ERROR(req, UV_ENOSYS, ERROR_NOT_SUPPORTED);
2060 if (CopyFileW(req->file.pathw, req->fs.info.new_pathw, overwrite) != 0) {
2061 SET_REQ_RESULT(req, 0);
2065 SET_REQ_WIN32_ERROR(req, GetLastError());
2066 if (req->result != UV_EBUSY)
2070 if (fs__stat_impl_from_path(req->file.pathw, 0, &statbuf) != 0 ||
2071 fs__stat_impl_from_path(req->fs.info.new_pathw, 0, &new_statbuf) != 0) {
2077 SET_REQ_RESULT(req, 0);
2082 static void fs__sendfile(uv_fs_t* req) {
2083 int fd_in = req->file.fd, fd_out = req->fs.info.fd_out;
2084 size_t length = req->fs.info.bufsml[0].len;
2085 int64_t offset = req->fs.info.offset;
2125 SET_REQ_RESULT(req, result);
2129 static void fs__access(uv_fs_t* req) {
2130 DWORD attr = GetFileAttributesW(req->file.pathw);
2133 SET_REQ_WIN32_ERROR(req, GetLastError());
2144 if (!(req->fs.info.mode & W_OK) ||
2147 SET_REQ_RESULT(req, 0);
2149 SET_REQ_WIN32_ERROR(req, UV_EPERM);
2155 static void fs__chmod(uv_fs_t* req) {
2156 int result = _wchmod(req->file.pathw, req->fs.info.mode);
2158 SET_REQ_WIN32_ERROR(req, _doserrno);
2160 SET_REQ_RESULT(req, 0);
2164 static void fs__fchmod(uv_fs_t* req) {
2165 int fd = req->file.fd;
2172 VERIFY_FD(fd, req);
2176 SET_REQ_WIN32_ERROR(req, GetLastError());
2187 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2202 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2211 if (req->fs.info.mode & _S_IWRITE) {
2224 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2239 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2244 SET_REQ_SUCCESS(req);
2296 INLINE static void fs__utime_impl(uv_fs_t* req, int do_lutime) {
2299 error = fs__utime_impl_from_path(req->file.pathw,
2300 req->fs.time.atime,
2301 req->fs.time.mtime,
2309 fs__utime_impl(req, 0);
2312 SET_REQ_WIN32_ERROR(req, error);
2318 SET_REQ_RESULT(req, 0);
2321 static void fs__utime(uv_fs_t* req) {
2322 fs__utime_impl(req, /* do_lutime */ 0);
2326 static void fs__futime(uv_fs_t* req) {
2327 int fd = req->file.fd;
2329 VERIFY_FD(fd, req);
2334 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
2338 if (fs__utime_handle(handle, req->fs.time.atime, req->fs.time.mtime) != 0) {
2339 SET_REQ_WIN32_ERROR(req, GetLastError());
2343 SET_REQ_RESULT(req, 0);
2346 static void fs__lutime(uv_fs_t* req) {
2347 fs__utime_impl(req, /* do_lutime */ 1);
2351 static void fs__link(uv_fs_t* req) {
2352 DWORD r = CreateHardLinkW(req->fs.info.new_pathw, req->file.pathw, NULL);
2354 SET_REQ_WIN32_ERROR(req, GetLastError());
2356 SET_REQ_RESULT(req, 0);
2360 static void fs__create_junction(uv_fs_t* req, const WCHAR* path,
2385 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_NOT_SUPPORTED);
2478 SET_REQ_WIN32_ERROR(req, GetLastError());
2493 SET_REQ_WIN32_ERROR(req, GetLastError());
2506 SET_REQ_WIN32_ERROR(req, GetLastError());
2514 SET_REQ_RESULT(req, 0);
2530 static void fs__symlink(uv_fs_t* req) {
2536 pathw = req->file.pathw;
2537 new_pathw = req->fs.info.new_pathw;
2539 if (req->fs.info.file_flags & UV_FS_SYMLINK_JUNCTION) {
2540 fs__create_junction(req, pathw, new_pathw);
2544 if (req->fs.info.file_flags & UV_FS_SYMLINK_DIR)
2550 SET_REQ_RESULT(req, 0);
2564 fs__symlink(req);
2566 SET_REQ_WIN32_ERROR(req, err);
2571 static void fs__readlink(uv_fs_t* req) {
2574 handle = CreateFileW(req->file.pathw,
2583 SET_REQ_WIN32_ERROR(req, GetLastError());
2587 assert(req->ptr == NULL);
2588 if (fs__readlink_handle(handle, (char**) &req->ptr, NULL) != 0) {
2590 SET_REQ_WIN32_ERROR(req, error);
2592 req->result = UV_EINVAL;
2597 req->flags |= UV_FS_FREE_PTR;
2598 SET_REQ_RESULT(req, 0);
2653 static void fs__realpath(uv_fs_t* req) {
2656 handle = CreateFileW(req->file.pathw,
2664 SET_REQ_WIN32_ERROR(req, GetLastError());
2668 assert(req->ptr == NULL);
2669 if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) {
2671 SET_REQ_WIN32_ERROR(req, GetLastError());
2676 req->flags |= UV_FS_FREE_PTR;
2677 SET_REQ_RESULT(req, 0);
2681 static void fs__chown(uv_fs_t* req) {
2682 SET_REQ_RESULT(req, 0);
2686 static void fs__fchown(uv_fs_t* req) {
2687 SET_REQ_RESULT(req, 0);
2691 static void fs__lchown(uv_fs_t* req) {
2692 SET_REQ_RESULT(req, 0);
2696 static void fs__statfs(uv_fs_t* req) {
2704 pathw = req->file.pathw;
2718 is_second = pathw != req->file.pathw;
2723 SET_REQ_WIN32_ERROR(req, err);
2730 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2734 ret = GetFullPathNameW(req->file.pathw,
2740 SET_REQ_WIN32_ERROR(req, err);
2746 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2756 if (pathw != req->file.pathw) {
2762 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2773 req->ptr = stat_fs;
2774 req->flags |= UV_FS_FREE_PTR;
2775 SET_REQ_RESULT(req, 0);
2780 uv_fs_t* req;
2782 req = container_of(w, uv_fs_t, work_req);
2783 assert(req->type == UV_FS);
2785 #define XX(uc, lc) case UV_FS_##uc: fs__##lc(req); break;
2786 switch (req->fs_type) {
2830 uv_fs_t* req;
2832 req = container_of(w, uv_fs_t, work_req);
2833 uv__req_unregister(req->loop, req);
2836 assert(req->result == 0);
2837 SET_REQ_UV_ERROR(req, UV_ECANCELED, 0);
2840 req->cb(req);
2844 void uv_fs_req_cleanup(uv_fs_t* req) {
2845 if (req == NULL)
2848 if (req->flags & UV_FS_CLEANEDUP)
2851 if (req->flags & UV_FS_FREE_PATHS)
2852 uv__free(req->file.pathw);
2854 if (req->flags & UV_FS_FREE_PTR) {
2855 if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
2856 uv__fs_scandir_cleanup(req);
2857 else if (req->fs_type == UV_FS_READDIR)
2858 uv__fs_readdir_cleanup(req);
2860 uv__free(req->ptr);
2863 if (req->fs.info.bufs != req->fs.info.bufsml)
2864 uv__free(req->fs.info.bufs);
2866 req->path = NULL;
2867 req->file.pathw = NULL;
2868 req->fs.info.new_pathw = NULL;
2869 req->fs.info.bufs = NULL;
2870 req->ptr = NULL;
2872 req->flags |= UV_FS_CLEANEDUP;
2876 int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
2881 err = fs__capture_path(req, path, NULL, cb != NULL);
2883 SET_REQ_WIN32_ERROR(req, err);
2884 return req->result;
2887 req->fs.info.file_flags = flags;
2888 req->fs.info.mode = mode;
2893 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
2895 req->file.fd = fd;
2901 uv_fs_t* req,
2910 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
2914 req->file.fd = fd;
2916 req->fs.info.nbufs = nbufs;
2917 req->fs.info.bufs = req->fs.info.bufsml;
2918 if (nbufs > ARRAY_SIZE(req->fs.info.bufsml))
2919 req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs));
2921 if (req->fs.info.bufs == NULL) {
2922 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2926 memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs));
2928 req->fs.info.offset = offset;
2934 uv_fs_t* req,
2943 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
2947 req->file.fd = fd;
2949 req->fs.info.nbufs = nbufs;
2950 req->fs.info.bufs = req->fs.info.bufsml;
2951 if (nbufs > ARRAY_SIZE(req->fs.info.bufsml))
2952 req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs));
2954 if (req->fs.info.bufs == NULL) {
2955 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2959 memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs));
2961 req->fs.info.offset = offset;
2966 int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
2971 err = fs__capture_path(req, path, NULL, cb != NULL);
2973 SET_REQ_WIN32_ERROR(req, err);
2974 return req->result;
2981 int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
2986 err = fs__capture_path(req, path, NULL, cb != NULL);
2988 SET_REQ_WIN32_ERROR(req, err);
2989 return req->result;
2992 req->fs.info.mode = mode;
2998 uv_fs_t* req,
3004 err = fs__capture_path(req, tpl, NULL, TRUE);
3006 SET_REQ_WIN32_ERROR(req, err);
3007 return req->result;
3015 uv_fs_t* req,
3021 err = fs__capture_path(req, tpl, NULL, TRUE);
3023 SET_REQ_WIN32_ERROR(req, err);
3024 return req->result;
3031 int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
3035 err = fs__capture_path(req, path, NULL, cb != NULL);
3037 SET_REQ_WIN32_ERROR(req, err);
3038 return req->result;
3045 int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
3050 err = fs__capture_path(req, path, NULL, cb != NULL);
3052 SET_REQ_WIN32_ERROR(req, err);
3053 return req->result;
3056 req->fs.info.file_flags = flags;
3061 uv_fs_t* req,
3067 err = fs__capture_path(req, path, NULL, cb != NULL);
3069 SET_REQ_WIN32_ERROR(req, err);
3070 return req->result;
3076 uv_fs_t* req,
3084 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3088 req->ptr = dir;
3093 uv_fs_t* req,
3098 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3101 req->ptr = dir;
3105 int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
3110 err = fs__capture_path(req, path, new_path, cb != NULL);
3112 SET_REQ_WIN32_ERROR(req, err);
3113 return req->result;
3120 int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
3125 err = fs__capture_path(req, path, new_path, cb != NULL);
3127 SET_REQ_WIN32_ERROR(req, err);
3128 return req->result;
3131 req->fs.info.file_flags = flags;
3136 int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
3141 err = fs__capture_path(req, path, NULL, cb != NULL);
3143 SET_REQ_WIN32_ERROR(req, err);
3144 return req->result;
3151 int uv_fs_realpath(uv_loop_t* loop, uv_fs_t* req, const char* path,
3158 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3162 err = fs__capture_path(req, path, NULL, cb != NULL);
3164 SET_REQ_WIN32_ERROR(req, err);
3165 return req->result;
3172 int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
3177 err = fs__capture_path(req, path, NULL, cb != NULL);
3179 SET_REQ_WIN32_ERROR(req, err);
3180 return req->result;
3187 int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_uid_t uid,
3194 int uv_fs_lchown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
3199 err = fs__capture_path(req, path, NULL, cb != NULL);
3201 SET_REQ_WIN32_ERROR(req, err);
3202 return req->result;
3209 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
3213 err = fs__capture_path(req, path, NULL, cb != NULL);
3215 SET_REQ_WIN32_ERROR(req, err);
3216 return req->result;
3223 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
3227 err = fs__capture_path(req, path, NULL, cb != NULL);
3229 SET_REQ_WIN32_ERROR(req, err);
3230 return req->result;
3237 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
3239 req->file.fd = fd;
3244 int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
3249 err = fs__capture_path(req, path, new_path, cb != NULL);
3251 SET_REQ_WIN32_ERROR(req, err);
3252 return req->result;
3259 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
3261 req->file.fd = fd;
3266 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
3268 req->file.fd = fd;
3273 int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file fd,
3276 req->file.fd = fd;
3277 req->fs.info.offset = offset;
3283 uv_fs_t* req,
3295 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3299 err = fs__capture_path(req, path, new_path, cb != NULL);
3301 SET_REQ_WIN32_ERROR(req, err);
3302 return req->result;
3305 req->fs.info.file_flags = flags;
3310 int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file fd_out,
3313 req->file.fd = fd_in;
3314 req->fs.info.fd_out = fd_out;
3315 req->fs.info.offset = in_offset;
3316 req->fs.info.bufsml[0].len = length;
3322 uv_fs_t* req,
3329 err = fs__capture_path(req, path, NULL, cb != NULL);
3331 SET_REQ_WIN32_ERROR(req, err);
3332 return req->result;
3335 req->fs.info.mode = flags;
3340 int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
3345 err = fs__capture_path(req, path, NULL, cb != NULL);
3347 SET_REQ_WIN32_ERROR(req, err);
3348 return req->result;
3351 req->fs.info.mode = mode;
3356 int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file fd, int mode,
3359 req->file.fd = fd;
3360 req->fs.info.mode = mode;
3365 int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
3370 err = fs__capture_path(req, path, NULL, cb != NULL);
3372 SET_REQ_WIN32_ERROR(req, err);
3373 return req->result;
3376 req->fs.time.atime = atime;
3377 req->fs.time.mtime = mtime;
3382 int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file fd, double atime,
3385 req->file.fd = fd;
3386 req->fs.time.atime = atime;
3387 req->fs.time.mtime = mtime;
3391 int uv_fs_lutime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
3396 err = fs__capture_path(req, path, NULL, cb != NULL);
3398 SET_REQ_WIN32_ERROR(req, err);
3399 return req->result;
3402 req->fs.time.atime = atime;
3403 req->fs.time.mtime = mtime;
3409 uv_fs_t* req,
3415 err = fs__capture_path(req, path, NULL, cb != NULL);
3417 SET_REQ_WIN32_ERROR(req, err);
3418 return req->result;
3424 int uv_fs_get_system_error(const uv_fs_t* req) {
3425 return req->sys_errno_;